Context Issue

The first issue was rather generic. The message was Automation error: The server threw an exception. It seemed to happen while the code was looping through a collection of joins or contexts for some universes, although it had never happened to me during my usage. (Of course, isn’t that always the case?) One user was able to send me a copy of their universe for my testing and I was able to recreate the error which is always the first step towards a resolution.

The error was being thrown while processing contexts to get a list of included joins. The first several contexts were processed fine, but one particular context always threw the error mentioned above. I created a very simple program that only tried to traverse the collection of contexts and it threw the same error. (The code is listed at the end of this blog post.) When programs don’t work there are generally only two issues: either the code is wrong or the data is wrong. In this case I was quite certain the code was okay so I started looking at the data.

As I reviewed the context that was causing the error I accidentally “touched” one of the joins, deselecting it from the context. I made sure I restored that join to the context before trying another test run. Imagine my surprise when the “trouble” context was processed successfully on my next test run. Of course the following context still threw the error, but the “data” for the first problem context seemed to have been cleared up. Based on those results I went back into the universe and “touched” every context. I opened each one, deselected and then re-selected a join, and then saved the universe. After doing that, the code ran without throwing any errors while processing the contexts.

I can only assume that something had gone wrong in the way the context was being stored in the universe. I assume that the universe was working okay as far as query generation, but there was something causing problems for the VBA interface. Touching each context cleared that up.

Duplicate Parameters

However that was not the last problem with the test universe provided to me. Once I got beyond the context issue a new error came up while attempting to process the universe parameters. It seemed that somehow in this particular universe each universe parameter had become replicated multiple times!

This was causing a second problem because the name (ANSI92 for example) was used as a unique key to compare the before and after versions of each parameter. I was able to go through and remove many of the duplicate entries, but I decided that I should write some code to address this particular data issue. The code that captures the parameters now captures only the first occurrence of each parameter value and ignores the rest. It could easily be redone to capture the last rather than the first but for now that’s how it works.

2.0.1 Released

Because of the issue found with duplicate parameters I am releasing version 2.0.1 of the script. Please visit the support page to download the updated version. Note that this code update does not include a fix for the context issue as I have not figured out how to address a corrupted context definition with my VBA code yet. If you are experiencing this issue, please try the “touch” process outlined above and see if that addresses your issue.

Note: comments are off for this post to avoid fragmentation of the discussion. Please post any questions about this release on the download page, thanks.

Related Information

Here is the code I wrote to try to help diagnose the issue with contexts. This code simply opens a universe and lists all of the joins assigned to each context. It should work perfectly fine as long as the data is valid.

Sub main()

    Dim boDesignerApp As Designer.Application
    Dim boContexts As Designer.Contexts
    Dim boContext As Designer.Context
    Dim boJoins As Designer.Joins
    Dim boJoin As Designer.Join

    Dim boUniv As Designer.Universe

    ' Establish a Designer session and log in
    Set boDesignerApp = New Designer.Application
    boDesignerApp.Visible = True
    Call boDesignerApp.LogonDialog
    Set boUniv = boDesignerApp.Universes.Open

    Dim strJoinSet As String

    Set boContexts = boUniv.Contexts

    For Each boContext In boContexts
        strJoinSet = ""
        iRowNum = iRowNum + 1
        Set boJoins = boContext.Joins
        For Each boJoin In boJoins
            strJoinSet = strJoinSet & ", " & boJoin.ID
        Next boJoin
        Debug.Print "Context " & boContext.Name & " has joins " & strJoinSet
        Set boJoins = Nothing
    Next boContext
    Set boContext = Nothing

End Sub

Get it here.

Please post any support questions on the release page, and not on this blog post. The page will remain a permanent link on the top of my blog, while this post will eventually roll off of the front page. I hope that the utility proves to be useful, and that the wait was worth it.

Which brings up the philosophical question: if a blogger writes a post and nobody reads it, does it make the sound of one hand clapping? Or something like that…

Background and Purpose

Business Objects universes have always presented a challenge for people who want to track code changes and understand differences between versions. Universe information is stored in a binary file (.unv format) and is not readable by normal means. However, starting with Business Objects 4.0 the software included a basic scripting language (SBL) which allowed us to create some additional functionality. Starting with Business Objects 5.0 they switched to Visual Basic for Applications (VBA) provided by Microsoft. Both Desktop Intelligence and Designer had their inner workings exposed via a new software development kit (SDK).

