QSHONI SQL Query Commands Just Got an Upgrade

I use the QSHQRYTMP and QSHQRYSRC commands as part of my QShell on i tools a lot in my daily travels for running SQL statements and creating output files from the results. Recently I've had more of a need to run multiple commands and aggregate the results to an output file. And I didn't want to start getting overly fancy by writing UNION queries all the time, although they do have their place.

The easiest way to do this was implementing a parameter set that allows the QSHRYTMP and QSHQRYSRC commands to copy their temporary results to a second output file by optionally using the CPYF command. Of course you can do this yourself, but having a CPYF option built right in to QSHQRYTMP and QSHQRYSRC just adds more value when you have a need for multiple SQL queries to aggregate to a single table. 

Upgrade to V1.0.55 and give them a spin and let me know what you think.

https://github.com/richardschoen/QshOni 

Connect IBM i to Office 365

Did you know that you can connect you IBM i system to Microsoft Office 365 ?

Think of things like:

Sending email directly from IBM i without the need for SMTP. 

Sending and receiving messages to Microsoft Teams sites.

Creating issues and committing source code to Azure Devops.

Retrieving and storing data files and save files from the IFS.

Communicating to Copilot and other AI services.

Uploading and accessing data for PowerBI and PowerApps.

If you have a need to hook up your IBM i and other applications to Office 365, reach out and book a discussion to talk about your requirements.

MobiConnect may be just the right answer.

Web Site: https://www.mobigogo.net

Email: info@mobigogo.net

 

Bring the Power of Python to your IBM i Apps

Building modern command-line utilities for IBM i with Python is a powerful way to extend legacy systems into today’s API-driven world—without abandoning the reliability of DB2 and core business logic.

Why Python on IBM i?
Python brings a rich ecosystem, clean syntax, and strong community support, making it ideal for quickly developing lightweight command line and web service based tools that can be used from CL, RPG and even COBOL. On IBM i, Python acts as a bridge between traditional workloads and modern integrations, allowing developers to automate tasks, query data, and connect to external services with minimal friction.

Seamless DB2 Connectivity with ODBC
Accessing DB2 data is straightforward using ODBC drivers such as IBM i Access ODBC. With Python libraries like pyodbc, developers can:

• Run SQL queries directly from the command line

• Automate reporting and data extraction

• Integrate DB2 data into external workflows

This approach avoids complex middleware while maintaining secure, high-performance access to critical business data.

Command-Line Utilities That Do More
By combining Python’s CLI capabilities (via tools like argparse or click) with DB2 data access, you can build utilities that:

• Trigger batch processes

• Validate or transform data

• Monitor system health

• Provide quick operational insights

These tools are fast to deploy and easy for teams to use without needing full UI applications. They can also fully interact with your existing RPG, CL and COBOL applications.

Connecting and Creating Web Services
Modern businesses rely on APIs—and Python excels here. Using libraries like requests, your IBM i command-line tools can:

• Push DB2 data to cloud services

• Pull real-time data from external APIs

• Integrate with SaaS platforms (CRM, ERP, analytics)

This enables IBM i systems to participate fully in digital ecosystems, from microservices to event-driven architectures.

Integrating to RPG, CL and COBOL Apps
Using software such as our MobiConnect platform for integrating Python and other open source apps to your classic application stack is a great way to quickly extend the use of your existing classic application code with the power and flexibility of Python or other languages such as PHP, Node, Java and more.

The Bottom Line 
Python-powered command-line utilities unlock a new level of flexibility for IBM i environments. By combining DB2 access via ODBC with seamless web service integration, organizations can modernize incrementally—enhancing productivity while preserving the stability of their core systems.

If you’re looking to extend existing IBM I apps without rewriting everything, this approach is one of the fastest, most practical paths forward.

Getting Started Integrating IBM i and Python 
MobiGoGo offers training and service around integration of your IBM i to other platforms quickly using Python.  If you're looking to do more with your IBM i, reach out and let's chat. Whether you want an IBM i and Python integration training class on how to build Python based command line apps or you want a full integration toolkit like MobiConnect for IBM i, let's talk about your needs and integration pain points. 

Email: richard@mobigogo.net

Web Site: https://www.mobigogo.net

 

Generate Spreadsheet from an IBM i Table Without the need for SQL

A few years back IBM created the SYSTOOLS.GENERATE_SPREADSHEET SQL function which wraps around the IBM i Access acsbundle.jar Java JAR file to generate Excel spreadsheets from a database file. This function is typically used from RPG applications to create spreadsheets.

