Forem: Franz

🖥️ The DEC-VAX: The Machine That Changed Computing History

Franz — Wed, 31 Dec 2025 10:16:01 +0000

🎯 What Was the DEC-VAX?

The DEC-VAX (Virtual Address Extension) was a family of 32-bit minicomputers developed by Digital Equipment Corporation (DEC). The first model, the VAX-11/780, was introduced on October 25, 1977, and shipped starting in 1978. This groundbreaking computer transformed DEC from a $700 million company into a $14 billion powerhouse that seriously challenged even IBM.

🚀 The Birth of a Legend

Gordon Bell, who now works at Microsoft's research division, recognized back in 1972 that the PDP-11 minicomputer wouldn't survive the decade due to its 16-bit address space limitation. In 1975, he started working with a team of engineers to develop a computer with 32-bit addressing that remained compatible with the older PDP-11 minicomputers.

The first system shipped in 1978 to Carnegie Mellon University in Pittsburgh, followed by CERN in Switzerland and a German Max Planck Institute. 📦

💻 Technical Innovation

The VAX-11/780 ran on the VMS operating system (VAX Version 1 contained approximately one million lines of code) and featured innovative capabilities:

✅ Built-in error correction (Error Correction and Detection Code; ECC)
✅ Virtual memory support
✅ 32-bit architecture breaking the 16-bit barrier

⌨️ The VT100 Terminal Legacy

Around 1976, DEC introduced the VT100, an affordable and robust ASCII terminal whose command set remains the de-facto standard for terminal emulation programs today. These terminals, featuring the iconic gold-colored key, were used alongside VAX systems and shaped an entire generation of developers.

Fun fact: This is why Uniface still uses the "Gold Key" concept! 🔑

📈 Market Dominance

By the 1980s, DEC had become the world's second-largest computer manufacturer by revenue, right behind IBM. The company evolved a comprehensive computer family with various subfamilies - advances in chip technology miniaturized the electronics while prices steadily declined.

DEC's predecessor system, the PDP-11, had already achieved remarkable success with over 600,000 units sold. The VAX family continued this legacy throughout the 1980s. 🌍

🔚 The End of an Era

In 1992, the death knell rang for VAX systems when DEC introduced the RISC CPU "21064" (codename: Alpha) - a 64-bit RISC processor, in contrast to the 32-bit CISC architecture of VAX computers. With the retirement of the VAX, a significant chapter in computing history came to an end.

🎓 Legacy Impact

The VAX systems influenced:

Modern operating system design (VMS concepts live on in OpenVMS)
Terminal standards (VT100 emulation)
Enterprise computing architecture
Developer workflows and tooling

Understanding the VAX era helps us appreciate why certain "legacy" systems work the way they do today! 🏛️

Have you worked with VAX systems or encountered their legacy in modern software? Share your stories in the comments! 💬

Note: This article was created with the assistance of AI to research and compile historical information about DEC-VAX systems.

🔑 The Gold Key in Uniface - A Relic from the VAX Era

Franz — Wed, 31 Dec 2025 10:07:00 +0000

🤔 What is the Gold Key?

The Gold Key is a special key in Uniface that modifies the behavior of subsequently typed characters. This function originates from the original development of Uniface on DEC-VAX machines, whose terminals actually had a gold-colored or yellow key on the keyboard.

A true piece of computing history! 🖥️✨

⌨️ How to Use the Gold Key Today

On Microsoft Windows, there are several options:

Standard Mapping

Numeric Keypad: + (Plus key on the numpad)
Without Numpad: Ctrl + Shift + F1 (press simultaneously)
Web Applications: \ (Backslash)

💡 Practical Use Cases

1. Enter Special Characters 📝

Gold Key + ; (semicolon) creates a Gold-semicolon, which serves as a subfill separator in Uniface lists

2. Wildcard Search 🔍

Gold + * for data query profiles

3. Structure Editor Functions ⚡

Gold + R = Retrieve
Gold + , = Find Again

🛠️ Configuration

Gold Key combinations are defined with ^GOLD_BASE_SET and are available by default in all keyboard translation tables.

🎯 Conclusion

The Gold Key may seem antiquated at first glance, but it remains an integral part of Uniface operation today. A perfect example of how legacy systems carry their history with them! 🚀

Do you have more Uniface tips? Share them in the comments! 💬

Note: This article was created with the assistance of AI to research and compile information about Uniface's Gold Key functionality.

🔌 MySQL Connector in Uniface 10.4: A Developer's Guide

Franz — Tue, 23 Dec 2025 09:02:48 +0000

Note: This blog post was created with AI assistance and is based on the official Uniface 10.4 documentation for the MySQL connector.

Introduction: Why MySQL Integration Matters for Uniface Developers

If you're working with Uniface 10.4, you're likely maintaining enterprise applications built with this powerful low-code platform. MySQL has become one of the most popular open-source relational database management systems, offering cost-effective data storage and compatibility with modern cloud platforms.

Whether you're integrating with existing MySQL databases, modernizing legacy systems, or building new functionality, understanding the MySQL connector in Uniface is essential. This guide covers the core features, installation requirements, and practical setup based on official documentation.

What is the MySQL Connector in Uniface?

The MySQL DBMS connector is a database driver that enables Uniface applications to interact with MySQL database servers. It provides a bridge between Uniface's data model and MySQL's relational database structure.

Key Connector Information

Aspect	Details
Connector Mnemonic	MQL
SQL Support	✅ Supported
Stored Procedures Support	✅ Supported
Create Table Utility	✅ Supported
Load Definitions Utility	✅ Supported
Create Scripts Utility	❌ Not Supported

Understanding the Utilities

Create Table: Allows you to generate MySQL tables directly from Uniface entity definitions in your application model
Load Definitions: Enables reverse engineering—importing existing MySQL table structures into Uniface entities
Create Scripts: Cannot generate standalone SQL script files (use alternative methods if needed)

Platform and Version Support

The MySQL connector is available for Uniface 10.4 across multiple supported platforms. For the complete list of supported platforms and MySQL versions, consult the official Platform Availability Matrix.

Installation: The Critical Setup Steps ⚙️

The MySQL connector requires proper configuration to function. Here's what you need to know:

Requirement: libmysql.dll

To use the MySQL connector in Uniface, you must copy libmysql.dll from your MySQL installation to your Uniface installation.

Essential Step:

Locate libmysql.dll in your MySQL Connector/C installation folder
Copy it to: <Uniface Installation>\common\bin\

⚠️ The 32-bit vs. 64-bit Compatibility Issue

This is critical: The 32-bit and 64-bit versions of libmysql.dll are not binary compatible.

You must ensure:

If running 32-bit Uniface → copy the 32-bit libmysql.dll
If running 64-bit Uniface → copy the 64-bit libmysql.dll

Using the wrong architecture will result in library loading errors. Always verify which version of Uniface you're running before copying the DLL.

Configuring the MySQL Connector in Uniface

Configuration is handled through Uniface's assignment files (.asn files). The specific syntax and options depend on your Uniface configuration.

Basic Setup Process

Open your assignment file in the Uniface IDE or text editor
Define the logical database path with the MQL mnemonic
Configure connection parameters (hostname, database name, credentials)
Test the connection before deploying

For detailed configuration options and parameters specific to your environment, refer to the official Uniface 10.4 documentation on database connector configuration.

Supported Features in Detail

SQL Support

The MySQL connector supports SQL statements, allowing you to execute queries directly from Uniface applications.

Stored Procedures

MySQL stored procedures are fully supported. You can call existing stored procedures from Uniface and handle their results. This is useful for:

Complex business logic encapsulated in the database
Performance-critical operations
Reusing existing database code

Important consideration: When working with stored procedures, ensure proper error handling on both the Uniface and MySQL sides.

Important Naming Considerations

When using MySQL with Uniface, be aware of naming rules:

Uniface requires uppercase names in the application model definition
MySQL has reserved words that cannot be used for table or entity names
Always check the official documentation for reserved words in your MySQL version

Common Scenarios

Creating Tables from Uniface

Use the Create Table utility when:

You're building a new application with a database
You want tables generated automatically from your entity model
You need consistent naming and structure across entities

Importing Existing Database Structures