Up until Business Objects XI the universe was stored in a set of relational tables in the repository. With a little research, it was not too hard to figure out where the various components of a universe were stored, and since everything was in relational tables many clients wrote universes and reports against this data. In some cases I even saw some folks that had created ways to check for differences and dependencies. However, when XI was released all of those utilities became worthless because the universe was no longer broken apart and stored in relational tables. We could no longer run reports that would show the content and structure of our universes.

Some years back Dwayne Hoffpauir released a VBA utility that provided a way to document a universe by extracting the various components into Microsoft Excel. This was in many ways the first step towards building a compare utility. Some enterprising folks were able to run the program against two different universes, then use third-party tools to identify the differences between the two workbooks. However, Dwayne’s utility was not really designed for this use, and in my opinion the third-party compare tools left much to be desired since they didn’t really “get” universes. For these and other reasons I decided to write my own utility that could be used to compare two universes.

First Release

The first version of this utility was completed in 2006 and was used in a Business Objects 6.5 project. This project required all programmers to check in a log of changes made before any code could be promoted. No matter how hard I protested that a universe wasn’t really code they would not relax this requirement. I thought about Dwayne’s utility, and used the concepts to create my own universe extract. The main difference was that mine was designed to extract classes and objects from two universes and then compare the results, all within an Excel environment. This first release had a lot of hard-coded elements and was not extendable as it was only designed to compare SQL differences between objects and predefined conditions. That meant that it could not easily be extended to compare joins, contexts, hierarchies, or any other universe element. It was successful as a proof of concept, but not viable as a long-term solution, therefore I did not publish this code.

Second Release

By 2008 I had completely rewritten the code. It was much more modular and included code to extract and compare classes, objects, tables, and joins. At this point I discovered that my method of comparing the “before” and “after” sets was not efficient enough to handle large universes. I was using Excel worksheets to contain the extracted data and trying to compare universe elements via their assigned ID. At first I tried to store each element in the row based on the assigned ID, but that was not very effective because there is no guarantee that ID’s will be sequential. The concept was sound: in order to look up an element in the “after” set in order to compare to the equivalent item in the “before” set I only had to check the row in the proper worksheet. While this was an effective way for matching elements that had a match, it was not an efficient way to track items that were new (existed only in the “after” list) or removed (existed only in the “before” list.)

Next I tried to create arrays to track the before and after sets, but while many universe elements have a system-generated key (objects, tables, and joins) many others do not (hierarchies, contexts, and others). That’s why this release only compared the four elements mentioned above; all of those elements have a system-assigned numeric key that could be used as an array index. Contexts and other elements didn’t have a numeric key so I had left them out for now. Of course it was important to be able to compare these elements so I started drawing on my experience with programming in other languages for inspiration.

In perl or PHP I can create arrays that do not have requirement of a numeric value for the array index. I started looking for a similar concept for VBA, and after some research I found the Microsoft Scripting Runtime library. This library allowed me to create arrays in VBA with a non-numeric key. In the previous version of the script I had written a specific routine to extract each component of a universe into a specific worksheet, then I had written another specific routine designed to compare the “before” and “after” sheets for that specific component. After rewriting this portion of the code to use the scripting library I was able to create a single subroutine that would do all of the compare operations. Ultimately I had plans to rewrite the extraction routines and replace all of them with a generic routine but I never got around to that.

Third Release and Conference Demo

In 2010 I finally had completed the parts of the code that I wanted to have ready in order to release it for others to use. I demonstrated it at the SBOUC. During the demonstration I took a risk. I asked for three suggestions from the audience as to what I should change in the “after” version of the universe, made those changes, crossed my fingers, and hoped that the script would capture everything. It did, and I felt good about the result and was fully intending to release it last fall.

Unfortunately I discovered that there were still some issues with the code when I returned back to work from the conference. Some universes were large enough that the list of elements (specifically the list of incompatible objects) was too large for the 65K row limit of the Excel host. One more tweak was required. The workbook already included a worksheet called “Config” that I intended to hide to prevent accidental edits. I left this sheet visible and added a list of universe elements and a Y/N flag. If the flag is set to “N” for a specific universe component, then that element will be ignored during the compare operation.