Internally the Java functionality uses the Apache POI JAR file to create the actual spreadsheet output to an IFs file. 

But what about CL, RPG's distant cousin. 

I discovered a post from Scott Schollenberger over on TechXchange where he used my QSHONI utility to create a wrapper process to export an IBM i database table to an Excel file without needing RPG. I had seen this technique before but hadn't used it until this weekend. 

Essentially he called the acsbundle.jar file using Java and the appropriate command line parameters and the QSHEXEC command which is my high level wrapper around QShell and PASE calls. 

After mixing the appropriate elements a spreadsheet complete with column heading magically appears in IFS. 

If you have a need to use the GENERATE_SPREADSHEET style functionality from a CL program or command, check out the GENXLSACS command I created. This might save you several hours of programming output to Excel files. 

You can also marry this command with DB2 services or other summary data by first generating an output file (OUTFILE) from an SQL query using a command such as QSHQRYTMP or QSHQRYSRC from my QShell on i utilities. These two commands allow you to run an SQL query with or without soft coded parameter data and output the results to an output file in the QTEMP library or elsewhere.

I Can't Find My IBM i Open Source Packages

If you're like I am you may have struggled a little when starting to use PASE and open source packages for your IBM i application development or operations. 

The open source packages are usually installed in a directory named: /QOpenSys/pkgs/bin

For example the first thing you may have run into when trying to call a git command from a QShell or PASE session might have been: git: command not found.

You development or operations leaders told you to use git, but it's not running for you. And you don't want to look dumb asking why the git command won't run. 

Well just like we have library lists for classic IBM i jobs, PASE jobs and command lines use a directory search path which is the PASE equivalent to the library list. 

If you run the following commands from a QShell, PASE or SSH terminal session you should be all set to start using open source command line apps because the commands create a profile file including a search path for QShell and other PASE apps if you happen to be using bash instead of QShell.

To run these PASE profile creation commands you should be able to run STRQSH from a 5250 command line. 

First make sure your user profile has a home directory. This same value must also be set in the user profile Home Directory setting if you do a WRKUSRPRF or DSPUSRPRF on your user profile.

mkdir /HOME/RICHARD.  

Note: If your home directory gets created or already exists you're in good shape either way.

Then type and run each of the following individual commands.

What they will do:

The rm command first deletes the profile file if it exists. 

Note: If you get an error that file does not exist, that should be OK just continue to the next command.  

The touch command creates an empty profile file with CCSID 819 which is ASCII. This will make sure that QShell write ASCII data to your profile files.

The echo command writes the desired open source search path and appends the existing search path to it using the $PATH directive.

Let's create the profiles now.

WARNING: If you already have bash or QShell profile files you may not want to run these commands as they overwrite those profile files. Or make backups of the files beforehand. If you want to just edit your existing profile files, you might need to edit the file with the EDTF command from 5250 or vim or nano from the PASE command line instead and simply add the path statement. 

Create a QShell profile 

rm ~/.profile 

touch -C 819 ~/.profile 

echo PATH=/QOpenSys/pkgs/bin:$PATH > ~/.profile

Create bash profiles

rm ~/.bashrc

touch -C 819 ~/.bashrc 

echo export PATH=/QOpenSys/pkgs/bin:$PATH > ~/.bashrc

rm ~/.bash_profile

touch -C 819 ~/.bash_profile 

echo export PATH=/QOpenSys/pkgs/bin:$PATH > ~/.bash_profile

 

After you've created these profile files, you should be able to access any of the IBM i open source packages from any of the command line shells, QShell, PASE (CALL QP2TERM) or bash command lines in an SSH terminal client.

 

Simply exit and restart your favorite PASE command line shell, type git (or whatever other command you were trying to access) and it should show work as expected.

If you happen to be using my QShell on i utilities to run PASE commands the path handling is done automatically when you run a command. Check them out at: https://github.com/richardschoen/QshOni 

Creating, Distributing and Restoring IBM i Objects via Save Files

One of the object types I use the most with the IBM i operating system is the save file. 

Save file objects can be used to save and restore IBM i libraries using the SAVLIB/RSTLIB commands. 

You can also save and restore individual objects or groups of objects using the SAVOBJ/RSTOBJ commands. 

And for saving and restoring IFS files for archive or distribution you can use the SAV/RST commands.