Use Load Definitions when:

You're integrating with an existing MySQL database
You need to reverse-engineer database schema into Uniface entities
You're migrating from another system to Uniface

Troubleshooting Tips

Connection Issues

If Uniface cannot load the MySQL connector:

Verify libmysql.dll is in <Uniface>\common\bin\
Check that the DLL architecture matches your Uniface installation (32-bit or 64-bit)
Ensure all required files are properly copied
Verify database connectivity settings in your assignment file

Library Loading Errors

Common error messages indicate:

Missing libmysql.dll
Architecture mismatch (32-bit/64-bit)
Missing dependencies

Naming and Reserved Words

If table creation fails:

Check for reserved MySQL keywords in your entity names
Review naming rules in the Uniface documentation for MySQL
Ensure compliance with both Uniface and MySQL naming conventions

U_VERSION Mechanism for Locking

The MySQL connector supports the U_VERSION mechanism, which is recommended for improving locking performance in concurrent environments. Consult the Uniface documentation for implementation details.

Best Practices for MySQL Integration

Configuration Management

Store connection credentials securely
Use the Platform Availability Matrix to verify version compatibility
Test all database operations thoroughly before production deployment

Development Workflow

Design your data model in Uniface first
Generate tables using Create Table utility, or
Import existing schema using Load Definitions
Test SQL statements and stored procedure calls
Deploy with proper configuration management

Using Stored Procedures Effectively

Keep procedures focused on specific business logic
Document procedure parameters and expected results
Handle errors appropriately in both database and Uniface layers
Test procedures independently before integration

Referential Integrity

MySQL connector supports referential integrity management. Review the documentation for how to properly implement and maintain referential integrity constraints in your application.

Conclusion

The MySQL connector in Uniface 10.4 provides robust support for integrating MySQL databases with your enterprise applications. Key points to remember:

✅ Always match the libmysql.dll architecture (32-bit/64-bit) to your Uniface installation
✅ Use Create Table for forward engineering and Load Definitions for reverse engineering
✅ MySQL stored procedures are fully supported
✅ Follow Uniface naming rules and avoid MySQL reserved words
✅ Consult the Platform Availability Matrix for version compatibility
✅ Test thoroughly before production deployment

By following these guidelines and referring to the official documentation, you can successfully integrate MySQL with your Uniface 10.4 applications.

Sources and References

Uniface 10.4 MySQL Connector Documentation (December 15, 2025)
Rocket Software Platform Availability Matrix
Rocket Uniface Community Documentation

Have you integrated MySQL with Uniface? What challenges did you encounter? Share your experiences in the comments! 💬

🔐 Connecting Uniface 10.4 to LDAP Servers: A Complete Guide

Franz — Tue, 23 Dec 2025 08:43:36 +0000

Subtitle: Unlock the power of Directory Services in your Uniface applications with the 10.4 LDAP Connector.

In the world of enterprise development, applications rarely live in isolation. They need to talk to other systems, and one of the most common requirements is authentication and user management. This is where LDAP comes in.

If you are a Uniface developer working with version 10.4, you have a powerful tool at your disposal: the Uniface LDAP Connector.

In this guide, we will break down exactly how to configure, use, and troubleshoot this connector, with a special deep dive into the addbase option. Whether you are a veteran dealing with legacy systems or a modern developer integrating new directories, this guide is for you! 🚀

1. What is LDAP? (A Quick Refresher) 📚

Before we dive into the code, let's clarify a few terms for those who might be new to this specific domain.

LDAP (Lightweight Directory Access Protocol): Think of LDAP as a highly optimized, digital phonebook. It is a protocol used to access and manage distributed directory information services over an IP network. It's "Lightweight" because it was designed as a simpler alternative to the older, heavier X.500 standard.
X.500: This was the original "granddaddy" of directory standards. It was comprehensive but very complex and heavy on network resources. LDAP kept the directory structure of X.500 but streamlined the way we talk to it.
IPv6: You might see references to this in networking docs. It stands for "Internet Protocol version 6." It's the modern address system for the internet, replacing the older IPv4. Uniface and modern LDAP servers fully support IPv6, ensuring your application is future-proof.

In simple terms: If your company uses Microsoft Active Directory (AD) or OpenLDAP to store user passwords and emails, you use LDAP to talk to it.

2. The Uniface LDAP Connector 🔌

Uniface doesn't treat LDAP like a weird external service; it treats it like a database.

This is the magic of the Uniface architecture. You define an Entity (table) in your model, map it to an LDAP Object Class (like person or organizationalUnit), and use standard Uniface ProcScript commands (retrieve, store, delete) to manipulate data.

Key Capabilities:

✅ Authentication: Verify user credentials (bind).
✅ CRUD Operations: Create, Read, Update, and Delete directory entries.
✅ SSL/TLS Support: Secure your connection (essential for production).
✅ Hierarchy Management: Navigate the tree structure of a directory.

3. Configuration and Setup ⚙️

The connection behavior is controlled by the USYS$LDP_PARAMS setting in your assignment file (usually .asn). You configure this in the [DRIVER_SETTINGS] section.

The Assignment File Syntax

[DRIVER_SETTINGS]
USYS$LDP_PARAMS = addbase=on, searchscope=sub, identifier case=lower, logon timeout=10

Options Reference

Option	Description	Recommended Value
`addbase`	(See Deep Dive below) Controls automatic DN concatenation.	`on`
`identifier case`	Determines if field names are case-sensitive.	`lower`
`logon timeout`	How long (in seconds) to wait for the server to accept a login.	`10`
`nulldefault`	Controls if empty fields are saved as `NULL` or empty strings.	`N`
`searchscope`	Defines how deep the search goes (`base`, `one`, or `sub`).	`sub`
`stepsize`	Controls batch fetching size. Higher values = better performance.	`50`
`tls server validation`	Checks if the server's certificate is valid.	`on`

4. Deep Dive: The `addbase` Option 🕵️‍♂️

One of the most useful (but often misunderstood) settings in the LDAP driver is addbase.

What does it do?

The addbase option controls whether Uniface automatically appends the Base DN (Distinguished Name) defined in your path to the names you use in your ProcScript code.

addbase=on (Default/Recommended): Uniface saves you typing. You only need to provide the "Relative" Distinguished Name (RDN).
addbase=off: You are in full control but must provide the full Distinguished Name for every operation.

Example in Action

Imagine your Base DN is dc=example,dc=com and you want to search for a user named jdoe inside the users container.

With addbase=on:

; You write cleaner code:
read (U_NAME = "cn=jdoe,ou=users")

; Uniface actually sends this to the server:
; "cn=jdoe,ou=users,dc=example,dc=com"

With addbase=off:

; You must write the full path every time:
read (U_NAME = "cn=jdoe,ou=users,dc=example,dc=com")

When should you turn it OFF?

You might want to set addbase=off if your application needs to access objects strictly outside of your defined Base DN, or if you are dynamically constructing complex DNs that might not follow the standard hierarchy of your main tree. For 95% of use cases, keeping it on reduces bugs and makes code more readable.

5. Practical Use Cases & Code Examples 💻

Scenario A: User Login (Authentication)

Instead of writing complex API calls, you simply try to "log on" to the LDAP path.

; Trigger: Detail Button (Login)
variables
  string vUsername, vPassword
endvariables

vUsername = FIELD_USER
vPassword = FIELD_PASS

; Format: $logon(Path, Username, Password)
$logon("LDAP_PATH", vUsername, vPassword)

if ($status < 0)
  message/error "Login Failed! Check credentials."
else
  message/info "Welcome, %%vUsername! 🔓"
endif

Scenario B: Searching for a User

Assume you have modeled an entity named INETORGPERSON.

; Trigger: Read
read
if ($status < 0)
   message/info "No users found."
endif
; Note: With addbase=on, the search is automatically 
; restricted to your Base DN subtree.

6. Platform-Specific Notes & Troubleshooting 🚧

Linux vs. Windows 🐧🪟

Windows: Uses the built-in Windows Secure Channel (Schannel). It usually "just works" if your machine trusts the domain controller.
Unix/Linux: You often need to explicitly point to your certificate bundle using the tls ca file option.
- Example: USYS$LDP_PARAMS = tls ca file=/etc/ssl/certs/ca-bundle.crt