Now, here in 2011 I am finally releasing the code. When? It could be any day now…

System Requirements

I have tested this tool on BusinessObjects 6.5, on XI R2, and XI 3.1. The only host operating system I have tested is Windows XP. (Yes, still on XP here.) The code as released is configured for XI 3.1. There are minor changes that would be required to run for XI R2 which I will include in the support post. Microsoft Excel acts as the host for the VBA (Visual Basic for Applications) script; I have not tested on all different Excel versions so there may be some issues there. There is one additional library that must be available in order for the script to run. You must have available on your system the Microsoft Scripting Runtime which on my system is found in C:\WINDOWS\system32\scrrun.dll. If you don’t have this file, the script will not run. You may need to search the Microsoft web site for a downloadable version that is compatible with your operating system.

Along with this library the script references the Business Objects library for the appropriate version (11.0 or 11.5 for XI R2 – may depend on patch version – or 12.0 for XI 3). It also includes references to the Excel object library (for obvious reasons). The script can only be run on a workstation with both Excel and the Business Objects Universe Designer application installed. The Excel and Business Objects libraries required should be already on your system if the appropriate programs are installed.

None of these libraries are provided with the script so you are responsible for finding legal and appropriate means to install these items on your system.

There is no Unix version of this script, nor will there be. As stated earlier, it is designed to be run on a system that has the XI Universe Designer application installed. As there is no Unix universe designer, there is no option for this tool to run on that platform.

There is no batch version of this program. It is designed to run interactively as it prompts the user to open the two different universes that are to be compared. It is certainly possible to create a batch “wrapper” for this program that would automate the comparison of multiple pairs of universes but it is not my intention to work on such an enhancement at this time.

Support

Support will only be provided via this blog only on an “as time is available” basis. There will be no email, twitter, or phone support, free, paid, or otherwise. I will not support this program via BOB, SCN, or any other online community. “As time is available” means it may be hours, days, or even weeks before your question is answered, depending on what else I am working on at the time. If you are not comfortable with those terms, please do not download or use this software. I will have a blog post dedicated for posting support questions, and a link to that post will be included in the software that you download.

There is no guarantee that support will continue as I reserve the right to discontinue support at any time and for any reason.

I do not plan to support any questions on Business Objects 6.5 or earlier versions, although it is entirely possible that this script will work there I no longer have a platform on which to test or diagnose bug reports.

Future Plans For BI 4.x Implementation

This script may work on .UNV files under BI 4.0 but will not work on .UNX files, nor are there any plans on my part to make a BI 4.0 version that supports .UNX files. The new Information Design Tool does not currently offer an SDK. Future versions of the IDT may offer an SDK but it is likely to be java-based so this tool would have to be rewritten on that platform. It will not be possible to create a BI 4.x version of this script until an SDK is available.

Warranty

From the GNU GPL license:

15. Disclaimer of Warranty.
THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM “AS IS” WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.

16. Limitation of Liability.
IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.

Usage Restrictions

There are none. If you are a consultant or contractor, feel free to use this program for personal use or within your company environment or at client sites. In other words, I do not place any restrictions on how or where you can use this program. Your company or client policies may prevent you installing this program on their networks or using it in their environments so be sure to check for and understand their specific policies regarding third-party software. The only restrictions are applied by the GPL, which is to say that if you distribute the script you must include my copyright information and the full GPL license, and if you base any derivative works on this program those derivative works must also be bound by the GPL license.

I’ve been using this code for over two years, making tweaks and adjustments along the way as needed. I have no problem using it in my environment. The program does not write anything into your universe. The only operations performed are “open” and “read” and those operations are only applied to the two universes that you are attempting to compare. I have never had this script corrupt a universe. I have occasionally had the script bomb because of a bug or some unanticipated scenario. If you encounter an issue, please add a comment to the dedicated support and FAQ post, which will also contain the link to download the latest version of the program.

I want to get credit for my work. I want people to know what I wrote. Can I still get credit if I use the GPL?
You can certainly get credit for the work. Part of releasing a program under the GPL is writing a copyright notice in your own name (assuming you are the copyright holder). The GPL requires all copies to carry an appropriate copyright notice.

