DEV Community: Franz

Building a tested calculator in the Uniface 10 IDE

Franz — Sun, 20 Sep 2026 10:15:30 +0000

Uniface is one of those tools you rarely read about, but that still runs a surprising amount of business software. I work with it regularly, and I wanted a small, self-contained project to try out a few things properly: a clean structure, input validation and - the part you almost never see in Uniface examples - automated tests.

The result is a calculator with a modern flat look, about 25 functions (basic arithmetic, powers, roots, trigonometry, logarithms, rounding, memory, history) and a test service with 69 test cases.

Everything here was built with Rocket Uniface 10 Community Edition (10.4), so you can follow along for free.

The architecture in one picture

CALC_FRM (Form)          CALC_SVC (Service)           CALC_TEST_SVC (Service)
 - fields & buttons   --->   - public operations    <---  - exec -> RUN_ALL
 - checks empty fields       - all math                   - 69 test cases
 - shows errors              - validation                 - PASS/FAIL via putmess
 - history                   - returns 0 / -1 + text

The most important decision: the form does not calculate anything. It collects input, calls the service and displays the result. That is what makes the logic testable at all.

Step 1: A modeled entity without a database

A Uniface form needs at least one entity - if you try to compile a form without one, you get:

error: 1017 - Compiling a component without entities is not allowed.

For a calculator there is no table, so I created a modeled entity that is not in the database:

Model: CALCULATOR_MDL
Entity: CALCULATOR_DMY (Database Behavior: Not in Database)
Fields: NUMBER1, NUMBER2, RESULT - data type Numeric

You will see warnings like 1065 - Field ... might be truncated on output to DBMS and 1072 - Scaling ... changed to 8 when compiling. Since the entity is never written to a database, they are harmless.

Step 2: The form

Create a Non-modal Form (CALC_FRM), drag the entity into it and add:

the three modeled fields for input and result,
non-modeled fields for CALCULATION (last calculation), MEMORY and HISTORY (multi-line edit box),
one Command Button per function (BTN_ADD, BTN_SQRT, BTN_SIN, ...).

The button caption is the field's Initial Value (+, √x, sin, ...). The flat look comes entirely from the widget properties, for example for the blue operator buttons:

BACKCOLOR=#2563EB; FORECOLOR=#FFFFFF; BACKCOLORFILL=flat;
BACKCOLORHOVER=#1D4ED8; BACKCOLORSELECT=#1E40AF; FONT=SANSLARGE
TOOLTIPTEXT=Add: Number 1 + Number 2

Grey buttons for functions, indigo for memory, red for "C" - three or four colour groups are enough to make an old-school form look surprisingly current.

Step 3: The logic lives in a service

CALC_SVC is a plain Service component. Every function is a public operation with the same shape:

public operation DIVIDE
params
   numeric pA : IN
   numeric pB : IN
   numeric pResult : OUT
   string pError : OUT
endparams
   pError = ""
   if (pB = 0)
      pError = "Division by 0 is not possible."
      return -1
   endif
   pResult = pA / pB
   return 0
end

The convention is simple: return 0 on success, -1 on error, and put a readable message into pError. The caller never has to know which error happened - it just shows the text.

Unary functions (SQRT, SIN, FACTORIAL, ...) have the same signature without pB. Shared helpers such as the sine/cosine series or the natural logarithm are private entry blocks inside the service, so both LN and LOG use the same code:

public operation LOG
params
   numeric pA : IN
   numeric pResult : OUT
   string pError : OUT
endparams
variables
   numeric vLn
endvariables
   pError = ""
   if (pA <= 0)
      pError = "The logarithm is only defined for numbers greater than 0."
      return -1
   endif
   call NATURAL_LOG(pA, vLn)
   pResult = vLn / 2.302585092994045684
   return 0
end

To keep the project self-contained, I implemented the transcendental functions myself in ProcScript: Taylor series for sine and cosine (after normalising the angle to -180..180 degrees), a series for ln after scaling the argument into 0.5..2, "halve, expand, square back" for e^x, and Newton's method for square roots. It is a nice exercise, and the tests below show whether the approximations are good enough.

Step 4: A button trigger

Each button's detail trigger follows the same pattern:

trigger detail
throws
variables
   numeric vResult
   string vError