The following GitHub page I created shows some PASE and CL commands that just might make your life a little easier when dealing with saving and restoring information using save file objects.  

https://github.com/richardschoen/howtostuff/blob/master/ibmi_savefile_copying.md

MacBook Neo For IBM i Development

For those who don't know me I'm a software developer and I create software apps and utilities for Windows, Linux, MacOS, Mobile and IBM i.

I have used and tested almost every Windows computer and MacBook under the sun in search of the best portability machine that performs well so I can still get things done efficiently.

This week Apple released the MacBook Neo. The Neo is basically a new version of the MacBook that uses the A18 ARM phone chip. And it starts at $599/$499 US with the student discount.

I had seen a lot of Neo reviews on the lead up to release day and since the release and thought surely this thing will be slow since it's using a phone chip. Release day happened to be during my vacation in sunny Florida. I tried to keep my FOMO in check but ultimately my curiosity lead me to picking one up on opening day. The Apple Store was not overflowing but the guy in front of me was picking up the same model. I went the Indigo Blue model. They currently offer Silver, Indigo (Blue), Citrus (Yellow) and Blush (Pink).

Even though I was trying not to check it out right away I couldn't help myself. My tech brain needed to see what this thing can do.

I've been trying out new technology on release day since the first Windows 95 release when I had to pick up my copy at midnight. At least this was a daytime pickup. 

I purchased the 2nd tier 13" Neo model with 512 gb storage and a lowly 8gb ram.  If the thing performed well I wanted to make sure I can take it along with me on a trip when I don't want a more expensive computer with me when traveling or when I need a capable backup computer "just in case".

My two main concerns about the device were:

- How well can it run things with just 8gb ram.

- Will I be able to use it in a dim room without the backlit keyboard.  

Well I can share that it spectacularly failed the low light keyboard test, but as a potential choice for the user or developer looking for a low price MacBook to test the waters or for a first time Mac user to replace an older Windows or MacBook laptop I believe it's a win.

To put this machine to the performance test I decided to install a raft of my favorite development tools and other apps to see how they perform. 

-Jetbrains Development Suite for .Net, Python, PHP, Java and HTML (Rider, PyCharm, PHP Storm, IntelliJ, WebStorm)

-VS Code with Code for i and other plugins

-IBM i Access (ACS)

-IBM i Access (ODBC)

-TN5250J

-IBM Rational Developer for i

-Rosetta (For running MacOS x64 apps)

-Greenshot

-LibreOffice

-Microsoft Office

-Remote Desktop Manager

-Windows App (RDP)

-Java JDK

-DotNet 10.0 SDK

-VMware with Ubuntu Linux

-VMware with Windows 11

I expected things to become sluggish pretty quickly because of the limited memory in the MacBook Neo. 

Rather than take you through a litany of my tests let me just say that the MacBook Neo seems to run just fine with 8gb of Ram.  Even VMWare seems to do quite well with Ubuntu Linux in case you like having a copy of Linux or Windows 11 available. Windows 11 functions well with 5632 of memory or below. Windows in VMware is recommended for limited use only on the MacBook Neo. Ubuntu seems to be pretty snappy with 4gb. 

The only reasons for not choosing this as your MacBook of choice might be for the user or developer who does a lot of photo editing or video editing of large file transfers or you want to do some local AI work. Or if you work in the dark often like I do you might want to choose a MacBook Air or Pro. 

Highlights for the MacBook Neo

-2.7 lbs

-Price

-Performance and functionality

-Keyboard keys that match the laptop color schema

Potential shortcomings

-Mechanical trackpad (actually works quite well)

-No keyboard backlight

-No notch or live camera indicator other than in the menu bar

-Only 8gb memory

-Slower NVM disk speeds, although not really noticeable

-No high speed Thunderbolt ports, although it does have USB-C

-No separate charging port. Have to use the USB-C ports.

-Doesn't fast-charge

Ultimately if you have been considering purchasing a MacBook for the first time, the Neo is a great place to start and you, your wife or husband, your kids or grandma and grandpa will not be disappointed with this device unless they are high end gamers or photo/video production creators. A used or re-furbished MacBook of any vintage M1-M5 with 16gb would also be a good option.

If you don't purchase the MacBook Neo, let me just say that anything with the M5 processor will become a computer that can probably last you the next 5-10 years. I have been using a MacBook Air M1 from 2020 for almost six years and it still functions as my daily driver, even though I have newer machines. The M1 was one of the few bright spots of the pandemic year. I recall picking it up from the Apple Store while wearing a mask. Sadly Apple says it's only worth $200 on trade in. For that amount I will keep and continue to use it.