Simply put, this means that even though I am releasing code under the GPL I still retain the copyright to the code. Releasing it under the GPL ensures that anyone who downloads the code for use has the right to do so, and that those rights cannot be removed by someone else. If someone were to download my code and modify or improve it in some way, then the modified / improved version must also be released under the GPL, so that everyone can benefit.

If I add a module to a GPL-covered program, do I have to use the GPL as the license for my module?
The GPL says that the whole combined program has to be released under the GPL. So your module has to be available for use under the GPL.

That restates what I was saying earlier. By releasing my code under the GPL it protects everyone. Someone could take my program and turn around and try to sell it, but anyone who buys a copy – even if there are improvements – has the right to then distribute the software for free. Code based on GPL software must be licensed under the GPL, which grants the user the right to decide what to do with it, not the owner of the copyright.

What does this have to do with anything? I just finished a project where I reworked a very large universe. During that project I used my universe comparison tool quite extensively, and I think the final testing is done. I will be posting a copy of the VBA code for download next week here on my blog. The software will include the GNU GPL license so that anyone is free to use it in any way they see fit.

Keep in mind that – unfortunately – there is already an expiration date on the software, as the BI 4.0 Information Design Tool does not initially ship with an SDK, and even when it does start to provide one it will likely be in java rather than visual basic. So enjoy it while it lasts.

Once that is complete, I will release the initial version here on my blog. I anticipate at this time that I will be able to do this early in December. Thanks for your patience.

While on the subject of the SDK… I was asked multiple times when I would be posting my script from the conference. I discovered a few days before the presentation was due that there is a problem with joins when switching from one database to another. For example, we are in the process of switching one of our larger datamarts from DB2 to Teradata. I am going to write a more detailed blog post on that shortly, but let me say that my universe compare script was very useful during the process. But during the compare process I found that this join:

table1.table_1_id = table2.table_2_id

Got changed to this:

table2.table_2_id = table1.table_1_id

Of course both joins are functionally the same. But to my script they showed up as three different changes. Table 1 was changed from “table1″ to “table2″ while Table 2 was changed in reverse. And of course the join logic was reversed as shown above. So while this was not really a change, my script was recognizing three unique differences between the two universes, all related to that one join. I had not encountered this when running against two different versions of the same universe pointing to the same database, which is the expected use of the tool. I created it primarily to compare the DEV and PROD versions of the same universe. But I am trying to think about a way to update the code so that inverted or reversed joins are not detected as changes. If I can’t come up with something in the next few weeks, I will go ahead and post the code as I demonstrated it at the conference last week.

As of today I have completed the rewrite and am now going to extend the comparison to other universe components. I expect to have the final code ready to demonstrate (and release) during my talk Change Management Strategies For Universe Developers at the fall BusinessObjects conference. And of course once I release it there, I will also set up a way to download the code here on my blog.

Why use this tool rather than some of the other tools that are available? For one thing, it will be free. Free is good. It will be released under the GNU GPL license, which allows me to retain the copyright on the code while ensuring that the code can be distributed without restrictions. Support for the code will be on an “as time allows” basis here on my blog. For more details on the GNU GPL license (if you are not familiar with it) I have included a link at the end of this post. Basically it says that I retain copyright of the code, but anyone can use it however they see fit. So there are no restrictions on using it for personal or company use, and it can even be redistributed. The only requirement is that the code remains free of all restrictions and that my copyright information be retained in a visible fashion.

I’m excited to be able to finally complete this project. When I submitted the abstract for the conference I was hoping that it would get accepted, and that would be the incentive for me to get around to completing the code. It seems to have worked. Now all I have to do is complete my slides and get them submitted (a week late). I look forward to being able to share the results and the code in Orlando.

Related Links

• GNU GPL V2

Executive Summary

This utility is designed to automate the update of the schema or owner name in a universe. The host application is Microsoft Excel since the Universe Designer application cannot be a VBA host. You enter the “From” and “To” schema names into cells in the XLS and run the macro. At completion you will have a universe where the schema (or owner) has been updated.

Explaining the Problem