Common Pitfalls

"Table not found": Your Uniface Entity name must match the LDAP Object Class exactly.
Slow Searches: If addbase=on and searchscope=sub are set on the root of a massive directory, you might timeout. Try narrowing your Base DN in the path definition (e.g., ou=london,dc=company,dc=com).
Connection Refused: Check firewall rules and ensure IPv6 isn't blocking you if your server is configured for IPv4 only.

7. Conclusion ✅

The Uniface 10.4 LDAP connector bridges the gap between your sturdy legacy logic and modern directory services. By correctly utilizing options like addbase, you can write cleaner, more maintainable code that integrates seamlessly with enterprise identity systems.

Go ahead and integrate that directory! Happy coding! 👩‍💻👨‍💻

Transparency Note: This article was created with AI assistance to help structure technical documentation effectively.

🔐 Mastering LDAP Integration in Uniface 10.4: The Native Way

Franz — Tue, 23 Dec 2025 08:35:35 +0000

This article was created with AI assistance, synthesizing official Rocket Uniface 10.4 documentation with practical implementation patterns.

Connecting legacy enterprise applications to modern directory services is a classic integration challenge. While many developers attempt to build complex wrappers or external call-outs, Uniface 10.4 provides a native LDAP Connector (LDP).

This connector is powerful because it allows you to treat a hierarchical Directory Service almost exactly like a relational database. This guide will show you how to configure and use it correctly using native ProcScript.

📚 What is LDAP? (For the Uninitiated)

Before we dive into code, let's clarify the terminology:

LDAP (Lightweight Directory Access Protocol): Think of it as a specialized database optimized for reading data. Unlike a standard SQL database that balances reading and writing, LDAP is designed for scenarios where you write once (create a user) but read millions of times (verify a login).
X.500: This is the "grandparent" standard. It defined the comprehensive model for directory services. LDAP was created as a lighter, more efficient way (via TCP/IP) to access X.500 directories. Uniface supports both pure LDAP and X.500 gateways.
IPv6: The modern version of the Internet Protocol. The Uniface LDAP connector is fully compatible with IPv6 addresses (e.g., [2001:db8::1]), ensuring your application is future-proof.

🔌 The Uniface Approach: Driver, Not Service

A common misconception is that you "call" LDAP like a web service. In Uniface, you don't. You use the LDP driver.

This means you interact with LDAP using standard Uniface I/O commands:

retrieve to search for users.
open to authenticate.
store to update attributes (if permissions allow).

🛠️ Step 1: Configuration (The ASN File)

The magic happens in the Assignment File (.asn). You need to define the driver and map a logical path to your LDAP server.

[SETTINGS]
; Load the LDAP driver (ensure the version matches your install, e.g., U3.0 or similar)
USYS$LDP = LDP

; Enable debug logging - crucial for seeing what happens under the hood!
LDAP_DEBUG = 1
LDAP_TIMEOUT = 10

[PATHS]
; Syntax: $PATH_NAME = LDP:ServerName:Port:BaseDN
; 'BaseDN' is the root folder where your search begins.
$AD_PROD = LDP:ad.company.com:389:DC=company,DC=com

; For SSL/TLS (LDAPS), typically use port 636
$AD_SECURE = LDP:ad.company.com:636:DC=company,DC=com

[ENTITIES]
; Map your Uniface entities to the logical path
USER.AD  = $AD_PROD
GROUP.AD = $AD_PROD

📝 Step 2: The Data Model

LDAP is hierarchical, but Uniface is relational. We bridge this gap by mapping:

LDAP Class ➡️ Uniface Entity
Distinguished Name (DN) ➡️ Primary Key

In your Uniface Model:

Create an entity (e.g., USER)
Create a field DN (String, approx C256) and mark it as the Primary Key.
Create fields for attributes you want (e.g., CN, MAIL, TELEPHONENUMBER).

⚠️ Important: The field names in Uniface must match the LDAP attribute names (case-insensitive in Uniface, but usually lowercase in LDAP schema).

💻 Step 3: Practical Examples

Use Case A: User Authentication (The Login)

To check a password, we don't need a complex query. We simply try to open a connection using the specific user's credentials. If the server accepts the connection, the password is correct.

operation user_login
params
    string p_username : IN
    string p_password : IN
endparams

variables
    string v_connection_string
endvariables

    ; Construct the dynamic path string
    ; Syntax: LDP:Host:Port:BaseDN|Username|Password
    ; Note: Active Directory often requires 'domain\user' or 'user@domain'
    v_connection_string = "LDP:ad.company.com:389:DC=company,DC=com|%%p_username|%%p_password"

    ; Attempt to open the path
    ; The 'b' flag is best practice here to skip table verification checks
    open v_connection_string, "b"

    if ($status < 0)
        ; Connection refused (Wrong password, account locked, or server down)
        return -1
    endif

    ; Security Best Practice: Close the connection immediately!
    ; You don't want to keep a session open with the user's privileges.
    close v_connection_string

    return 1 ; Success
endoperation

Use Case B: Finding a User (The Search)

To find a user, use the standard retrieve command. Uniface translates your profile fields into an LDAP filter.

operation find_employee
params
    string p_search_name : IN
endparams

    clear/e "USER"

    ; Set the search profile
    ; This translates to an LDAP filter like (cn=Smith*)
    CN.USER = "%%p_search_name%%*"

    ; Execute the search
    retrieve/e "USER"

    if ($status < 0)
        message "Error or no data found: %%$status"
        return
    endif

    ; Loop through results
    setocc "USER", 1
    while ($status > 0)
        putmess "Found: %%CN.USER - %%MAIL.USER"
        setocc "USER", $orc + 1
    endwhile
endoperation

🐧 Platform Specifics: Linux vs. Windows

While the ProcScript code stays the same, the environment setup differs slightly.

Windows 🪟

Certificates: The connector typically uses the Windows Certificate Store. If your organization uses a private CA for LDAPS, ensure the Root CA is installed in the Windows Trusted Root store.
Authentication: Integration with Active Directory is usually seamless.

Linux 🐧

Certificates: You must explicitly tell the driver where to find certificates if they aren't in the standard OpenSSL location. Add this to your .asn file:

[SETTINGS]
LDAP_CACERTFILE = /etc/pki/tls/certs/ca-bundle.crt
LDAP_CERTFILE   = /path/to/client-cert.pem
LDAP_KEYFILE    = /path/to/client-key.pem

⚡ Troubleshooting & Best Practices

"Table Not Found" (-13): This is the most common error. It usually means your Base DN is incorrect. If Uniface looks in OU=Sales but the user is in OU=IT, it won't find the "table" (object).
Performance: Never do a retrieve without setting a profile field (like CN or SAMACCOUNTNAME). An unbounded search attempts to download the entire directory, which will time out or crash your application.
Encoding: LDAP v3 uses UTF-8. Ensure your Uniface application handles Unicode correctly, otherwise, characters like é or ü in names will appear corrupted.
Read-Only Mindset: While store commands exist, AD permissions are complex. It is generally safer and easier to use Uniface for reading/authenticating and use specialized tools (or PowerShell scripts invoked by Uniface) for creating accounts.

🏁 Conclusion

The Uniface LDAP connector eliminates the need for external DLLs or Java wrappers. By understanding that LDAP is just another "database" to Uniface, you can use the standard commands you already know (open, retrieve) to build secure, integrated enterprise applications.

Happy coding! 🚀

Connecting Uniface 10.4 to LDAP Servers: A Complete Guide 🔐

Franz — Tue, 23 Dec 2025 08:27:13 +0000

This article was created with AI assistance to provide accurate technical documentation for the developer community.

If you're working with legacy enterprise systems, you've probably encountered the challenge of integrating directory services. Today, I'll walk you through the Uniface 10.4 LDAP Connector - a powerful tool that bridges the gap between your Uniface applications and enterprise directory services.

📚 Table of Contents

What is LDAP?
Understanding the Uniface LDAP Connector
Supported Features and Operations
Real-World Use Cases
Configuration and Setup
Platform-Specific Considerations
Best Practices and Common Issues
Conclusion

What is LDAP? 🤔

Before diving into the Uniface connector, let's understand what LDAP actually is.