endvariables
   call VALIDATE_INPUT
   if ($status < 0)
      return 0
   endif
   if (NUMBER1.CALCULATOR_DMY = "" | NUMBER2.CALCULATOR_DMY = "")
      message/error "Please enter both numbers."
      return 0
   endif
   activate "CALC_SVC".ADD(NUMBER1.CALCULATOR_DMY, NUMBER2.CALCULATOR_DMY, vResult, vError)
   if ($status < 0)
      message/error vError
      return 0
   endif
   RESULT.CALCULATOR_DMY = vResult
   call LOG_CALCULATION($concat(NUMBER1.CALCULATOR_DMY, " + ", NUMBER2.CALCULATOR_DMY, " = ", RESULT.CALCULATOR_DMY))
end

After activate, $status holds the return value of the operation, so the -1 from the service arrives directly in the form.

LOG_CALCULATION is a component entry that rounds the result for display, writes it into CALCULATION and prepends it to HISTORY. In a Uniface multi-line field, %%^ is the line separator:

HISTORY.CALCULATOR_DMY = $concat(vText, "%%^", HISTORY.CALCULATOR_DMY)

Step 5: The input validation trap

This one surprised me. Type 2-1 into a numeric field and tab out - Uniface rejects it and keeps the focus in the field. Fine.

But type 2-1 and click a button directly, and the trigger runs anyway. The field's raw text is still 2-1, while the numeric value used in the calculation is 2. So ln(2-1) happily returned 0.693... - the logarithm of 2.

The fix is an explicit check before every calculation. The service has a VALIDATE_NUMBER operation that walks through the raw string:

while (vPos <= vLen)
   vChar = pValue[vPos:1]
   if ($scan("0123456789", vChar) > 0)
      vDigits = vDigits + 1
   elseif (vChar = ".")
      vDots = vDots + 1
   elseif (vChar != "-" | vPos != 1)
      pError = $concat(pLabel, " is not a valid number. Use digits, one dot as decimal separator and an optional leading minus sign.")
      return -1
   endif
   vPos = vPos + 1
endwhile

The form calls it for both fields in its VALIDATE_INPUT entry. Accepted: 42, -3.5. Rejected: 2-1, 2,5, 1.5.2, -, abc.

Step 6: Tests in ProcScript

You don't need a test framework for this. A test service with an exec operation is enough, because Compile & Test on a service runs exec:

public operation exec
   activate $instancename.RUN_ALL()
   return $status
end

Two small helper entries do the assertions. CHECK_VALUE compares with a tolerance (the series only approximate), CHECK_ERROR expects a negative status:

entry CHECK_VALUE
params
   string pName : IN
   numeric pExpected : IN
   numeric pActual : IN
   numeric pStatus : IN
   numeric pTests : INOUT
   numeric pFailures : INOUT
endparams
variables
   numeric vDiff
endvariables
   pTests = pTests + 1
   vDiff = pActual - pExpected
   if (vDiff < 0)
      vDiff = 0 - vDiff
   endif
   if (pStatus < 0 | vDiff > 0.000001)
      pFailures = pFailures + 1
      putmess $concat($concat("FAIL: ", pName, " (expected ", pExpected), $concat(", got ", pActual, ")"))
   else
      putmess $concat("PASS: ", pName)
   endif
end

A test case is then three lines:

activate "CALC_SVC".SIN(30, vResult, vError)
vStatus = $status
call CHECK_VALUE("SIN 30", 0.5, vResult, vStatus, vTests, vFailures)

activate "CALC_SVC".TAN(90, vResult, vError)
vStatus = $status
call CHECK_ERROR("TAN 90", vStatus, vTests, vFailures)

The suite covers every operation with normal values, edge cases and expected errors - for example ROUND(-2.5, 0) = -3, LOG(0.01) = -2, 10! = 3628800, division by zero, 0 ^ -1, 2 ^ 0.5 (only whole-number exponents are supported), FACTORIAL(2.5) and all the validation strings above.

The putmess output ends up in the session log (log\ide_<pid>.log in your Uniface user folder):

PASS: ADD 2 + 3
PASS: DIVIDE 1 / 0 (error expected)
PASS: SIN 30
...
PASS: VALIDATE 2-1 (error expected)
Calculator: 69 tests, 0 failures

One caveat worth knowing: a CHECK_ERROR test would also pass if the service could not be activated at all. That is acceptable here because dozens of CHECK_VALUE tests would fail in the same situation - but if you write a suite that only checks errors, test the activation separately.