When I build a connection to Teradata, I do not connect to a database. I connect to a server. That server could be the host for more than one database or schema. That means that for my universe I have to fully qualify the tables as owner.tablename rather than referencing the tablename by itself. This presents a problem because my schema names change during the migration process. And most migration managers frown on editing code during the migration process.

In this particular case the schema name is a short abbreviation of the project (I will use PROJ for this blog post) followed by a letter that designates the purpose of the schema. For example, _D is the development schema, _S is the System Test schema, and _P is for production. A table that is named PROJ_D.tablename in development will become PROJ_P.tablename in production. That’s a code change.

First Solution

If you have a simple universe you can highlight all of the tables, right-click and select the “rename table” option from the mouse menu. With this technique you can update the owner for every single table in the universe in one step. But what if you have aliases as well as regular tables? In that case, you have to selectively highlight all of the tables (ignoring the aliases) and rename only the source tables. The aliases will inherit the change.

The easiest way I have found to do this is to use the table listing on the “List Mode” panel that you can show on the top of the screen. That way all of the tables with the same owner are listed together, and rather than use the graphical structure to rename my tables I can use a list. This works well, and solves the problem.

Until you introduce Derived Tables into your universe.

Second Solution

When you use a derived table those tables don’t really have owner names since they exist only in the universe. But they do reference tables in the database, and as discussed above, they will include the schema or owner name. In order to migrate derived tables correctly, I had to open each one and update the SQL manually. This was a problem.

The main issue is that I was changing the code during a migration. That means that a bug could be introduced. And introducing bugs during a migration (after system testing has been completed) is not a popular result.

So what I did to solve this issue at first was to create an Excel spreadsheet that contained the SQL code required for each derived table. I created formulas where the schema name was a reference to a single cell in the sheet. To migrate a universe I would open this XLS, update the schema name in one place, and see that schema name updated in each different SQL statement. It becomes a simple copy / paste operation during the migration rather than an “edit” operation. This was certainly safer, because the code itself was verified and the only thing that was being updated was the schema name. But there were still problems.

For example, at one point we had someone new join our team, and their video resolution was smaller than mine. What does the video setting have to do with this? Smart question. The issue was on my screen I would see seven derived table definitions. On their screen, because it was smaller, they only saw five. That meant when they processed the instructions in the spreadsheet they only updated five of the seven derived tables, with the net result being we got code in production that was not working.

Automate the Process

So now, finally, the VBA solution. The advantage of VBA (or any programming language) is that it’s going to do exactly what you tell it to do. It won’t do half of the derived tables and skip the rest. It won’t accidentally miss a table during the selection process. If you set up a program loop and tell it to process every table, that’s just what it will do.

The Code

The code is contained within a host application since Designer cannot host the code itself. I selected Excel as my host which is quite common. Many of the utilities on BOB’s Downloads do the same. I will detail the code here, and the entire file is presented as an attachment at the end of this post. Disclaimer: This code should be considered “beta” quality at this time. This means it is “use at your own risk” and make backups and all that good stuff.

Getting Started
First there are some basic settings and declarations that appear at the top of every Business Objects utility that I write.

Option Explicit                 ' Require variables to be declared before being used
Option Base 1                   ' Start array indexes at 1 as I think better that way

Dim boDesignerApp As Designer.Application
Dim boUniv As Designer.Universe
Dim xlSheet As Excel.Worksheet

Next there is the main routine. In most cases my main routines are very short, often (as in this case) there is nothing in them except for function or subroutine calls. This means that the main routine reads more like a process flow and less like actual code. I think it’s easier to manage that way.

Sub Main()

    Set xlSheet = Worksheets(1)
    Call UpdateSchema
    MsgBox ("Done")

End Sub

The first line of code is a shortcut and would not be in the final code. I use it so I have a reference to the first sheet in the workbook where the schema names appear. I generally try to provide all of my input variables via excel cells rather than requiring a user to answer a prompt (because I’m lazy) or editing the code (because of the potential for mistakes).

Next, the function used to update the schema names. The “Private” declaration means that you cannot run this macro function directly. It can only be called from other code.

Private Sub UpdateSchema()