LDAP (Lightweight Directory Access Protocol) is an industry-standard protocol used to access and manage directory information services over a network. Think of it as a specialized database optimized for read-heavy operations, storing information in a hierarchical tree structure.

Key Concepts:

📖 X.500 Standard: LDAP was originally designed as a lightweight alternative to the X.500 Directory Access Protocol (DAP). While X.500 required the heavy OSI protocol stack, LDAP runs directly over TCP/IP, making it much more practical for modern networks.

🌳 Hierarchical Structure: Data in LDAP is organized like a tree, with a root at the top and branches leading to individual entries (called "Distinguished Names" or DNs).

🔍 Common Operations: LDAP supports standard operations including:

Search: Query the directory for specific entries
Bind: Authenticate a user (verify credentials)
Add: Create new directory entries
Modify: Update existing entries
Delete: Remove entries from the directory

Why Use LDAP?

LDAP is perfect for centralized authentication in enterprise environments. Instead of managing user credentials separately in each application, you maintain a single source of truth. Applications like:

Jenkins 🛠️
Kubernetes ☸️
OpenVPN 🔒
Atlassian products (Jira, Confluence) 📊
Samba file servers 📁

...all commonly integrate with LDAP directories for user authentication.

Understanding the Uniface LDAP Connector 🔌

The Uniface LDAP connector (mnemonic: LDP) enables Uniface applications to communicate with LDAP servers seamlessly. This includes both standalone LDAP servers and X.500 Directory System Agents with an LDAP gateway.

Technical Specifications:

Specification	Details
Connector Mnemonic	LDP
Protocol Version	LDAP V3
Windows Implementation	Native LDAP (32-bit and 64-bit)
Unix/Linux Implementation	OpenLDAP
Connection Types	TCP (unencrypted) and TLS (encrypted)
Unicode Support	Full Unicode range (independent of $DEF_CHARSET)

Important IPv6 Note 🌐

The LDP connector supports IPv6 through hostname resolution using DNS or the local hosts file. However, direct IPv6 address input is not yet available. This means you'll need to configure DNS entries or host file entries for IPv6-enabled LDAP servers rather than using literal IPv6 addresses.

Example:

# Instead of using literal IPv6 address
ldap://[2001:db8::1]:389  ❌

# Use hostname resolution
ldap://ldap-server.example.com:389  ✅

Supported Features and Operations 🛠️

The Uniface LDAP connector provides comprehensive functionality within the limitations of the LDAP protocol:

Core Capabilities:

✅ Read Operations

Retrieve individual entries by Distinguished Name (DN)
Access specific attributes from directory entries
Handle multi-valued attributes

✅ Write Operations

Create new entries in the LDAP directory
Update existing entries (modify attributes)
Delete entries from the directory

✅ Search Operations

Execute complex search queries with filters
Search across subtrees or single levels
Return specific attributes or complete entries

✅ Connection Management

Establish secure connections using TLS
Authenticate using credentials stored in .asn files
Close connections gracefully

Configuration Through .asn Files 📝

All connection settings are stored in Uniface assignment files (.asn). This includes:

Server address and port: Where to connect
Base DN: The starting point in the directory tree
Authentication credentials: Username and password for binding
Connection parameters: Timeout values, SSL/TLS settings

Real-World Use Cases 💼

Let's explore practical scenarios where the Uniface LDAP connector shines:

1. Enterprise Single Sign-On (SSO)

Scenario: A large organization uses Uniface applications for business operations and needs centralized authentication.

; Example: Authenticate user against LDAP
operation AuthenticateUser
  parameters
    string vUsername
    string vPassword
  endparameters

  variables
    string vDN
    string vResult
  endvariables

  ; Build Distinguished Name
  vDN = "uid=%%vUsername%%,ou=users,dc=company,dc=org"

  ; Attempt LDAP bind
  activate "LDAP_AUTH".bind(vDN, vPassword)

  ; Check result
  if ($status = 0)
    putmess "Authentication successful"
  else
    putmess "Authentication failed"
  endif

end ; AuthenticateUser

2. User Profile Synchronization

Scenario: Automatically sync user information from Active Directory to Uniface application entities.

; Example: Retrieve user details from LDAP
operation GetUserProfile
  parameters
    string vUsername
  endparameters

  variables
    string vEmail
    string vFullName
    string vDepartment
  endvariables

  ; Search for user
  retrieve LDAP_USER, 1
    where (LDAP_USER.UID = vUsername)

  if ($status = 0)
    ; Map LDAP attributes to variables
    vEmail = LDAP_USER.MAIL
    vFullName = LDAP_USER.CN
    vDepartment = LDAP_USER.DEPARTMENT
  endif

end ; GetUserProfile

3. Dynamic Group Management

Scenario: Query LDAP groups to determine user permissions dynamically.

Real-world benefit: Instead of maintaining duplicate group memberships in your Uniface database, query LDAP at runtime to check if users belong to specific groups (e.g., "Administrators", "Finance_Staff", "ReadOnly_Users").

Configuration and Setup ⚙️

Here's how to configure the Uniface LDAP connector step by step:

Step 1: Configure the .asn File

Create or edit your assignment file with LDAP settings:

[DRIVER_SETTINGS]
; Define the LDAP connector
LDAP_DRIVER = LDP

[ENTITIES]
; Map your Uniface entities to LDAP structure
LDAP_USER = LDAP_DRIVER, ou=users,dc=company,dc=com
LDAP_GROUP = LDAP_DRIVER, ou=groups,dc=company,dc=com

[LDAP_DRIVER]
; Connection parameters
Server = ldap.company.com
Port = 389
; For TLS/SSL connection use port 636

; Base DN for searches
BaseDN = dc=company,dc=com

; Bind credentials (authentication)
BindDN = cn=uniface_service,ou=service_accounts,dc=company,dc=com
BindPassword = YourSecurePassword

; Connection options
Timeout = 30
Version = 3

Step 2: Define Entity Keys

Each LDAP entity in your Uniface model needs a unique identifier:

[LDAP_USER]
; Define the key attribute
Key = uid

; Map Uniface fields to LDAP attributes
UID = uid
EMAIL = mail
FULL_NAME = cn
FIRST_NAME = givenName
LAST_NAME = sn
DEPARTMENT = ou

Step 3: Enable TLS/SSL (Recommended) 🔒

For production environments, always use encrypted connections:

[LDAP_DRIVER]
Server = ldaps.company.com
Port = 636
SSL = yes
; or for STARTTLS on port 389
UseTLS = yes

Security Best Practice: Never store credentials in plain text in production .asn files. Use environment variables or encrypted configuration management tools.

Step 4: Test the Connection

; Test LDAP connectivity
operation TestLDAPConnection
  variables
    string vResult
  endvariables

  ; Attempt to open connection
  activate "LDAP_DRIVER".open

  if ($status = 0)
    putmess "LDAP connection successful!"
    activate "LDAP_DRIVER".close
  else
    putmess "Connection failed: %%$status%%"
  endif

end ; TestLDAPConnection

Platform-Specific Considerations 🖥️

Linux/Unix Requirements

On Linux systems, the LDAP connector requires the OpenLDAP package to be installed:

Debian/Ubuntu:

sudo apt update
sudo apt install slapd ldap-utils libldap-2.4-2

Red Hat/CentOS:

sudo yum install openldap openldap-clients openldap-servers

SUSE/openSUSE:

sudo zypper install openldap2 openldap2-client

⚠️ Important: Make sure you install the OpenLDAP version that is current for your operating system version. Outdated packages may have security vulnerabilities or compatibility issues.

Windows Considerations

Windows systems use the native LDAP implementation (Wldap32.dll), which is included with the operating system. No additional packages are required.

Active Directory Integration: When connecting to Microsoft Active Directory:

[AD_DRIVER]
Server = ad.company.local
Port = 389
; Use Windows domain format for bind DN
BindDN = COMPANY\\uniface_service
; or UPN format
BindDN = uniface_service@company.local

Platform Independence ✨

One of LDAP's greatest strengths is its platform independence. Unlike Active Directory (which is Windows-centric), LDAP works seamlessly across:

Windows Server environments
Linux/Unix systems
macOS
Mixed heterogeneous networks