In case the MacBook Air is the sweet spot for your needs I will share with you my current favorite. My personal favorite laptop right now is the MacBook Air 15".  If I were buying a new development workstation today I would probably go for the MacBook Air 15" M5 as a mix of high performance, light weight and value. However the MacBook Air 15" M2, M3 and M4 are really just as capable. You can't really go wrong with any Mac with an M1, M3, M3, M4 or M5 chip. These things just work and almost never make you wait.

Self Hosting your Own Apps

If you business has a need for some new apps, check out the  following site: https://awesome-selfhosted.net/ 

This site contains lists of various self-hosted and open-source apps for Backup, Blogging, Wikis, Automation, CRM and more. 

My #%## SQL RPG Program Won't Compile

Compiling SQLRPGLE Programs that Contain Long SQL Lines

I had a need to create some SQL in the IBM ACS Run SQL Scripts and then wanted to transplant that code into an SQLRPGLE member for processing.   

When I compiled the SQLRPGLE program the SQL preprocessor was giving me odd pre-processor errors. 

As it turns out by default your SQL line width is most likely limited to 80-100 characters. 

Resolution

The easiest fix is to make sure your SQL statement lines are less than 80 characters.

-or-

The other option is to tell the compiler to allow longer lines when specifying *LVL1 or *LVL2 for the RPGPPOPT parameter. 

Here's an example using the PPMINOUTLN parameter in the CRTSQLRPGI command when creating an SQL RPG program: 

CRTSQLRPGI OBJ(&L/&N) SRCFILE(&L/&F) COMMIT(*NONE) RPGPPOPT(*LVL1)    DBGVIEW(*SOURCE) COMPILEOPT('PPMINOUTLN(500)')

Apparently you can skip the special compile option parm COMPILEOPT if you add a special environment variable into your current job like this:

ADDENVVAR ENVVAR(QIBM_RPG_PPSRCFILE_LENGTH) VALUE(500) 

You will still need to use the RPGPPOPT parameter set to *LVL1 or *LVL2.

What is my public IP address for IBM i

There are times you might want to check your public IP address from your IBM i system. Fortunately you can use the curl command and the QSHCURL command from a CL or RPG program to determine your current IP address if you're using the FREE QShell on i (QSHONI) software (https://www.github.com/richardschoen/qshoni) I created to integrate your PASE program calls to a traditional IBM i program. 

Making the CL API call to curl is as simple as this: 

QSHONI/QSHCURL CMDLINE('https://api.ipify.org') DSPSTDOUT(*YES)

And the results automatically show up in outfield QTEMP/STDOUTQSH for you to utilize from your CL or RPG programming. 

Example IP address response written from STDOUT to the first record of the outfile: 32.1.1.22

Check out QShell on i to be able to run curl commands and much more. 

If you find some interesting use cases create an issue on the GitHub site, post a comment or email me and I can publish as an example. 

What flavor of Linux do you like ?

 If you're interested in trying out the various flavors of Linux, check out this link. I learned about the site in the following link: https://www.zdnet.com/article/you-can-test-all-the-best-linux-distros-right-in-your-web-browser-with-this-site/

The actual site is called: https://distrosea.com/

Work with IBM i - A Modern Windows Alternative to PDM

As PDM and SEU continue to work towards being deprecated, the goal of the Work with IBM i project is to provide a FREE, Windows-based alternative for PDM developers who are beginning the journey of moving their development workflow off the green screen and onto the desktop.

While VS Code and RDi are both excellent development environments, having options matters—especially options that preserve editor freedom of choice and allow continued use of existing PDM user options.

Flexible Editor Support

With Work with IBM i, developers can use:

• The built-in internal editor
• VS Code
• Notepad
• Notepad++
• RDi (using a slightly modified workflow)

The software supports online and offline editing using virtually any Windows-based editor that accepts file names via the command line. Since Notepad++ is widely used in the IBM i community, this alone is a compelling reason for many developers to adopt Work with IBM i.

Another key advantage is that SSH is not required. Many shops prefer not to open SSH ports, and Work with IBM i works entirely through standard IBM i access ports.

Project Background

I originally started this project 4 years ago as a way to gain more practice with .NET Core WinForms, but it has proven to be far more useful than initially anticipated. The core application is completely FREE to use.