The next lines are declarations for variables that I need. The Designer reference is going to give me a handle for the application, and the tbl item will point to the collection of tables in my universe once it is open.

    Dim tbl As Designer.Table
    Dim sSchemaFrom As String
    Dim sSchemaTo As String

Those lines of code retrieve the “from” and “to” schema from the appropriate cells in the worksheet. Minor point: if you use this technique, I strongly suggest that you use named ranges rather than absolute cell references like “A1″ as it makes the code much easier to maintain.

    sSchemaFrom = xlSheet.Range("SchemaFrom").Value
    sSchemaTo = xlSheet.Range("SchemaTo").Value

Next, log in to Designer. The code to do this is different depending on whether you’re using versions 6.5 or earlier or XI. Both syntaxes are shown here.

    ' Establish a Designer session and log in
    Set boDesignerApp = New Designer.Application
    boDesignerApp.Visible = True

    ' Use this method instead for older versions
    ' Call boDesignerApp.LoginAs
    Call boDesignerApp.LogonDialog

Next, open the universe. Since I don’t specify a universe name, I will be able to interact with the standard “File – Open” dialog box provided by Designer.

    Set boUniv = boDesignerApp.Universes.Open

After opening the universe it is time to process the tables. This next block of code loops through each table in the Tables collection. There is an attribute called IsAlias that is true if the table is an alias rather than a true source table. If that flag is true, then there is no processing done on that table. The “debug.print” command sends output to the debug window; a user will not see that information.

    boDesignerApp.Visible = False

    For Each tbl In boUniv.Tables
        If tbl.IsAlias Then
            Debug.Print tbl.Name & " is alias"

Next, if the table is a derived table I have to update the schema name in the SQL. There is an called IsDerived that will be true if the table is a derived table. If it is true then the attribute SqlOfDerivedTable contains the SQL code.

One note: if the update fails the derived table will still exist but it will be in an invalid state. In this case what I have found is that a universe integrity check will fail in catastrophic fashion.

        ElseIf tbl.IsDerived Then
            ' Update derived table SQL here
            Debug.Print tbl.Name & " is derived"
            tbl.SqlOfDerivedTable = str_replace(tbl.SqlOfDerivedTable, sSchemaFrom, sSchemaTo)

Finally, if it’s a normal table then the Name attribute contains the full name, which includes the schema. I update the name attribute then loop to the next table in the collection.

        Else
            ' Update table owner
            Debug.Print tbl.Name & " is table"
            tbl.Name = str_replace(tbl.Name, sSchemaFrom, sSchemaTo)
        End If
    Next tbl

Finally, save the universe and exit.

    boUniv.Save

    ' Release the Designer app and recover memory
    boDesignerApp.Quit
    Set boDesignerApp = Nothing

End Sub

This code is fairly simple, once you know which attributes (they are actually called “properties”) are available. The last bit of code is the str_replace() function. There is no function named str_replace() in VBA by default, but there is a Replace() function. So why did I create something brand new, if all I am going to do is call a built-in function? It’s a good question.

There are many advantages to creating a function wrapper. First, if I need to port my code to a different version of VBA there might not be a Replace() function. By creating my own function call I can write a replacement function without touching the rest of the code. The more important advantage, however, is that I can put extra code inside my function. Here is what my str_replace() function looks like right now:

Private Function str_replace(ByRef sSql As String, sFrom As String, sTo As String) As String

    sSql = Replace(sSql, sFrom, sTo, 1, -1)
    str_replace = sSql

End Function

As you can see, there’s not much going on other than a basic replacement of text. But what I thought about doing is writing a log to the Excel worksheet showing the “before” and “after” state of each table that gets processed in the loop. That will help create an audit trail and make debugging easier as well. At the moment that code does not exist. But by creating a wrapper for the Replace() function I can do that.

I use this technique all the time in various programming languages, not just VBA. It has served me well in the past.

So that’s the end of the code. What, you thought there was more?

Conclusion

I’ve done only very preliminary testing for this utility so far, but it seems to work just fine. I expect that it will really help my current client with their Teradata universe migrations.

Downloads

The following utility is released under the GPL or Gnu Public License. This means that you have the freedom to do whatever you like with the code but it must retain my copyright. There are no licensing costs associated with use in a corporate or any other environment. No warranty is expressed or implied.

• Dagira Schema Change Utility