This makes the Uniface LDAP connector ideal for organizations with diverse infrastructure.

Best Practices and Common Issues 🎯

Security Best Practices 🔐

1. Always Use TLS/SSL

Never send credentials over unencrypted connections in production:

; ❌ Insecure
Port = 389
SSL = no

; ✅ Secure
Port = 636
SSL = yes

2. Use Service Accounts

Create dedicated LDAP service accounts for Uniface applications with minimal required privileges:

# Example: Create restricted service account
dn: cn=uniface_service,ou=service_accounts,dc=company,dc=com
objectClass: inetOrgPerson
cn: uniface_service
sn: Service Account
userPassword: {SSHA}encrypted_hash_here
description: Uniface application authentication service

3. Implement Connection Pooling

Reuse LDAP connections where possible to reduce overhead:

; Keep connection open for multiple operations
activate "LDAP_DRIVER".open

; Perform multiple operations...
; ... retrieve user 1
; ... retrieve user 2
; ... search groups

; Close when done
activate "LDAP_DRIVER".close

Common Issues and Solutions 🔧

Issue 1: Authentication Failures

Symptoms: Bind operations fail with "Invalid credentials" error

Common Causes:

Incorrect BindDN format
Expired service account password
Insufficient permissions

Solution:

# Test credentials manually
ldapsearch -x -H ldap://server:389 \
  -D "cn=uniface_service,ou=service_accounts,dc=company,dc=com" \
  -W \
  -b "dc=company,dc=com" \
  "(objectClass=*)"

Issue 2: Connection Timeouts

Symptoms: Operations hang or timeout

Common Causes:

Firewall blocking LDAP ports (389, 636)
Network latency
LDAP server overloaded

Solution:

; Increase timeout values
[LDAP_DRIVER]
Timeout = 60
NetworkTimeout = 30

Issue 3: SSL/TLS Certificate Errors

Symptoms: "Certificate verification failed" errors

Common Causes:

Self-signed certificates not trusted
Expired certificates
Hostname mismatch

Solution:

# Add CA certificate to trusted store (Linux)
sudo cp ldap-ca-cert.pem /usr/local/share/ca-certificates/
sudo update-ca-certificates

Issue 4: Character Encoding Problems

Symptoms: Special characters (ä, ö, ü, ß, é, ñ) displayed incorrectly

Solution: The Uniface LDAP connector uses Unicode exclusively. Ensure your .asn file specifies UTF-8 encoding:

[SETTINGS]
$NLS_ENCODING = UTF-8

Issue 5: Performance Issues with Large Directories

Symptoms: Slow search operations

Solution: Use indexed attributes and implement pagination:

; Use paged results for large searches
operation SearchUsersWithPaging
  variables
    numeric vPageSize
    string vCookie
  endvariables

  vPageSize = 100

  ; Implement paging logic
  ; (pseudocode - actual implementation varies)

end ; SearchUsersWithPaging

Testing and Debugging Tips 🔍

1. Use LDAP Browser Tools

Tools like Apache Directory Studio or JXplorer help you:

Visualize directory structure
Test search filters
Verify attribute names
Check permissions

2. Enable Verbose Logging

[SETTINGS]
$LDAP_DEBUG = 1
$TRACE = ALL

3. Test with Command-Line Tools

# Test basic connectivity
ldapsearch -x -H ldap://server:389 -b "dc=company,dc=com"

# Test TLS
ldapsearch -x -H ldap://server:389 -ZZ -b "dc=company,dc=com"

# Test authentication
ldapsearch -x -H ldap://server:389 \
  -D "cn=user,dc=company,dc=com" \
  -W -b "dc=company,dc=com"

Conclusion 🎉

The Uniface 10.4 LDAP Connector is a powerful integration tool that brings enterprise-grade directory services to your legacy applications. By understanding its capabilities and following best practices, you can:

✅ Implement centralized authentication

✅ Reduce administrative overhead

✅ Improve security posture

✅ Enable SSO capabilities

✅ Integrate seamlessly with existing infrastructure

Key Takeaways:

LDAP is a protocol, not a product - it works across platforms
X.500 compatibility means broad directory support
TLS/SSL is mandatory for production environments
IPv6 support requires DNS hostname resolution
Platform-specific requirements vary (OpenLDAP on Linux, native on Windows)

Next Steps 🚀

Review your organization's LDAP directory structure
Install required OpenLDAP packages (Linux)
Configure your .asn file with connection parameters
Test authentication in a development environment
Implement proper error handling
Plan migration strategy for production

Resources 📚

Have you integrated Uniface with LDAP? Share your experiences, challenges, or tips in the comments below! 💬

Note: This guide is based on Uniface 10.4 documentation. Always refer to your specific version's documentation and consult with your system administrators before implementing changes in production environments.

Uniface 10.4 & Informix: Decoding Error Messages 🔍

Franz — Tue, 23 Dec 2025 08:08:39 +0000

Hey developers! 👋

If you work with Uniface 10.4 and Informix, you know that robust error handling is key. Sometimes, the message frame shows you an error, but it can be confusing. Is it Uniface? Is it the Connector? Is it the Informix database itself?

In this post, I will help you understand the different types of error messages and give you a cheat sheet for the specific Connector return values.

🤖 This blog post was created with the help of an AI assistant, based on the official Uniface documentation.

Two Types of Messages 📧

First, you need to spot the difference between a Connector error and a native Informix error. They look different in the message frame.

1. Connector Errors

These are errors generated by the Uniface driver itself (before or during communication with the database).

Syntax:

Connector {ERROR|WARNING} (Number): Message

2. Informix Errors

These come directly from the DBMS. They include the SQLSTATE and SQLCODE.

Syntax:

Informix {ERROR|WARNING|NO DATA} (SQLSTATE: sqlstate ): Message SQLCODE sqlcode: Message

The $dberror Variable 🕵️

When an error happens, Uniface stores the last error code in the $dberror variable. This is what you check in your ProcScript code.

Here is the breakdown of what the values in $dberror mean:

Value	Meaning
0	Success, no error. Everything worked perfectly. ✅
< 0	Error detected by Informix. A negative number means the DBMS reported an issue. 🔴
20–29	Connector errors. A positive number in this range means the Connector found an issue. 🟠

Connector Error Cheat Sheet 📝

If you see a positive number in $dberror between 20 and 29, it is one of these specific Connector issues. Keep this list handy!

$dberror	Message
20	The requested function/mode is not supported.
21	The specified database environment name is too long.
22	The connector can fetch by primary key only.
23	No more cursors could be allocated.
24	No more statements could be allocated.
25	Connector deleted/updated more or less than 1 row.
26	The parsed SQL statement was not a select.
27	An illegal request was received by the connector.
28	Already logged on to a database.
29	Unrecognized option for open database.

Examples in Action 🚀

Example 1: Success (Error 0)

You fetch a record successfully from the Informix database.

Result in $dberror: 0
Message: No error message appears.

Example 2: Already Logged On (Error 28)

Your code tries to open a connection to the database, but your path is already open.

Result in $dberror: 28
Message: Connector ERROR (28): Already logged on to a database.

Example 3: Informix Error (Negative Value)

The Informix DBMS reports an error (for example, a syntax error in your SQL or a constraint violation).

Result in $dberror: A negative number (example: -201)
Message: Informix ERROR (SQLSTATE: 42000): ... SQLCODE -201: ...

Quick Tips 💡

✨ Always check $dberror after database operations.
✨ If $dberror is positive and between 20–29, use the table above to find the cause.
✨ If $dberror is negative, contact Informix documentation for the SQLCODE meaning.
✨ Look at both the error number and the message to debug faster.

Conclusion

Next time you see an error in the message frame, check the syntax first. Is it "Connector" or "Informix"? If it is a Connector error, use the table above to quickly find the cause!

Happy coding! 💻✨

Uniface 10.4 + Informix: Simple Guide to Data Packing 📦

Franz — Tue, 23 Dec 2025 08:02:54 +0000

🤖 This blog post was created with the help of an AI assistant and is based on the Uniface 10.4 documentation about “Informix Data Packing”.

When you use Uniface 10.4 with an Informix database, every field in your model has a packing code. This packing code tells Informix how the data is stored in the database. 😊