Purpose and Philosophy

The primary purpose of Work with IBM i is to provide a Windows-based replacement for PDM that looks and feels similar to PDM, allowing developers to work with IBM i source members without a 5250 green screen, while maintaining a familiar, PDM-like workflow.

The goal is simplicity:

Use the best editors available on the PC, keep existing processes where possible, and avoid forcing developers to learn an entirely new development model.

Git Integration with iForGit

Work with IBM i integrates with iForGit, the subscription-based Git source management solution for IBM i that I created.

Learn more:

• https://www.iforgit.com
• https://github.com/richardschoen/iforgit

The Work with IBM i client app provides direct access to iForGit CL commands, allowing you to commit changes to Git repositories directly from standard source physical files.

(An active iForGit annual subscription is required for versioning features.)

Editor Configuration Options

Although the application includes a built-in text editor, many developers prefer VS Code. Work with IBM i supports VS Code along with the Code for i syntax extensions.

You can configure separate editors and viewers if desired. Supported options include:

• Internal editor (default)
• Notepad
• Notepad++
• VS Code
• External workflows using RDi

Using RDi requires downloading source locally and editing outside the application. Detailed instructions are available here:

https://github.com/richardschoen/workwithibmipdm/blob/main/using_rdi_for_editing.md

PDM User Options Support

PDM user options are supported, provided they do not rely on a 5250 interface.

The default PDM options file is:

QGPL/QAUOOPT

This can be changed in the settings file, allowing you to reuse your existing PDM user option commands directly within Work with IBM i.

Offline Editing and Visual Feedback

The client tracks whether a source member has already been downloaded for offline editing and provides visual indicators in the UI. You can:

1. Download source to your PC
2. Edit it offline
3. Upload changes once reconnected

This editing workflow enables productive development even when disconnected from the system.

Future Enhancements

As a future enhancement, .NET developers will be able to create custom alternatives to PDM user options using a C# plugin model.

Connectivity

❗ IBM i access ports used for communication:

• 446–449
• 8470–8479

No SSH access is required.

Getting Started

Getting started is simple:

1. Download the application. Visit the GitHub site below to request access.
2. Unzip it 
3. Launch it
4. Enter your IBM i user profile, password, and host name or IP address

You’ll be connected and ready to start using PDM—on Windows.

Have fun, and please leave feedback or report issues on the GitHub project page.

https://github.com/richardschoen/workwithibmipdm

Moving IFS Files Between IBM i and Linux Systems Just Got Easier with QSHSCP

If you’re anything like me, you’re always looking for efficient ways to move files and objects between systems. Over the holidays, I needed a fast, reliable way to transfer files between two IBM i systems and a Linux system using SSH. Since scp is already part of the IBM i open-source SSH tooling, it felt like the perfect foundation for a simple utility command. That’s what led me to create the QSHSCP command and share it with others who utilize my QShell on i app. 

The QSHSCP command is essentially a thin CL wrapper around the PASE scp command. It allows you to securely send and receive files over SSH connections without having to drop into a shell session. While my usual go-to tool is SFTP, I found SCP to be surprisingly efficient once I started working with it.

With QSHSCP, I can easily send IFS files between IBM i systems, as well as to and from Windows, Linux, or AIX systems—such as a cloud-based backup server or an IBM Power Cloud environment.

One intentional design choice—whether you see it as a limitation or a strength—is that QSHSCP only supports SSH key-based authentication. By relying exclusively on public/private key pairs, there’s no need to exchange or store passwords between systems, which improves both security and automation.

Below is an example of using the QSHSCP command to send a file from a local IBM i system to a remote IBM i or Linux system for backup purposes or to deploy new objects:

QSHONI/QSHSCP CMDPFXPARM('-v')                                    
      KEYFILE('/home/user1/.ssh/id_rsa.ppk')     
      USER(user1)                                     
      HOST(myhost.com)                       
      PORT(22)                                       
      ACTION(*SEND)                                  
      REPLLOCAL(*NO)                                    
      LOCALFILE('/home/user1/mylib.savf')          
      REMOTEFILE('/home/user1/mylib.savf')         
      DEBUGCMD(*NO)                                    
      DSPSTDOUT(*NO)                                   
      PRTSTDOUT(*NO)        