Pitfalls I ran into

$concat has an argument limit. A call with seven arguments failed with 1000 - Syntax error (Wrong number of arguments). Nesting two $concat calls fixes it.
askmess vs. message/error. askmess without options shows a Yes/No dialog - odd for an error. message/error shows a proper error box with OK.
The script editor has two sections. Each object in Write Script has a Declarations and a Script section. If you select all and paste a trigger, it can end up in Declarations. Paste into the Script section.
Don't touch the repository while the IDE is running. The Community Edition keeps its repository in a local SQLite file (dbms\usys.db). Editing it with an external tool while the IDE was open made the IDE hang, and it would not start again until I restored a backup. Make every change through the IDE - or at least close it first and keep a copy.

Wrap-up

None of this is exotic - it is the same separation you would use in any other stack: UI in one place, logic in a service with a clear contract, and tests that call the service directly. What I like is how little Uniface needs for it: no framework, no plugins, just a service with an exec operation and putmess.

If you are maintaining Uniface applications, the pattern scales: move logic out of form triggers into services one piece at a time, and put a test service next to each one before you change anything.

How do you test your Uniface code - or do you? I would be curious to hear about other approaches in the comments.

Disclosure: This article was created with the help of AI

Working with Uniface Lists Using `putitem` and `getitem`

Franz — Mon, 14 Sep 2026 19:18:46 +0000

In Uniface ProcScript, putitem adds or replaces list items, while getitem copies an item into a variable. This example uses an indexed list, with positions starting at 1.

Build, read, and update a list

Add this operation to your component’s Script section:

public operation LIST_DEMO
variables
  string vMonths, vMonth
endvariables

vMonths = ""

; Append three items.
putitem vMonths, -1, "January"
putitem vMonths, -1, "February"
putitem vMonths, -1, "March"

; Read the second item: February.
getitem vMonth, vMonths, 2
putmess vMonth

; Replace the second item, then read it again.
putitem vMonths, 2, "April"
getitem vMonth, vMonths, 2
putmess vMonth

return 0
end

Expected message output:

February
April

Remember these rules

putitem vList, -1, value appends an item.
putitem vList, 2, value replaces the second item. A position beyond the list’s end creates empty intermediate items.
getitem vValue, vList, 2 reads the second item without removing it. Index -1 reads the last item.
After getitem, $status > 0 indicates the copied item’s position. If no item was copied, $status is 0 and the target is empty. Check the status immediately when handling a potentially missing item.

Use putitem to construct the list instead of typing ordinary semicolons: Uniface uses special list separators.

Creating a Service in Uniface 10 — Step by Step

Franz — Mon, 14 Sep 2026 19:15:21 +0000

This short guide shows how to create and name a service component in the Uniface IDE. You need an existing project and write access to your development repository.

The steps are based on Rocket Uniface 10 Community Edition 10.4.03, patch 021, on Windows 11.

1. Open your project

Open your project in the Uniface IDE, for example through Recent Objects on the start page. In the project editor, select Define Project.

2. Select the Service template

Open Templates on the left and find Component: Service.

Select this exact template. Component: Entity Service and Modeled Component: Service are different templates.

3. Add the component

Right-click Component: Service and select Insert into Structure.

The IDE adds a new component to the project with an automatically generated name, such as UCSVC_1. The name may differ in your repository.

4. Name your service

Double-click the new component to open it, then:

Select Define Structure.
Right-click the top-level component row.
Select Rename.
Enter a name, such as HELLO_SERVICE.
Press Enter to confirm.

Choose a name that is not already used in your repository. Check that the new name appears in the component structure and editor tab, then save your changes using the IDE’s Save action.

Your service component is now created and named, ready for you to add its implementation.

🖥️ 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! 🚀

DEV Community: Franz

Building a tested calculator in the Uniface 10 IDE

The architecture in one picture

Step 1: A modeled entity without a database

Step 2: The form

Step 3: The logic lives in a service

Step 4: A button trigger

Step 5: The input validation trap

Step 6: Tests in ProcScript

Pitfalls I ran into

Wrap-up

Working with Uniface Lists Using `putitem` and `getitem`

Build, read, and update a list

Remember these rules

Creating a Service in Uniface 10 — Step by Step

1. Open your project

2. Select the Service template

3. Add the component

4. Name your service

🖥️ 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)

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