In this article, you see how Uniface packing codes map to Informix storage formats, in simple language and with small examples. This can help you avoid strange data problems when you design or debug your application. 💡

What is data packing?

In Uniface, each field has a data type and a packing code, for example C10 or I4. The packing code controls how the data is stored physically in the Informix table (for example as CHAR, VARCHAR, DECIMAL or DATE).

The Informix connector uses a fixed mapping from the Uniface packing code to the Informix storage format. This means that the same packing code always results in the same Informix data type.

Very small example

C10 in Uniface → stored as CHAR(10) in Informix.
I4 in Uniface → stored as INTEGER in Informix.
D in Uniface → stored as DATE in Informix.

Once the table is created in Informix, this mapping is fixed for that column unless you change the table definition with SQL. So choosing the right packing code is important already in the Uniface model.

Character and text fields 📝

Many Uniface packing codes become simple character types in Informix. These are used for names, codes, flags and other text data that is not extremely large.

B, B1-B5 → stored as CHAR in Informix (for example for boolean-like fields stored as Y/N or 0/1).
C1-C* → stored as CHAR (fixed-length character fields).
R1-R* → stored as CHAR (often used for raw codes).
(S)A1-A9 → stored as CHAR (short strings).
(S)A11-A40 → stored as CHAR (longer strings).
T, T1-T2 → stored as CHAR (small text or time-related codes).
U1-U* → stored as CHAR (Unicode string handled as character data by the connector).
VC1-VC255, VR1-VR255, VU1-VU255 → stored as VARCHAR (variable-length text).
VC256-VC*, VR256-VR*, VU256-VU* → stored as CHAR (because of size limits in the Informix driver).

Example: customer name

Imagine a field CUSTOMER.NAME defined as C40 in Uniface. The Informix connector will create this as CHAR(40) in the database.

If you change it later to VC40, Uniface would map it to VARCHAR(40), which can save space but may behave differently in indexes and comparisons. So plan your character packing codes with your DBA rules in mind.

Numbers and money 💰

For numeric fields, the Uniface packing code controls whether Informix uses INTEGER, SMALLINT, DECIMAL, FLOAT or MONEY. This is important for precision and performance.

I1-I2 → SMALLINT (small integers).
I3-I4 → INTEGER (normal integers, for example IDs or counters).
I8 → FLOAT (large numeric values stored as floating point).
F → DECIMAL (fixed-point numeric, generic F).
F4 → REAL (4-byte floating point).
F8 → FLOAT (8-byte floating point).
M1-M4 → MONEY (monetary values).
N1-N32 → DECIMAL (numeric with different sizes and precision).
(N)C1-32 → DECIMAL (numeric values packed with a C packing, but stored as decimal).
O1-O32, P1-P16, Q1-Q16 → DECIMAL (different decimal ranges and precisions).

Example: invoice amount

For an invoice amount, a typical choice in Uniface is M2 (money with 2 decimals). The Informix column will then be of type MONEY, which keeps the decimal places stable and is easy to sum in SQL.

If you used a floating type like F8 instead, Informix would store it as FLOAT, which can introduce rounding issues for financial calculations. So for prices and totals, it is safer to use M* or N* (decimal) instead of FLOAT.

Dates and times ⏰

Date and time fields have special mappings because Informix has dedicated date and datetime types. Using the correct packing code here makes your queries simpler and more efficient.

D, D1-D11 → DATE (calendar date without time).
E, E1-E8, E10 → DATETIME YEAR TO SECOND (full date and time down to seconds).
T3 → DATETIME YEAR TO SECOND (time-related packing that maps to datetime).

Example: order date vs. timestamp

For an ORDER_DATE field, a simple D is often enough and becomes DATE in Informix. For an audit field like LAST_UPDATE, you can use E so that Informix stores DATETIME YEAR TO SECOND.

This way you can easily select all rows from today or sort by the exact update time in SQL. It also keeps the storage compact and index-friendly.

Serial, byte and text fields 📂

Some Uniface packings are used for special Informix types like serial numbers, byte data and text data. These are important for technical IDs, blobs and large documentation fields.

(S)A10 → SERIAL (auto-increment integer, often used as technical primary key).
SR1-SR* → BYTE (binary data, for example PDF or image stored as blob).
SC1-SC* → TEXT (large text stored as a TEXT blob).
SU1-SU* → TEXT (Unicode text stored in a TEXT-like way by the connector).

Example: document storage

If you have a field DOCUMENT.FILE_CONTENT with packing SR1, Informix will store it as BYTE. This is good for binary files like PDFs.

For a field DOCUMENT.LONG_COMMENT with packing SC1, Informix will store it as TEXT. This is better for long user comments or descriptions that can be larger than normal VARCHAR limits.

Why this mapping matters in real projects 🧠

The mapping between Uniface packing codes and Informix storage formats is not just a technical detail. It affects how indexes work, how much disk space you use and how easy it is to write SQL queries.

If you choose a CHAR packing for a field that changes a lot in length, your table may waste space and become slower.
If you choose a floating type (F4, F8, I8) for monetary values, you may get rounding problems in reports.
If you use TEXT or BYTE for fields that you often filter in WHERE clauses, you may not be able to index them easily.

A good practice is to create a small test table where you define one column for each packing code that you plan to use. Then you can check the real Informix types with tools like dbschema or your favorite database browser and adjust your Uniface model before you go to production. ✅

Uniface 10.4 and Informix give you a flexible and powerful combination for business applications. When you understand how packing codes map to Informix storage formats, you can design models that are both safe and efficient. 🚀

Uniface 10.4 + Informix: Simple Guide to Stored Procedures 🚀

Franz — Sun, 21 Dec 2025 06:58:31 +0000

🤖 This blog post was created with the help of an AI assistant and is based on the official Uniface 10.4 documentation for “Informix Stored Procedures”.

When you build Uniface applications on Informix, performance matters. One simple way to speed up basic database operations is to use stored procedures generated by the Uniface Informix connector (INF).

What is a stored procedure? 🤔

A stored procedure is one or more SQL statements that are already parsed and compiled and stored in the Informix database. Because of this, Informix can execute them immediately without parsing the SQL text again each time.

Compared to sending raw SQL from your application, stored procedures can be faster and more consistent for common operations.

How the INF connector uses stored procedures

The INF connector can create stored procedures automatically when it creates the base tables in Informix. These procedures handle the most basic I/O operations: insert, fetch, update, delete, and select.

To enable this behavior, you must set the procs connector option in the Uniface assignment file for Informix. Without this option, Uniface does not create or use these Informix stored procedures.

Stored procedures created by INF 🔧

For each table (let’s call it table_name), the connector can create several procedures with specific suffixes. Here are the most important ones:

table_name_E – Existence check. This procedure checks if table_name already has the expected procedures.
table_name_I – Insert a row into table_name. This one is not created for tables that contain segmented fields.
table_name_F – Fetch all nonsegmented fields in one row of table_name using a specific primary key, and optionally lock the row.
table_name_U – Update one row in table_name based on the primary key, or the primary key plus the U_VERSION field. This is also not created for tables that contain segmented fields.
table_name_D – Delete a row in table_name based on the primary key, or the primary key plus U_VERSION.
table_name_S – Select nonsegmented fields for all rows of table_name, using a select cache for better performance.
table_name_S# – Select nonsegmented fields using a specific index number #, again using the select cache. The connector generates one stored procedure for each index that is used in such select operations.

In addition, Uniface can generate extra stored procedures to enforce referential integrity, depending on your settings and table relationships.

Segmented fields and stored procedures 📦

Informix supports segmented fields (for example, large text or byte data stored in separate locations). The INF connector has special rules for these fields.

