#rpgiv

Following on from the last blog, this one will extend your Embedded SQL knowledge. This blog will mainly focus on two things. First: SQLSTATE and how to use it to your advantage. Second: Dynamic SQL queries in Embedded SQL

SQLSTATE is define as a Char(5), although for this tutorial we're only really interested in the first 2 characters (%Subst(SQLSTATE:1:2)). You can find out what those two character codes mean here. We're going to look at the following (for this tutorial):

00 Unqualified Successful Completion It works! 01 Warning Something broke(d)! 02 No Data Couldn't find the data you wanted

I also want to let you know, if you plan on debugging embedded SQL which affects a physical file in a *PROD library, make sure you STRDBG with UPDPROD(*YES) otherwise you'll get some weird SQLSTATE like 42 or 54. When you're debugging Embedded SQL and something goes wrong, always EVAL SQLSTATE and then DSPJOBLOG.. Embedded SQL will always print to the job log if you're debugging.

Back to the blog; In the previous blog, I used the following as an example:

Exec SQL SELECT CUS_BAL, CUS_NAME INTO :Customer.CUS_BAL, :Customer.CUS_NAME FROM CUSTOMERS WHERE CUS_ID = 1; printf(Customer.CUS_NAME + x'25');

But what if there is an error? At the moment, we're just printing Customer.CUS_NAME no matter what happens. Let's handle that using some of the 2 character codes we'd spoken about earlier. I'm using a SELECT and WHEN to check the value of gSql. gSql is defined like so and we only assign to gSql after we have used EXEC SQL statements. You may want to replace the static strings with constants.

Dcl-S gSql Char(2); //Embedded SQL happens here gSql = %Subst(SQLSTATE:1:2); Select; When (gSql = '00'); printf(Customer.CUS_NAME + x'25'); When (gSql = '01'); printf('Probably worked, but with warnings. ' + 'Check job log?' + x'25'); When (gSql = '02'); printf('No relevant data' + x'25'); Other; printf('It''s worse: ' + gSql + x'25'); ENDSL;

Project Alexis is a college project for the last unit on my course - Unit 311, Create a Procedural Program. Creating procedural programs is easy and boring! So I took it to the next step and made a stack based virtual machine in RPGLE on IBMi.

So far, it's a very basic instruction set. It's probably best to explain by showing examples and listing its features. Features include:

Functions

Implicit types

Interpreted

Debugging tools

First off, functions. Everything is inside a function, there are no global variables or anything like that. The two function instructions are STRFUN and ENDFUN - as you can guess, start function and end function.

Next is implicit types. You don't have to worry about type conversion as it will be converted at runtime - everything is stored as Char(72) in the backend. The only thing you need to note is that each type has it's own operations. For example, for adding doubles (decimal numbers) you'd do a DECADD or adding two integers you'd do an INTADD.

It's interpreted, and there's nothing wrong with that.

The best part, it has a debugger. It allows you to step through, set breakpoints.. the lot.

Better start with some examples, with comments:

STRFUN Test .LDVAL Hello world //Load 'Hello world' onto the stack DUP //Duplicate the latest value PRINTF //Print the lastest value on the stack .LDVAL *BLANK //Load '' onto the stack CALL HELLO //Call a function named HELLO (below), all functions require a parameter. .LDVAL 1 //Load '1' onto the stack .LDVAL 5 //Load '5' onto the stack SUBSTR //Do a subst PRINTF //Print the latest value on the stack ENDFUN STRFUN HELLO .LDVAL Hello there DUP PRINTF .LDVAL 1 .LDVAL 5 SUBSTR .LDVAL 7 .LDVAL Liam APPEND PRINTF ENDFUN

Change management can be pricey and confusing, espcially if you're developing on a shared hosting and only have access to a limited amount of libraries.

Along side FFEDIT, I've been working on FFCR. If you don't know what FFEDIT is, it's a free format source editor for IBM and can be found on GitHub.

FFCR is a very basic change management system. Other change management systems would use your library list to create new change requests (by creating a library over the top of another) but instead my system works with source physcial files.

It starts with a basic Load Change Request screen where you're able to enter your working library and the CR keyword:

Or you can press F5 to show a list of change requests that are currently open:

After you've loaded your change request, you'll be taking to an area where you can 'work' with your change request, which states the library, the base source physical file and the change request's source physical file:

Using option two can open the window to pull a source member in:

Of course if you try to pull a member that us already pulled into another CR..

And lastely commiting your changes back to the orignal SPF - nice and simple, even looks pretty: (I did notice that it shouldn't say "Library" when mentioning the CR because it's really just an SPF in the base library.)

I think what makes .NET so useful is it's object orientation, I think I may be able to implement this within the scripting language I am creating.

I would want the operation codes to look something like this:

newob Person //Creates an object called person field Person ID //Give the object fields field Person Age //Another field newob Person //Create a new instance of person into the stack pushi 1 //This would be the ID callobject set ID //Set that object's instance ID to 1, will push //he object back onto the stack stloc 1 //Store the object address ldloc 1 //Load the object's instance onto stack callobject get ID //Load the ID field from this object, will push //he object back onto the stack before the number pushi 1 //Load a numeric add //Add the ID and 1 together, pushing 2 to the stack stloc 2 //In theory we copied customer 1, changed the ID //and then stored it in another location