QSHSCP also serves as a solid starting point for building additional SCP-based utility commands on IBM i. As part of my upcoming MobiConnect product, I’ll be adding extended object management capabilities—allowing you to directly save and restore IBM i libraries, objects, and IFS files over scp. In additional to object management utilities MobiConnect will make it easier to integrate IBM i with open-source applications and web services from traditional CL and RPG programs.

For more details on the FREE QSHSCP command, visit: the QSHSCP command URL

To learn more about MobiConnect and connecting all your systems and applications, visit: https://www.mobigogo.net
Email: info@mobigogo.net or richard@mobigogo.net

Interesting Git Error today: "The remote end hung up unexpectedly"

I received an interesting Git error today: "The remote end hung up unexpectedly".

Sounds like an unwelcome phone caller.

However the article link below points out simply that the git command needs a larger buffer allocated to it. 

I have not seen this error in several years of using git. 

At least there's a quick fix. Run the following git command to set your git post buffer size. 

git config http.postBuffer 524288000 

https://stackoverflow.com/questions/15240815/git-fatal-the-remote-end-hung-up-unexpectedly

My List of Favorite MacOS Apps

 What's your favorite MacOS app or tool ?

I wanted to start keeping track of the various apps I use or have tried so I decided what better place than a GitHub page.

Drop an issue or pull request on the GitHub site with your favorites or feel free to to comment here.

https://github.com/richardschoen/macapps

Dynamic SQL with Soft Coded Parameters from IBM i CL Programs

Dynamic SQL from IBM i CL commands has never been easier. RUNSQL and RUNSQLSTM have been available for years to run SQL statements or stored SQL scripts. However they have always lacked the ability to create queries that contain dynamic parameter values. Think about how powerful these two commands become with soft coded parameter markers.

Imagine running an embedded dynamic SQL statement from a CL program and also passing parameters to the query on-the-fly. Or think about being able to store an SQL query template in a source member or IFS file with parameter markers ready to be run dynamically.

The following SQL helper commands were recently added to my IBM i QShell on i utilities to make life easier when you need dynamic SQL in a CL program or process. QShell on i is available on the following GitHub site. https://github.com/richardschoen/qshoni 

Read on for an example of how to use the commands:

RUNSQLPRM — Run SQL Action via SQL Stmt with Parm Replacement

This CL command is a nice way to run dynamic SQL action (non-query) commands via RUNSQL. The command allows us to pass soft-coded parameters to SQL statements, effectively giving the RUNSQL command superpowers by allowing substitution parameters to be used much like parameter markers. This makes action queries much more dynamic when embedding SQL in a CL program.

Here’s an example of RUNSQLPRM inserting a record to QIWS/QCUSTCDT by passing a SQL statement template and parms for @@LIB, @@FILE, @@CUSNUM, @@LSTNAM and @@QT to pass single quotes to a query. All keyword instances get replaced with selected parameter values.