The connector never uses stored procedures to manipulate segmented fields.
For tables that contain segmented fields, the connector does not create the insert (_I) or update (_U) procedures.
The other procedures (_F, _D, _S, _S#) are still created but they only work with nonsegmented fields.

For read, write, and update operations that involve segmented fields, the connector falls back to dynamic SQL instead of using stored procedures.

Serial fields and the serial insert option 🔁

Informix also supports serial fields (auto-increment numeric values). In Uniface, the behavior for tables with serial fields depends on the connector options.

If the serial insert option is turned on together with the procs option, the INF connector changes its behavior:

For tables that contain serial fields, the connector does not use the insert stored procedure.
Instead, it uses dynamic SQL to execute the write request, so that serial values are handled correctly.

Example: Simple customer table 🧑‍💻

Let’s look at a small example. Imagine a table called customer with a primary key customer_id, no segmented fields, and no serial fields.

With the procs option enabled, you can expect the INF connector to create procedures like:

customer_I – Insert a new customer row.
customer_F – Fetch one customer row by primary key (and optionally lock it).
customer_U – Update an existing customer row using the primary key (and possibly U_VERSION).
customer_D – Delete a customer row using the primary key (and possibly U_VERSION).
customer_S – Select all customer rows.

In your Uniface component, the connector can call these stored procedures internally when you do normal store, read, or update operations. You do not have to call the procedures manually; Uniface does it for you based on your configuration.

When should you enable stored procedures? 💡

Using the procs option makes most sense when:

You want better performance for common CRUD operations on Informix.
Your tables mainly use nonsegmented fields (or you are fine with dynamic SQL for the segmented ones).
You like a clear, predictable mapping between Uniface I/O and Informix stored procedures.

If you have many segmented fields or very complex SQL logic, you may still rely more on dynamic SQL or custom SQL statements. But for standard, frequent operations, the generated stored procedures are a clean and efficient solution.

Final thoughts 😊

Uniface 10.4 and Informix work well together when you use the INF connector options correctly. With the procs option, you get a set of ready-made stored procedures that speed up basic I/O.

Add in the special behavior for segmented and serial fields, and you have a flexible setup: fast where possible, dynamic where necessary.

Happy coding with Uniface and Informix! 🚀

Uniface 10.4 + Informix: Simple Guide to DSQL Support 🧩

Franz — Sun, 21 Dec 2025 06:55:17 +0000

🤖 This blog post was created with the help of an AI assistant and is based on the Uniface 10.4 documentation section “SQL Support on Informix”.

When you use Uniface 10.4 with Informix, you can run direct SQL from your ProcScript code. The main tools for this are the sql ProcScript command and the SQL Editor in the Uniface environment. 😊

What is DSQL in Uniface?

In this context, DSQL means that Uniface sends your SQL string directly to Informix. You write the SQL yourself, and it is executed on the Informix side without extra Uniface logic.

You can use the sql statement in ProcScript to execute SQL like select, insert, update, or delete. You can also use the SQL Editor in Uniface to run SQL statements against your Informix database.

Monitoring SQL in the message frame

Uniface can show the SQL statements that are sent to Informix in the message frame. This can help you understand which SQL is actually executed.

However, you cannot see the actual values used in these SQL statements. Only the statement itself is visible, not the concrete parameter values.

Important rules for transactions

For the single connection mechanism, you must not use commit work or rollback inside an SQL string that you send with the sql instruction. The same restriction applies to SQL that you execute in SQL Edit.

Uniface handles the single database connection and its transaction state. If you send commit work or rollback yourself, you can disturb this mechanism, so it should be avoided in this mode.

Example: what you should not do

; ❌ Bad example in single connection mode
sql "update customer set active = 1 where id = 100;
     commit work", "inf"

This example mixes data change and transaction control in one SQL string and should not be used with the single connection mechanism.

Better example without transaction control

; ✅ Better example: let Uniface control the connection
sql "update customer set active = 1 where id = 100", "inf"

; Here, Uniface or your normal application flow decides when the work is committed.

In this example, the SQL statement only updates data and does not send commit work or rollback, which fits the rule for the single connection mechanism.

Using SQL Edit when you have no front-end

Sometimes you do not have an Informix front-end and have not yet created an Informix database. In that situation, you cannot log on to Informix with another tool.

In this case, you can use SQL Edit in Uniface to create the Informix database and run the required SQL statements. This gives you a way to work with Informix even if Uniface is your only available front-end.

Limitations with BLOB fields

There is an important limitation for BLOB data when you use DSQL on Informix. You cannot select, insert, or update BLOB fields in SQL Edit or with the sql instruction.

If you need to work with BLOB fields, you must use other Uniface mechanisms instead of SQL Edit or the sql command. This keeps your application compatible with the Informix driver limitations.

Example: simple select without BLOB

; ✅ Valid DSQL example (no BLOB involved)
sql/data "select id, name from document where status = 'A'", "inf"

if ($status >= 0)
  message "Select was successful."
else
  message "Select failed, status = %%$status"
endif

Here the SQL selects only normal fields like ID and NAME and does not touch any BLOB fields, so it is safe with the documented DSQL limitations.

When to use DSQL on Informix

Use DSQL (the sql instruction or SQL Edit) when you want to send your own SQL directly to Informix from Uniface. It is useful when you know the exact statement you want to execute.

Do not use DSQL for BLOB operations and do not include commit work or rollback in your SQL when you work with the single connection mechanism. Following these rules keeps your Uniface and Informix integration stable and predictable.

✍️ This article is a simplified explanation of the “SQL Support on Informix” section from the Uniface 10.4 documentation, written with AI assistance to make the topic easier to understand.

Uniface 10.4 + Informix: Simple Guide to Data Retrieval 📊

Franz — Sun, 21 Dec 2025 06:52:07 +0000

This article gives a simple overview of how data retrieval works when you use Uniface 10.4 with an Informix database. 😊 This post was created with the help of an AI assistant and is based on the official Uniface 10.4 documentation about “Data Retrieval on Informix”.

read with where clause 🔍

The Uniface read statement can use a where clause that Uniface inserts directly into the generated select statement for Informix. Everything inside the double quotes of the where clause is copied as text into the SQL, so you must always write valid Informix syntax.

trigger read read where "AMOUNT > 1000 AND STATUS = 'OPEN'" end

In this example, Uniface does not try to interpret the condition; it simply passes the where text to Informix, which then filters the rows. This is helpful if you want to use Informix-specific features, such as special functions or optimizer hints. 🧠

Using the option parameter ⚙️

The option parameter of the read statement lets you tune how Uniface and Informix retrieve data, so you can improve performance. You can use it to control things like the maximum number of hits (rows) that should be returned, the number of rows per fetch step, or how many hits are cached.

Example (typical pattern):

trigger read read "ORDER" option "maxhits=500, stepsize=50, hitcache=100" end

In simple words, this kind of setting can do the following:

maxhits=500: Stop after 500 rows, even if more rows exist.
stepsize=50: Fetch data in blocks of 50 rows at a time.
hitcache=100: Keep up to 100 hits in memory for faster navigation.

The exact option names and values are connector specific, but the idea of limiting rows and controlling fetch behavior is important for performance.

selectdb and count functions 🧮

Informix always supports the selectdb statement, but the way it behaves with count and plain field transport can affect performance. If you use the count function in a selectdb that also lists several fields, Informix may perform a separate select for every field named, and the same can happen if you use selectdb without any aggregate functions at all.

Pattern that can be slow:

; Can cause extra selects per field selectdb (count(F1), max(F2), min(F3)) from MYTABLE to (CNT.DUMMY, MAXF2.DUMMY, MINF3.DUMMY)

Better pattern:

; 1) Count in a separate selectdb selectdb (count(F1)) from MYTABLE to (CNT.DUMMY) ; 2) Other aggregates in a second selectdb selectdb (max(F2), min(F3), ave(F4), sum(F5)) from MYTABLE to (MAXF2.DUMMY, MINF3.DUMMY, AVGF4.DUMMY, SUMF5.DUMMY)

By separating count (and simple transport without aggregate) from the other aggregate functions, you avoid unnecessary extra selects and keep your application faster and more scalable. 🚀

Field subsetting on Informix 🧩

Uniface can automatically subset fields when working with Informix, but only in specific environments. Fields that are not painted on the form and not mentioned in ProcScript are then not selected, fetched, inserted, or updated by the Informix connector.

Important rules:

Field subsetting is allowed only for Informix OnLine.
Field subsetting is not allowed for Informix Standard Engine (SE).

Example scenario:

Your table has 20 columns.
Your Uniface form only shows 5 fields and your ProcScript also uses only these 5.
The connector will then work only with these 5 fields and ignore the other 15, which reduces network traffic and improves performance. 📉

The Uniface kernel decides which fields are required and which fields can be skipped, so you do not need to configure this manually.

Maximum number of open cursors 🎫

The Informix connector in Uniface supports up to 256 open cursors. An open cursor is basically an active query on the database, so every hitlist or running query can use one cursor.

What this means for your application:

If you open many hitlists or nested queries and never close them, you can reach the cursor limit.
You should close or release hitlists and instances when you no longer need them, especially in long-running components or batch jobs.

Keeping an eye on cursor usage helps you avoid “too many open cursors” errors and keeps your Uniface and Informix system stable. ⚠️

Practical mini example 🧪

Here is a small example that combines several of these ideas in one trigger:

trigger read ; 1) Read orders with a limit and tuned fetch behavior read "ORDER" option "maxhits=200, stepsize=20" ; 2) Read only recent orders using an Informix-specific where clause read where "ORDER_DATE >= TODAY - 30" option "maxhits=100" ; 3) Get total number of orders selectdb (count(ORDER_ID)) from ORDER to (CNT.DUMMY) ; 4) Get average order amount in a separate selectdb selectdb (ave(AMOUNT)) from ORDER to (AVGAMOUNT.DUMMY) end

The two read statements show how you can combine where clauses and options to limit hits and tune performance. The pair of selectdb statements shows the recommended way to separate count from other aggregates to avoid extra selects and keep Informix efficient. 💡

With these patterns, your Uniface 10.4 applications can retrieve data from Informix in a way that is both simple to understand and friendly to database performance. 🚀

Uniface 10.4 and Informix: Simple Guide to Transaction Control 💾

Franz — Sun, 21 Dec 2025 06:46:34 +0000

This article gives a simple overview of how transaction control works when you use Uniface 10.4 with an Informix database. 😊

This post was created with the help of an AI assistant and is based on the official Uniface 10.4 documentation about “Transaction Control on Informix”.

Why transactions matter 💡

Transactions help you keep your data consistent.

Either all changes are saved, or none of them are saved, which is very important in financial, medical, or other critical systems.

A typical example:

You insert an order into an ORDERS table.
You insert order lines into an ORDER_LINES table.
You update the customer’s credit balance.

All these actions should be part of one transaction. If something fails, you want to roll back everything.

Transaction logging in Informix 🧱

Informix can work with or without transaction logging.

If there is no transaction logging, the database does not manage transactions in a way that supports safe commit and rollback operations; changes are effectively written without the option of a full transactional rollback.
If transaction logging is enabled, Informix supports both commit and rollback, so Uniface can use transactions safely.

So, if you want real transaction control, make sure that logging is turned on for your Informix database.

Never commit inside SQL strings 🚫

Uniface lets you send SQL directly using the sql ProcScript statement.

However, you must not put commit or rollback into the SQL string when you use the single connection mechanism.

Why?

In the single connection mechanism, a logon path can be shared by multiple logical paths.
If you end a transaction on that logon path, you end the transaction for all paths that use the same connector.

Example of what not to do:

; ❌ bad practice in single connection sql "update orders set status = 'PAID' where order_id = 123" sql "commit"

Better: keep your business SQL and your transaction control separate:

; ✅ better: let Uniface control the transaction sql "update orders set status = 'PAID' where order_id = 123" if ($status >= 0) commit ; Uniface commit else rollback ; Uniface rollback endif

In this version, Uniface manages the transaction on the logon path correctly.

Multiple connections vs. global transactions 🔀

Uniface and Informix also support a multiple connection mechanism.

In this mode, you can have several open connections, and each connection has its own transaction.

Multiple concurrent transactions are supported: each connection can start, commit, and roll back its own transaction.
Global transactions, where a single transaction spans several databases over multiple connections, are not supported by Informix as a native feature in this Uniface connector context.

Example scenario:

Connection A uses database FINANCE.
Connection B uses database LOGGING.

You can:

Start a transaction on A, do some updates, and commit A.
Start a transaction on B, do other updates, and roll back B.

But you cannot have one atomic transaction that covers both FINANCE and LOGGING at the same time just by using normal Informix transactions; for real distributed transactions you need a transaction manager and XA support.

Two-phase commit support ✅

Informix supports Two-Phase Commit (2PC) for XA-compliant environments, and this is handled largely transparently by the database and the transaction manager.

Two-Phase Commit is a protocol used to make sure that a distributed transaction either commits everywhere or rolls back everywhere.
In a setup with a transaction manager, Informix takes part in this process, while Uniface still uses its usual commit and rollback ProcScript statements to signal transaction boundaries.

The important point: you do not need special commit SQL statements inside your Uniface SQL strings to “enable” 2PC; the infrastructure around Informix handles that.

Simple practical tips 🧰

Here are some simple rules you can follow in daily work:

Make sure transaction logging is enabled if you need safe commit and rollback.
Do not put commit or rollback inside SQL strings when using the single connection mechanism; use Uniface’s commit and rollback instead.
When using multiple connections, remember that each connection has its own transaction, and Informix does not provide one global transaction across several databases in this setup.
If your environment uses Two-Phase Commit, let Informix and the transaction manager do the heavy lifting; keep your Uniface code clean and simple.

With these rules, your Uniface 10.4 applications can use Informix transactions in a safe and predictable way. 🚀

Forem: Franz

🖥️ The DEC-VAX: The Machine That Changed Computing History

🎯 What Was the DEC-VAX?

🚀 The Birth of a Legend

💻 Technical Innovation

⌨️ The VT100 Terminal Legacy

📈 Market Dominance

🔚 The End of an Era

🎓 Legacy Impact

🔑 The Gold Key in Uniface - A Relic from the VAX Era

🤔 What is the Gold Key?

⌨️ How to Use the Gold Key Today

Standard Mapping

💡 Practical Use Cases

1. Enter Special Characters 📝

2. Wildcard Search 🔍

3. Structure Editor Functions ⚡

🛠️ Configuration

🎯 Conclusion

🔌 MySQL Connector in Uniface 10.4: A Developer's Guide

Introduction: Why MySQL Integration Matters for Uniface Developers

What is the MySQL Connector in Uniface?

Key Connector Information

Understanding the Utilities

Platform and Version Support

Installation: The Critical Setup Steps ⚙️

Requirement: libmysql.dll

⚠️ The 32-bit vs. 64-bit Compatibility Issue

Configuring the MySQL Connector in Uniface

Basic Setup Process

Supported Features in Detail

SQL Support

Stored Procedures

Important Naming Considerations

Common Scenarios

Creating Tables from Uniface

Importing Existing Database Structures

Troubleshooting Tips

Connection Issues

Library Loading Errors

Naming and Reserved Words

U_VERSION Mechanism for Locking

Best Practices for MySQL Integration

Configuration Management

Development Workflow

Using Stored Procedures Effectively

Referential Integrity

Conclusion

Sources and References

🔐 Connecting Uniface 10.4 to LDAP Servers: A Complete Guide

1. What is LDAP? (A Quick Refresher) 📚

2. The Uniface LDAP Connector 🔌

Key Capabilities:

3. Configuration and Setup ⚙️

The Assignment File Syntax

Options Reference

4. Deep Dive: The addbase Option 🕵️‍♂️

What does it do?

Example in Action

When should you turn it OFF?

5. Practical Use Cases & Code Examples 💻

Scenario A: User Login (Authentication)

Scenario B: Searching for a User

6. Platform-Specific Notes & Troubleshooting 🚧

Linux vs. Windows 🐧🪟

Common Pitfalls

7. Conclusion ✅

🔐 Mastering LDAP Integration in Uniface 10.4: The Native Way

📚 What is LDAP? (For the Uninitiated)

🔌 The Uniface Approach: Driver, Not Service

🛠️ Step 1: Configuration (The ASN File)

📝 Step 2: The Data Model

💻 Step 3: Practical Examples

Use Case A: User Authentication (The Login)

Use Case B: Finding a User (The Search)

🐧 Platform Specifics: Linux vs. Windows

Windows 🪟

Linux 🐧

⚡ Troubleshooting & Best Practices

🏁 Conclusion

4. Deep Dive: The `addbase` Option 🕵️‍♂️