RUNSQLPRM SQL('INSERT INTO @@LIB.@@FILE (CUSNUM,LSTNAM) 

         VALUES(@@CUSNUM,@@QT@@LSTNAM@@QT)')                 

         PARMS(@@LIB @@FILE @@CUSNUM @@LSTNAM @@QT)         

         PARMVALS(QIWS QCUSTCDT 123456 Test '''')           

         NAMING(*SQL)                                       

         DSPOUTPUT(*YES)

RUNSQLSRC — Run SQL Action from SQL Src with Parm Replacement

This CL command uses the same process as RUNSQLPRM to run dynamic SQL action (non-query) commands, except that it uses the RUNSQLSTM command (instead of RUNSQL). In addition, the RUNSQLSRC SQL queries are sourced from a source member so template SQL action query scripts can be created with reusable soft-coded queries.

Here’s an example of RUNSQLSRC inserting a record to QIWS/QCUSTCDT using a SQL source member that contains template parms for @@LIB, @@FILE, @@CUSNUM and @@LSTNAM. You can use whatever values you want but I have found @@ to be an adequate parameter marker header. 

Sample query source member SQLTEST4 in file QSHONI/SOURCE with parameter markers. 

INSERT INTO @@LIB.@@FILE 

(CUSNUM,LSTNAM) VALUES(@@CUSNUM,'@@LSTNAM')

Sample call to the RUNSQLSRC command using source member SQLTEST4 with substitution variables and values.

RUNSQLSRC SRCFILE(QSHONI/SOURCE)                 

          SRCMBR(SQLTEST4)                       

          PARMS(@@LIB @@FILE @@CUSNUM @@LSTNAM)  

          PARMVALS(QIWS QCUSTCDT 123456 Test)    

          NAMING(*SQL)                           

          DSPOUTPUT(*YES)

Caution when naming your parameter marker values

When using parameter markers make sure each parameter name is fully unique. For example don't have parameters named @@NAME and @@NAME1. If @@NAME were to get processed first in line, it would also replace anything with @@NAME1 as well but leave the 1 at the end of the value. One way around this could be to use a trailing parameter marker as well.  Ex: @@NAME@@ and @@NAME1@@. Or something like: @NAME@ and @NAME1@. I just try to always keep my named parameter markers unique.  

Make sure to visit the QShell on i GitHub site to stay up to date on QSHONI enhancements. Also feel free to suggest new commands or enhancements in the Github site issue pages, and to contribute!

Modernizing IBM i Integration with Linux on Power

As businesses evolve, the ability to connect legacy systems like IBM i with modern applications, trading partners, and cloud services is no longer optional—it’s essential. For IBM i shops looking to bridge that gap without a complete overhaul, Linux on Power Systems offers a smart, scalable path forward to enhance IBM i integration and connectivity.

Why Connectivity is Key
IBM i has long been a rock-solid platform for enterprise workloads. But in a today's digital world, you need more than stability—you need flexibility. That includes real-time data exchange, modern APIs, scripting support, and access to the open-source ecosystem.

Enter: Linux on Power

Running Linux on IBM Power Systems—or even on x86 or ARM platforms—gives you immediate access to the latest tools and languages like:

• PowerShell
• .NET
• PHP
• Python
• Node.js
• Go
• Rust
• Java/Kotlin
• Bash
• And many more

With Linux on Power alongside IBM i, you can develop, automate, and integrate without disrupting your core systems.

What You Gain

• Bus level high-speed connectivity between IBM i and Power Linux partitions
• Enhanced connectivity to cloud and trading partners
• Modern development frameworks
• Open-source tooling at enterprise scale
• Cost-effective modernization
• A hybrid platform that plays to the strengths of IBM i and Linux

Ready to Connect IBM i to the Future?
Learn more and explore documentation at:
🔗 Linux on Power Overview – IBM

Feel free to reach out with questions.  

PASE (Portable Application Solutions Environment) and QShell on IBM i feels a lot like Linux

PASE (Portable Application Solutions Environment) and QShell on IBM i feels a lot like working in a Linux or UNIX environment, and there's a good reason for that.

Why PASE Feels Like Linux

PASE is essentially a runtime environment on IBM i that allows AIX (IBM’s UNIX) binaries to run. Since AIX is UNIX-compliant, and Linux shares much of the same philosophy and command-line behavior, working in PASE can indeed feel like working on Linux.

Here are some similarities and practical takeaways:

---

Similarities Between PASE and Linux

• Shell commands like ls, cd, pwd, grep, cat, grep, etc., are available in both environments.

• File system navigation behaves similarly (though the underlying file systems are quite different — IFS on IBM i vs ext4, xfs, etc. on Linux).

• Environment variables like $PATH, $HOME, and others are used in both.

• Scripting with shells like sh, ksh, or even bash (if installed) can be practiced in both systems.

• SSH access allows terminal-based work just like in a Linux shell.

• Tools like vi, awk, sed, ps, kill,nano , and cron are either identical or very close in functionality.

---

What’s Different

• QShell vs PASE:

  • QShell is a POSIX-like shell on IBM i, but it's not a full UNIX shell. It lacks some scripting features and behaves differently in areas like redirection and process handling.

  • PASE is closer to real UNIX/Linux, especially when running native AIX binaries.

• File paths:

  • IBM i uses the IFS (Integrated File System) which is different from the hierarchical Linux file system. /home/user might work, but behind the scenes, you're still dealing with IBM i objects and structure.

• Access to native IBM i resources:

  • Native IBM i commands (like WRKACTJOB, DSPLIB, etc.) aren't directly usable in PASE without special handling via the system command.

---

Why Working on One Helps with the Other

• Linux gives you muscle memory for shell navigation, scripting, and using standard UNIX tools.

• PASE gives you exposure to working in a hybrid environment, where UNIX concepts meet IBM i's robustness and control.

So yes — if you're an IBM i developer looking to sharpen your skills, getting comfortable with Linux can directly enhance your productivity in PASE and QShell, and vice-versa.

Simple IBM i Source Member Version Control

If you haven't implemented source version control on your IBM i system yet, but have a need to start easily capturing source member versions of your classic source from source physical files, we have you covered. 

In iForGit V1.25 a new feature has been added to handle simple source member version control for a team that isn't quite ready for using Git. And once ready for Git, the simple source management commands can still be used to manage moving source between production and development libraries if the source master versions will continue to live on IBM i in source physical files.

Developers can:

Check out a source member copy to their development or test libraries to work on the source. The source member can also be removed from the production library while being worked on if desired. Archive snapshots are always taken before and after source member checkouts so that no source ever gets lost. 

Check in a source member copy from their development or test libraries after completing work on the source. The checked in source member can be removed from the development library when checked in. Or a copy of the development source can be left in the development library once checked in for further work. Archive snapshots are always taken before and after source member check-ins so that no source ever gets lost. 

Capture an instant point-in-time archive snapshot of ANY source member at any time for backup purposes. This is helpful when working on a source member and you don't want to have multiple named copies of the source member lying around. Just take a snapshot and get to work on the source member changes. 

A database log is kept for all archive source versions so developers can easily identify an old source member by reviewing the log file. 

Getting started with source management has never been easier with the new Simple Source Management Commands built-in to the iForGit software. 

For more information to make your source management life easier, visit: https://www.iforgit.com and request more info. Or feel free to email: info@mobigogo.net

 

Who Stole my IBM i Disk Space ?

Solve Your IBM i Disk Use Issues with FREE Disk Utility
In some of my previous roles I often played an extra part as Disk Cop. This often meant scouring through thousands of libraries and directories to find large files and determining who owned them and why they were being kept online. If you understand the phenomena of the ever-growing disk usage you know why Cloud platforms have grown exponentially. It's because storage use never goes down. This post will introduce you to a FREE solution for handling your disk space woes. 

Most likely you might have these disk space questions:  

I need to check ALL the disk space on my IBM i?  

I can't seem to get a handle on our IFS files and I wonder what's taking up space?

The domain of checking free disk space used to belong to commercial utilities or the GO DISKTASKS menu, which was limited to locating only libraries. Let me introduce you to the Ncurses Disk Utility (ncdu). Ncdu is part of the open-source packages available for IBM i. To install ncdu from the PASE or SSH command line simply type: yum install ncdu  Or you can install ncdu from the Open-Source Package Management option in ACS.

After installation, simply change to the appropriate directory and type: ncdu or /QOpenSys/pkgs/bin/ncdu (if the open-source package binary directory is not in your file search path) from an SSH terminal command line. Ncdu must be run from an SSH terminal via putty or your favorite SSH terminal tool.

Listing Free Disk Space for a Single Library
After installation, go to an SSH terminal and log in to the command line and run the following command to check out the QGPL library and show the list of objects descending by size. Libraries exist as a directory inside of the /QSYS.LIB directory. 

ncdu /QSYS.LIB/QGPL.LIB

ncdu results for QGPL - largest objects in use at top in descending order 

After the object list is shown you can use the arrow keys to navigate the list of library objects IFS-style and determine which of them are the largest in-use objects. You can also type a question mark: ? to display options available. If you're brave enough you can use the d option to delete offending objects, but it might be safer to use this tool to identify large objects and delete them another way. It's up to you how you use the app. You have been warned to be careful when deleting objects!

Listing Free Disk Space for the entire IFS Root File System

You can also crawl the entire root / file system on your IBM i partitions using the following command:

ncdu /

It may take a few minutes to get an object list, but you now have a full picture of ALL the directories and libraries (everything under /QSYS.LIB) on your system. 

ncdu root / list results - largest objects in use at top in descending order

Once again you can navigate through the directories to locate offending objects and decide what to do with them. 

That's it. Start policing your IBM i disk space. 

ncdu is a great forensic analysis tool for determine large objects in use. Let me know if you find value in this tool. I surely have. 

This link on learning ncdu might also be helpful: 

ncdu Command Guide | Managing Linux Disk Usage (ioflood.com)

This link points to some ncdu export processing examples

wodny/ncdu-export: Standalone ncdu export feature (github.com)

If your team needs mentoring or learning how to use ncdu or automatically monitoring disk utilization, or if your team needs help with process modernization discovery, training, mentoring and integration services, reach out and let's talk about your business automation pain points. Your team will be on track to streamlining and modernizing your
IBM i processes in no time. 

Web Site: https://www.mobigogo.net

Email: info@mobigogo.net