RELEASE NOTES for IBO Version 5.x

 

Change Log:

 

11/1/2016 Version 5.9.1 [Build 2522]

 

I majorly reworked the TransactionOAT tutorial application to showcase recent additions to IBO.

I included a new piece of documentation "Optimizing Queries and Transactions" in the docs folder.

Improved the SearchingLinks capabilities and demonstrated in the BrowsingItems sample app.

Improved TIB_Grid to behave gracefully if during validating or painting rows there is an exception.

Improved IBO to avoid or handle when a BLOB has been removed and is not able to be found.

I reworked some session global resources to be handled locally in an effort to make IBO more resilient against multi-threading problems.

TIBODataset will use persistent field ProviderFlags pfInKey to define KeyLinks of the query.

Fixed a problem having to do with TIBODataset and applying filters failing and leaving the dataset open or closed in an inconsistent manner. It now leaves the dataset open consistently. TIBOTable also behaves better when changing the TableName property. If it was open it stays open.

Fixed the CreateDatabase() method to properly handle international characters.

Fixed a problem where changing the OrderingItems property caused an Unprepare/Close.

Fixed a bug having to do with using the Origin property in persistent TField objects.

I fixed a problem having to do with input parameters with duplicate names.

IBO more aggressively binds them together if it can or it will raise an exception if it can't.

I added a new UpdateAction type uacIgnore in order to override data conflicts.

I added a data conflict detection and management system.

I made a DefaultHandleUpdateError routine in the VCL application handler.

I made it so that cached updates and DML caching are fully integrated and cooperative.

Added ability to see underlying conflict information in TIB_Grid.

Fixed some issues with the TIB_Monitor output of rows and blobs.

Fixed some issues with Firebird 3 and Lazarus/FPC BOOLEAN column support.

Added an optimization to TIB_StringList.Assign when they are both blank.

I made it so that input parameter names can be read out of adjacent block comment.

            WHERE MyTable.MyCol = ?/* MyParamName */

 

I totally reworked the UpdateSQL capabilities allowing more update modes to work with.

The following properties were added: UpdateModeEdit, UpdateModeDelete, UpdateModeInsert.

There is also a set of these properties for when CachedUpdates is enabled called CachedUpdatesUpdateModeEdit, CachedUpdatesUpdateModeDelete, CachedUpdatesUpdateModeInsert. Please see the TransactionOAT tutorial and documentation for more information about this new feature. Legacy properties SearchedEdits, PreparedEdits, PreparedInserts will still work fine but they are deprecated. They now map into the new functionality.

 

I improved the transaction handle management so that fewer stuck transactions will happen.

Added feature to TIB_UpdateBar to allow it to do a Revert on posted cached update items.

Fixed "Fetching Query Results" dialog to properly handle request to cancel fetching.

Added feature to TIB_Grid allowing a click on the corner title cell to get sorted in natural order.

Added OnNotFound() event to TIB_IncSearch control.

Fixed an issue with IncSearch() and the NOCASE ColumnAttribute setting.

Fixed a bug having to do with DFM streaming of the KeyRelation property.

 

 

8/8/2016 Version 5.7.15 [Build 2419] (Was not released)

 

Fixed a bug having to do with string primary keys and trailing whitespace.

Fixed installer scripts for Delphi 10.1 Berlin.

Added some aggressiveness at avoiding long-running transaction.

 

6/8/2016 Version 5.7.13 [Build 2411]

 

Enhanced TIB_Grid control to color all columns that are part of a multi-column sorted dataset.

 

Fixed a problem with TIB_SearchEdit and the SearchingLinks feature so that NULLs are not problematic. I also fixed a case where it would freeze when this control would call Application.ProcessMessages.

 

Enhanced TIB_LocateEdit control to make use of the SQLOrderLinks so that it can take advantage of multiple column searching. I also added a property so that you can user define what character you want to delimit the multi-column values with.

 

Enhanced a workaround to deal with an old Firebird bug so that the SQL trace monitor doesn't get flooded with cursor close messages by attempting to work around that issue when it no longer exists. This will also make the code run more efficiently overall.

 

Fixed an Access Violation if the EIB_ISCError exception object is instantiated with TObject.Create() constructor instead of the more appropriate constructors.

 

Improved IBO's logic to keep inactive transactions closed to avoid extra garbage collection and bloating.

 

Fixed issue with field trimming on key columns when using TIB_Import.

 

Added enhancement to the TIBOBackupService and the TIBORestoreService. It's now possible to use stdin.

 

Fixed problem where the following TField types were not properly registered with the Delphi IDE:

TIBOBooleanField, TIBOWideStringField and TIBOArrayField.

 

Fixed a bug that caused "Column Type 0" error.

 

Fixed a bug where primary key column values were being trimmed of whitespace when they shouldn't have been.

 

Improved handling of domain name based column attribute settings.

 

Improved buffer synchronization logic.

 

I made a few improvements to the CPPB 5 build files.

 

5/2/2016 Version 5.7.11 [Build 2388]

 

I added support for Delphi 10.1 Berlin.

 

I fixed an access violation bug with the TDataset TField.OnValidate event handling. This only affected XE8 and up and BCD fields.

 

I fixed the problem where Origin information is plugged into persistent TField objects and then causing problems.

Now I keep track of when I plug in Origin information and clear it out when the query is unprepared.

 

Fixed a bug in TIBOTable.ResetSQL().

It was raising an exception when the TableName property is being set when it shouldn't. The problem was because it disturbed the form loading.

 

I fixed an issue with 64-bit LINUX support.

Had to make the transaction buffer use C-style record packing.

 

Contributed changes by Wassim:

Fix GetJumbleKey for Lazarus

Fix compilation for Lazarus due to Lazarus FileUtil/LazFileUtils changes

Fix compilation for Lazarus: types.TSmallPoint vs Classes.TSmallPoint

 

12/14/2015 Version 5.7.9 [Build 2360]

 

I added support for Delphi 10 Seattle Update 1.

 

I fixed a minor issue in the IB_Export helper form. The import/export button wasn't being enabled properly for all SQL statement cases.

 

I improved the TIB_LocateEdit control. It now allows you to performn navigation commands to the dataset using the up and down arrows in it.

 

I fixed a parsing bug in the routine that converts a list of field names into a string list of field names. It was causing an out of bounds error when it shouldn't have in some cases.

 

I fixed a bug in the IB_FTS (full text search) system. In some cases, when dropping a metadata index there would be an access violation. I also fixed things so that it is possible to use the OCTETS character set for keys. In the case that was fixed they were using a GUID as a key.

 

I improved the installer to deal with the 64 bit version of Delphi not being included in recent versions of Delphi.

 

8/27/2015 Version 5.7.7 [Build 2340]

 

I added support for Delphi 10 Seattle.

 

I fixed an issue when in some cases using the OLD_ prefix on a parameter name could cause a parameter type mismatch.

 

Added ability to define a character set for the admin services components. I also fixed how it generates exceptions so that more information can be gleaned out of the exceptions it raises.

 

I fixed a painting bug in the TIB_Edit control when using buttons.

 

I fixed an issue in the TIB_Grid inplace edit OnKeyPress handling logic with FormatSettings and numeric entry.

 

Added ability to do OnTranslateString event more uniformly in the TIB_Export component.

 

Fixed problem when using EXECUTE PROCEDURE statement with the TIB_Import component. Also fixed an issue where it was possible to fail to import the last record if it wasn't terminated with a CRLF or an EOF marker.

 

I fixed an issue in TIBODataset that had the Bookmark property behaving differently when an insert or an append were cancelled. I also fixed a bug in how input parameters are handled. In a rare case it would give an exception of index out of range.

 

Started working on supporting the new InterBase XE7 change views feature. It isn't quite finished yet.

 

5/16/2015 Version 5.7.5 [Build 2275]

 

I added support for Delphi XE8.

 

I added a new property to TIB_Connection called OnResolveBoolean so that people can customize how their boolean values are handled.

 

I fixed a bug in the TIB_Grid to color the fonts more appropriately when a grid cell is focused.

 

I fixed a bug in the handling of the FOR UPDATE clause where a list of editable columns is provided.

 

I fixed a problem with using reserved field names with double quotes in the DisplayLabel property.

 

I fixed a problem with control focusing issues when the app has a form with visual controls and an explicit TIB_Session instance on that form. Some of the visual controls were causing a default session to be generated and then remained associated to it instead of to the explicit session. As a result, they were not responding to focussing notifications.

 

I improved the Clean and Build scripts to deal with the paths better.

 

I fixed a problem with the TIB_Export component so that it will export SQL data in a format that TIB_Script can handle where special characters are concerned.

 

I improved the RowsAffected results for the stExecProc statement type.

 

I fixed a problem where TIBOTable with persistent fields was having a problem when using SetRange().

 

 

3/26/2015 Version 5.7.3 [Build 2265]

 

I fixed a bug in TIBOStoredProc where it was losing its input parameter information if the stored proc name was set when there wasn't a connection to the database.

 

Some minor improvements to the TIB_Events.pas unit.

 

Some additional improvements for Free Pascal Compiler / Lazarus support.

 

Some work on the work in progress document processing engine.

 

2/12/2015 Version 5.7.3 [Build 2238]

 

I added the IB_ClientLib.pas unit and the TIB_ClientLib component for allowing one application to connect through separate instances of the client DLL. This will allow one application to have a connection to both a Firebird and and InterBase database. This has become necessary due to the inability to have cross-compatibility between these now divergent products.

 

I made some improvements to the filter parsing logic. It didn't handle the inclusion of input parameters and it didn't handle the LIKE clause if there wasn't a space after it. I also made some improvements to how things behave when a filter that is invalid is attempted and what happens as a result of an exception. IBO will now reliably and consistently put you back to the state it was in prior to the invalid filter.

 

I included a user supplied enhancement to have a new CharCase feature to only uppercase the first character.

I altered an internal behavior that would always use the SchemaCache.Transaction when preparing a statement. It will now only do this if you have not provided a TIB_Transaction instance explicitly. 

 

I altered the logic of how blob caching works. I have been using the BLOB_ID to determine the identity of cached blob contents, but it was shown to me that the server will reuse the BLOB_ID of a previous content with new contents. This means that I actually cannot rely on the BLOB_ID remaining stable. So, when InvalidateRow is called, or InvalidateRows, etc. I flush out the cached blob information in order to avoid this potential ambiguity.

 

I fixed an issue with the Full Text search component. It was having a problem removing the metadata due to object in use issues.

 

I fixed the DBF export to better handle the new UTF-16 string type. It was producing unusable files from Delphi 2009 and higher.

 

1/16/2015 Version 5.7.1 [Build 2194]

 

I added the following routines to the regression testing app:

    procedure Test_OLD_ID_AsParameter;

    procedure Test_ExecBlockParamIssue;

    procedure Test_LocateOnJoinAmbiguous;

    procedure Test_SelectDistinctAs;

    procedure Test_LocateWithLongInput;

 

I added the IB_SQLStringList.pas unit to the core module in order to provide better control over the SQL parsing mechanisms. There were also some basic enhancements to the TIB_StringList class to help it better keep track if it was actually changed or not.

 

I included an enhancement by Magnus Johansson to improve the formatting of IN() search criteria clauses.

 

I improved the handling of RecordCount requests when the source query has SELECT DISTINCT ... AS colalias ... format.

 

I improved support for EXECUTE BLOCK statements. You now get their fields list returned in the parsing information and it uses this list to determine if it is to be treated as a SELECT or as an EXECUTE PROC operation. They can go either way depending upon if there is output.

 

I reworked the internal statement processing significantly in an effort to reduce the amount of duplicate parsing. I was looking for more of a performance improvement than I got but at least things are more organized and logical than they were previously. These changes made performing some of the above mentioned fixes much easier.

 

I fixed a bug where potentially ambiguous column references were figured out and fixed automatically by looking at the parse info. This showed up in the KeyLinks property as well when a call to Locate() was performed.

 

I fixed a bug when making a call to Locate() that led to a string truncation error.

 

I fixed a few issues in the IB_Event alerter component that caused it to be unstable under certain circumstances. I also avoided a deadlock thread issue in IB2007.

 

I fixed some issues in the TIB_Session.FocusedXXXX properties. It was possible to get a stale pointer in some circumstances that led to an AV.

 

10/31/2014 Version 5.5.5 [Build 2152]

 

Support for RAD Studio XE7.

 

I removed references to the BDE from sample applications because the BDE is no longer supported with XE7.

 

I improved the handling of the OnEditError, OnPostError and OnUpdateError events.

 

I enhanced the GeneratorLinks property to allow you to add the increment value after a comma.

 

I enhanced the handling of boolean values to keep them strict but to allow for additional items for the unknown state to be added for some flexibility.

 

I enhanced the query engine to work with array element columns in the select list with greater accuracy when doing RequestLive updating. They are properly omitted from being included in the INSERT and UPDATE statements that are automatically generated.

 

I improved the handling of getting a record lock.

 

I added bsAlwaysKeepEdited and bsAlwaysKeepInserted flags to the TIB_BufferSynchroFlags type in order to keep records in the buffer when posted even though they may no longer meet the query criteria and would otherwise be removed from the buffer. I also added in row flags to distinguish when records have been retained instead of removed.

 

I fixed a numeric overflow error having to do with transaction timings.

 

Enhancements from Geoff Worboys:

  - Added LinksAreFBNames property to TIB_StraingList.

  - Added SchemaPropParamDomains information to TIB_SchemaCache.

  - Added CheckSessionsUnder() procedure and TIB_Session.GetSession method.

  - Enhanced parsing routines to include consideration of SQL comments.

  - Added trusted authentication capability to TIB_Connection.

  - Added ability to work with stored procedure parameters that are based on domains.

 

7/11/2014 Version 5.5.3 [Build 2095]

 

I fixed some issues having to do with the IB_Session being set to nil and then things still being done to try and set it back to the default session anyway. This seemed to cause some instability when doing the destruction phase of closing out an application.

 

I fixed an access violation that would happen when compiling from the DEBUG DCU files when you would call the Locate() method with a single column. This was a small glitch that was left behind while working out the issues I solved with regard to being able to have incremental searching work fluidly by way of fetch callback mechanisms.

 

I fixed a bug in TIB_Grid having to do with the coloring of rows and cached updates.

 

I added support for the new Firebird 3 BOOLEAN column type. I also added the TIBOBooleanField class for TIBODataset as well. This was necessary to have the same behavior as the server in terms of how the value is handled for the UNKNOWN value.

 

I enhanced the InvalidateRows method of TIBODataset to work better with the OnFilterRecord event and to properly notify the AfterScroll event if the current record ends up being changed. I also made the Refresh mechanism take the OnFilterRecord into consideration as well.

 

I enhanced the Filter parsing to better handle multiple NOT operators and to avoid reworking a date literal if the column it is being compared to is wrapped by some other operator that could potential change its data type. I also made it parse mathematical operations accurately in some cases where it used to give an unsupported filter error.

 

I fixed a problem having to do with persistent TField definitions in the TIBOQuery and TIBOTable components being lost at design-time under certain circumstances. There was also an access violation when trying to Open these at design-time that resulted in the lost field object definitions.

 

5/8/2014 Version 5.5.3 [Build 2067]

 

I fixed a bug having to do with TIBOBCDField. It was getting a BCD Overflow error when the column value was NULL.

 

I fixed a problem in the IB_Samples.pas unit that was causing programs to sometimes have an AV when the app was shutting down. This only affected the sample applications.

 

4/24/2014 Version 5.5.3 [Build 2058]

 

I added support for XE6.

 

I fixed some issues with the BCD field support in the TIBODataset class.

 

I fixed an issue having to do with the NOTREQUIRED column attribute flag.

 

I enhanced the IndexFieldNames property to allow for the use of the UPPER() operator. Previously it would fail when attempting a Locate() on the column affected.

 

I enhanced the full text search engine so that it could customize the metaphone algorithm used.

 

I improved the logic for handling unassigned transaction components.

 

I implemented a change requested by Sita Software to improve the schema cache transaction behavior.

 

I fixed a race condition that could happen when using fetch callbacks and a number of master-detail relationships nested.

 

I added some BCD capabilties into Delphi 5 so that the code was uniform across all versions.

 

I added a fix for Lazarus/FPC to keep up with some improvements in the edit controls.

 

 

2/7/2014 Version 5.5.3 [Build 1996] (rev 2015)

 

I fixed a parsing error having to do with using the FIRST and/or SKIP clause in a SELECT statement where you had some spaces or other comments prior to the SELECT token.

 

I fixed a problem with handling of binary blob data in Delphi 5 and 6. The TIBOBlobField.SetVarValue() method was not working properly.

 

I adjusted the handling of the NULL indicator flag so that it always coerces to allow for a NULL. This was to eliminate situations where an ambiguous value could be sent to the server. It would be better to actually send a NULL to the server even if the column is declared as NOT NULL than a potentially ambiguous data value. I also added some SQL trace monitoring feedback to monitor this. This was also affecting the Locate() method. In some cases it would return false when a match did actually exist. It returned false because of the potential ambiguity factor.

 

I touched up some of the IB_MonitorDialog routines so that it would show the client DLL info better.

 

I made some additional fixes to the IB_Events component. There was a list index out of bounds error that slipped past my regression test framework that I fixed. I also had a subtle thread synchronization issue that needed to be solidified in order to achieve complete accuracy in maintaining an on-going cumulative count of event notifications. Events are now rock solid.

 

I added the OnEventAlertEx event to TIB_Events to allow you to have all of the events together from a notification packet. This should simplify the logic required if you need to compare event counts of particilar events and then perform actions based on count differences, etc.

 

I had some duplicate GUID values in some of my packages that needed to be resolved.

 

I had to adjust the way the TIB_ErrorExEvent event was structures so that it would work with C++ Builder. It does not allow for you to have a static array as a parameter. I changed it to a pointer to a static array and that resolved it. Due to this, you will need to change your source code to match.

 

I fixed a problem in the BCDToInt64Scaled() routine. It wasn't using the proper runtime routine in order to safeguard complete 64bit range capability.

 

I fixed a regional settings issue in the TIB_Currency control when using field masks.

 

I fixed a TBCDField issue in Lazarus where it wasn't setting the value property in the buffers.

 

I added support for TField.DefaultExpression into the TDataset compatible components.

 

I enhanced the behavior of the NOTREQUIRED column attribute setting to actually go ahead and coerce the affected columns so that the server will treat the column as nullable. Of course if you send it a NULL then you will get an exception. This is because in that case what was being sent to the server was a potentially ambiguous value. Therefore, your applications could start raising an exception when they didn't before. The goal here is to force the elimination of all potential ambiguity.

 

12/30/2013 Version 5.3.3 [Build 1955]

 

I revised the widestring and unicodestring encoding and decoding routines to make use of the WinAPI directly for all code page/charset types. Emulation was provided for LINUX via FPC.

 

I enhanced the TIB_Script component to have the SET BATCH_DECIMAL_SEPARATOR item.

 

I improved the parsing of input parameters to consider stored procedure and parameter names as well as table names and column names when deciphering when a parameter with the prefix of OLD_ is being used. It's best to use OLD. instead of OLD_ so that there isn't potential ambiguity in naming.

 

I added a compatibility unit IBOSDDataset.pas in the AddOn subfolder to ease the porting of an app written with SQL Direct to IB Objects.

 

I fixed a bug in the parsing of filter phrases so that it handles string literals like O'Brien that have a single apostrophe in them.

 

I significantly reworked the IB_Events.pas unit in an effort to avoid a bug in InterBase XE3. Unfortunately, the bug was also in the synchronous API call for handling events as well as the asynchronous API call. So, I abandoned the efforts to get isc_wait_for_event() working.

 

I fixed a bug in the handling of stringlist properties that affected the sort order and thus created a potential blind spot in the Find() mechanism. By removing this blind spot I was also able to improve the optimization of searching string lists.

 

I enhanced the statement processing logic so that it detects a DDL statement and causes the schema cache data to be invalidated so that all DDL statements are immediately recognized in how they impact the schema data. This may cause some extra overhead depending upon what you are trying to do but it should be negligable. For example, during the execution of a script where most DDL are performed, there isn't anything going on that will trigger repeated queries of the metadata.

 

I added the IB_BLR.pas unit to the tools package and enhanced the Blr sample app. It is now much easier to write your own customized blr programs to have executed directly on the server. I'm also leaning towards implementing the RETURNING capability for INSERT statements for InterBase since they haven't gotten around to doing that yet. This is possible with BLR handling.

 

I added the PostEvent() method to the TIB_Connection component to post an event without having to create a stored procedure or use an EXECUTE BLOCK statement. This is done via BLR.

 

I totally reworked the Service app sample application into a 100% functional application that shows you how to replicate a portion of a table into a separate database and how to put a full text search index against the replicated data. The service app also provides real-time maintenance of the replicator and full text search indexes. In the process of this I extensively reworked the service app framework so that you can easily create an app that plugs into a GUI form that emulates the service app controller to start, stop, pause or continue. This allows you to debug your service apps just as you would any standard GUI application. Then, when you are ready to deploy, the exact same app module plugs into an actual service application. See samples\ServiceApp for the two projects that show exactly how this is done. One is a GUI version and the other is an actual service app from the same service app module. They both make use of the generic TIB_ServiceApp instance you create for the service app.

 

I touched up a few things so that FireMonkey apps can compile in XE2. Using the TDataset based components it is possible to do everything in the FM framework without any VCL.

 

I enhanced the underlying framework for handling passive task processing to be named more intuitively and to have additional events at the TIB_Session level to tap into things happening at the connection and transaction level.

 

I made some touch-up improvements to the database file auto create capibility of the TIB_Connection component's Connect( AllowAutoCreate: boolean ) method.

 

I fixed a bug where a dataset could be put out of search mode by the TIB_Grid calling ValidateRows and causing the dataset to open when it wasn't being expected to.

 

I fixed a bug in the handling of a Locate() when there was a NULL value for a key value being compared.

 

I corrected an issue when using the 64-bit version of the client DLL's in 64-bit mode.

 

I made the TIB_LogFiles component more strict so that it will go ahead and raise an exception instead of quietly doing nothing when it is unable to create a valid output file.

 

I added a TIB_Thread class to the IB_Utils.pas unit.

 

I significantly enhanced and improved the replication and full text search components.

 

I fixed a bug in TIBOTable having to do with using persistent fields and having the index of the fields changed and having a reprepare take place. This caused a discrepancy that led to errors.

 

I fixed some issues and enhanced the behavior of the TIB_Monitor component.

 

I fixed a painting/coloring issue with the button bar controls.

 

10/15/2013 Version 5.3.1 [Build 1862]

 

I fixed some trimming issues with the widestring based columns in the TIBODataset class.

 

Extensive work has been done to make the sample apps work with Free Pascal/Lazarus.

 

10/11/2013 Version 5.3.1 [Build 1809]

 

I enhanced the handling of colors so that you will get one of two schemes as the default colors. I look at the window background color and determine if it is light or dark and then assign different default colors depending upon which it is. This only effects the colors used when TIB_Dataset.ColorScheme is set to true. If you are using a TIB_SessionProps component your colors will remain based upon whatever your settings are there.

 

I fixed some issues having to do with applying trimming and character case attributes to widestring based columns.

 

10/8/2013 Version 5.3.1 [Build 1767]

 

I enhanced the exception handling framework by including additional parameters in the methods that handle and show exceptions. I also added in and enhaced the global hooks into them.

 

I added an additional global hook to find a client library if after exhausting all efforts none is found.

 

I finished up the ability to set an install mode of Binary or Source when using the full source. This is documented in the HowToInstall file in the docs folder.

 

Fixed TIB_Dataset.CommitAction where caRefresh and caClose would sometimes not work.

 

Fixed TIBODataset problem with getting duplicate field error in the TField editor dialog.

 

TIB_Connection enhancements:

  Added ( AllowAutoCreate: boolean ) parameter to the Connect method.

  Added OnCustomCreateDatabase event to be called when the database is being auto-created.

  Added cetBeforeLoginPrompt and cetLoginPromptFailed connection event notifiers.

  Added a global thread-safe list of all TIB_Connection instances.

  Added behavior of auto assigning itself to the IB_Connection of component instances it owns.

 

TIB_Transaction enhancement:

  Added behavior of auto assigning itself to the IB_Transaction of component instances it owns.

 

Sample applications were significantly enhanced and reorganized.

 

9/23/2013 Version 5.3.0 [Build 1633]

 

I've decided to use the SVN revision number as the build number so that people using my primary development repository will know which revision to look to. This number may not correspond exactly with the actual released version as there may be some tweaks slipped in so a quick review of the notes on the revisions should always be done as I will notate last minute tweaks accordingly.

 

XE5 support and removal of VCL Framework requirement from core packages:

The most significant thing accomplished in this release is I have included support for XE5. I have been working hard to prepare the IBO codebase to compile on the MacOS, iOS and Android platforms but I am not quite ready with this part of XE5 support. Much more extensive changes than I have done are fourthcoming.

 

There is one significant change you will want to take notice of that may affect some applications. I extracted out everything tied to these units: Forms, Dialogs, Graphics, ExtCtrls and perhaps a few others. In short, anything that caused a requirement to associate my core packages with the VCL framework was refactored into a new unit IB_VCL and moved them into the ibo5vrt package. I also moved things like the LoginDialog, CancelQuery form and the ErrorDialog forms from ibo5art package to the ibo5vrt package. This enabled the TDataset package ibo5xrt to be free of the VCL framework requirement. As a result of this, there may be some applications that want the VCL to continue to be in their applications but they may not be using the ibo5vrt package.

 

If you only use the Core, Access or TDataset components for connectivity, you will need to include the unit IB_VCL in your project if you want to keep the visual aspects of a login dialog, error dialog, confirm delete record dialog and query fetching progress indicator popup form in your application.

 

NOTE: This also affects things that rely upon a TTimer in order to function, such as the TIB_Events component when left to its default settings.

 

I also noticed that I had neglected to provide installer support for the XE4 ability for C++Builder to compile in 64 bit. This has been remedied as well as I made sure it works with XE5.

 

Note: WebSnap has been dropped and is not a part of XE5.

 

Compiler directives cleanup and organization:

There has been a substantial amount of cleanup and reworking of compiler directives to be more feature specific instead of tied to versions of Delphi. This was necessary in order to coordinate with the ongoing development and progress of the Free Pascal Compiler and the Lazarus IDE.

 

Regression testing application:

The FixedTests unit was broken up into an additional unit IBODatasetTests so that they can be more organized to test specific areas. I included testing for 64 bit platform. I included new tests for statement handle cachint, script processing and all tests are now passing for both Delphi and FPC/Lazarus on both Windows and Linux.

 

IB_Events component:

The TIB_Events component was heavily rewritten in order to work correctly in the FPC/Lazarus development environment. I added a very aggressive regression testing item to make sure it has ongoing functionality. There are some improvements I would yet like to make, such as using thread synchronization. For now it is still dependent upon an internal TTimer or the session's ProcessPassiveTasks() system to have it actually trigger the OnEventAlert event to execute your code in that event.

 

TIB_ConComponent and TIB_TranComponent components:

I added in new intermediate class levels in order to consolidate code that is similar to many descendent components that have a reference to a TIB_Connection and/or a TIB_Transaction. This enabled me to clean up the way the object inspector handles the DatabaseName, IB_Connection and IB_Transaction references. This was necessary in order to have proper coordination with using a reference to the session's default connection as such or as an explicit reference to be mentioned next.

 

IB_Connection/DefaultConnection and IB_Transaction/DefaultTransaction properties:

The object inspector now indicates when the association is based on the default, which means that there won't be anything stored in the DFM. This is because if it is intended to just pickup the default, whatever it happens to be at runtime. You will likely notice a number of references in the DFM no longer being stored because they are not needed to maintain the desired connection/transaction references.

 

TIB_SessionProps:

I enhanced the TIB_SessionProps component so that more control can be taken over what session properties are active during design-time. It is possible to have a project group where multiple project's forms are open at the same time. This creates the situation where the global session is potentially influenced by multiple TIB_SessionProp instances. I have added a property to tell which TIB_SessionProps component was last asserted with the global session. And, if this property is set to true, that TIB_SessionProps instance will assert itself and be indicated as such. None of these settings will be stored in the DFM as they are just to give you a way to control various design-time aspects. For example, you may be using a different DefaultConnection in different session props components and you want to test a query through its proper connection. You must first assert its session props component and then when you open your query editor interface it will grab the right default connection. This ability exists because the TIB_SessionProps component stores its own copy of what all the TIB_Session instances properties should be.

 

IB_Session property referencing:

This property used to have as a part of its getter method a check to find a default session if there wasn't already an explicit reference stored. However, such functionality proved to be a bit problematic so I removed this feature. Thus, if you are making a reference to the IB_Session property in code you should first call the CheckSession() method. If you do not pass in a parameter value it defaults to raise an exception if it is nil. Otherwise, if you don't want an exception raised, you can pass in false but then you must check yourself if IB_Session is actually assigned or not.

 

TIB_Process component class:

I factor a bunch of code from the full text search and replication components in to this common base class component so that I could do some code cleanup and simplification. This brought in WakeUp mechanisms, more logging mechanisms, smarter NeedPassiveMaintenance logic, and it also encorporated the new TIB_ConComponent and TIB_TranComponent capabilities.

 

TIB_Script enhancements:

I added a property called IgnoreDropNotFound so that you can have a script that contains DROP statements that will not cause an exception to be raised if the object they are dropping does not exist. This is false by default so if you want this behavior you have to set it to true.

 

I added a new SET operator in the script language that allows you to SET INCLUDE '<filespec>'. This will load the file into the script engine and execute it in place and then continue on. I considered doing a more standard syntax for this but I decided to take the easy route and simply tap into the already existing parsing of other SET operations. Not elegant, but efficient and easy.

 

I added macro processing to the values of the SET operators. Therefore, the '<filespec>' in the above operator can have a macro placed in it to, for example, set a prefix directory to where the file of interest is located.

 

I fixed a potential memory leak due to an exception being raised and then in the exception handling code the same method was called and raised the same exception as before. Somehow this resulted in an exception object being orphaned and not freed properly.

 

Naming of input parameters:

I enhanced the way IBO processes input parameter names. If you wish to have the input parameter bound to the OLD value instead of the current value it was possible to add the prefix OLD_ to the name of the parameter. However, I store the actual parameter name in the confined storage space allocated for it. This means if you have a column name that is already using up all the storage space you are not able to use the OLD_ prefix. I have now devised a way to indicate the OLD_ prefix and have it flagged instead of becomming a part of the actual parameter name so that the full length of the identifier name can be utilized. This necessitated adding in the ParamNameOldRefStatus property so that it can keep track of this separate from the name buffer.

 

I also enhanced it to look at the metadata schema cache to figure out if it is a reference to an actual column with OLD_ as part of its actual name vs. having a parameter wishing to be bound to the OLD record buffer. This potential confusion can all be avoided if the prefix of "OLD." is used instead of "OLD_". You can now use this prefix in combination with parameter names that include the TABLE.COL format. Thus, you would have :OLD.MYTABLE.MYCOLUMN as the name of the input parameter. This is the best and recommended way of naming parameters in the EditSQL, InsertSQL and DeleteSQL properties.

 

Note: you should always use the full TABLE.COLUMN reference name when dealing with Blob and Array columns so that their particular characteristics can be detected in the metadata and utilized.

 

I added a new SchemaCache property called TableFields2. It provides a simple list of all column references in the database in TABLE.COLUMN format. This was needed in the logic to tell the difference between a reference to a column with a name starting with OLD_ vs. the use of the prefix OLD_ to indicate you were wanting the parameter to bind to the OLD value. Therefore, if you wish to avoid this extra bit of metadata being cached locally, always use the prefix OLD. instead and avoid naming columns in your database with OLD_ at the beginning of the name.

 

Global Error event processing:

I added a global hook to tap into the notification of non-zero ErrCode values when calls to the API are made. This will include exceptions that will be ignored as well as exceptions that will be raised. I needed this in the regression testing application in order to have all non-zero errcode situations logged for inspection and review.

 

Replication components:

I fixed up some issues with this set of components and added in a method in TIB_RPL_Meta so that an index can be added strictly in code instead of using the IB_RPL configuration tool.

 

Miscellaneous changes:

Cross platform items for LINUX/Windows were addressed surrounding the path delimiter and line ending special characters. They have been consolidated and applied across the IBO library codebase.

 

I revised all of the code surrounding API calls to no longer use the ErrCode and Status variables on the TIB_Session instance. Instead, they will always use locally defined variables and as necessary pass them on the callstack. This was necessary to keep some calls reacting to an errcode to not trample over the errcode that may yet be in the process of being raised as an exception. This also has the benefit of making IBO more resistant to problems if there is a stray thread. And, more importantly, so that if there is a stray thread there will at least remain to be sensible exception reporting.

 

I changed the TIB_SessionBase method named NeedTimerNotification to be named NeedPassiveMaintenance in order to be more intuitive as to what it does as well as to eliminate the notion that it must be associated with a TTimer.

 

I made some general improvements to how statement handle caching works. If you call the Unprepare method explicitly then the statement handle will not be cached and it will be immediately deallocated so that the statement being explicitly unprepared is freed totally.

 

I found several places in code where identifiers were being compared without using the special routine for comparing identifiers. This made it so that in some cases identifiers with double quotes were not being matched consistently. This special routine normalizes the names prior to doing a comparison and it also factors case sensitivity properly.

 

Some additional information has been added to the ClientTrace capabilities of TIB_Monitor.

 

I fixed a bug having to do with the IB_TransForUpdate property. There was a special case where when using a COMPUTED column or a column based on a JOIN and an edit was being performed the record would get refreshed with a value from the IB_Transaction instead of the IB_TransForUpdates. Thus, this made it look as if the change didn't take when in fact it did.

 

Standardized references to pointers as unsigned integers.

 

The TIB_Statement.RowsAffected will now provide the cumulative sum of UpdateCount and InsertCount when dealing with a statement of type UPDATE or INSERT. This should return the same as always in normal conditions but there are special instances where a more comprehensive result is desirable.

 

I fixed a number of issues to have better support of Firebird 1.5. Mainly in handling CharLen and detection of global temporary tables in DDL extract.

 

I fixed a bug with the Locate() method when using NULL as a value to search for.

 

I fixed a bug where SELECT statements with a FIRST and/or SKIP clause with some other complicating factors would cause a parsing error to occur if you were doing a Refresh or Locate() where an internal cursor to validate a bookmark was performed.

 

I fixed a bug where when doing a SQL_Lock for pessimistic locking and the Firebird bug 3343 was encountered it wasn't handling things as gracefully as I woudl like. Now there is no apparent exception as it detects the problem and automatically reworks the statement without the RETURNING clause.

 

TIB_LogFiles now uses UTF8 format with its output to files.

 

Fixed getNextToken() parsing routine to handle single and double quote delimiters more precisely.

 

I enhanced the VarSameValueEx() routine to tolerate an AnsiString vs an array of bytes.

 

I fixed the Int64ToBCDScaled() routine to handle numbers in the format of -0.0xxxx properly.

 

I fixed some issues with FieldType and DataType compatibility issues in TDataset support.

 

 

8/27/2013 Version 5.2.0 [Build 8]

 

I fixed a problem in Delphi 6 where it wasn't processing the ApplyUpdates() method properly. It wasn't dealing with the array of datasets passed in due to some kind of a compiler glitch.

 

I fixed an access violation in the TIB_CustomActionTransaction classes.

 

I added a property to TIB_Session in order to alter the OnError and OnErrorEx behavior slightly. There are some cases where I don't want an exception raised even if there is one. I call these soft errors. If you set the IgnoreSoftErrors to false then the OnError and OnErrorEx events will start to receive notification of them. In this case, the RaiseException variable is pre-initialized to false instead of true. What this means is if you have the OnError and/or OnErrorEx events assigned you will need to be sensitive to the fact that its RaiseException value could be initiated as true or false and that it is significant.

 

I fixed various issues with regard to the replication tools. I added the AddReplicatorIndex() method to the TIB_RPL_Meta component to programatically add in a replication index so that it isn't necessary to use the IB_RPL tool in order to configure your replication items. I reworked TIB_RPL_Meta it to be more efficient in its internal allocations and to do a certain amount of work to avoid the Object In Use errors when dropping metadata. It is advisable to have a dedicated connection when working with a TIB_RPL_Meta component because it will close datasets and transactions across the whole connection if it encounters such an exception in order to retry.

 

I added a new method to TIB_Connection called SwapOutHandle. It will close all datasets, deallocate all statements and close all transactions and then it will detach and attach to the database without causing all of the associated event notifications that would normally happen with a Disconnect and Connect call. The goal is to just quietly as possible flush out an old connection handle and bring in a fresh new one. I use this in the feature above to help the replication tools deal with object in use errors when dropping metadata.

 

I made some enhancements to the TIBF_Status dialog form. It now interrogates all sessions and I added an option to have it only show components which have allocated resources in some way.

 

I added in some additional information for SQL tracing for the IB_Components, IB_Events and IB_Schema units.

 

I added a new public property FilterInSQL that mirrors the Filter property. It is there simply to make things more explicit so that code reads more intuitively.

 

I added in the capability of a TIB_Component to push down a change to its IB_Session property so that all components in its ownership downline will be kept in the same IB_Session context.

 

I reworked the recently added ability to use the new flag fopInMemory in the TIB_BDataset FilterOptions property. I removed that flag and reimplemented this capability to write a filter that is processed in the dataset buffers into a separate property altogether. Now there is the FilterInMem property where you can put a filter clause that will exclusively be processed in memory. This allows you to continue to put filter criteria in the Filter property that will be resolved into the SQL statement to be filtered on the server. Doing it this way was simpler to implement internally and it gives greater flexibility to the developer to have both kinds of filters simultaneously.

 

I enhanced the IB_GetDateTimeLiteral() routine to have millisecond precision.

 

I fixed a bug in TIB_StringList.LinkParamValue[] property. It wasn't possible to implicitly add in a new entry in the process of setting a value. If there wasn't already a link entry to modify you would get an index out of range error. Now it will just go ahead and make an entry for you with the settings specified.

 

I added code to protect against an undefined IB_Session reference as well as tightened up the handling of errors in the session so that a generated errcode won't get lost if additional processing is performed in the process of handling that errcode.

 

I reworked the handling of TIBODataset.Prepare so that the default fields will be generated at that time instead of in conjunction with opening up the dataset. There are still some limitation as to what can be done with those field objects because they are not yet bound. There is some alterations made during that process that won't take place until the dataset is opened. This can affect lookup fields and calculated fields.

 

I added in field compatibility between ftBCD and ftCurrency field types in TIBODataset.

 

I added in a feature to look at the primary key (KeyLinks) columns when doing an insert to see if they are assigned a value or not. If they aren't then IBO will assume their value(s) will be set in trigger code. Thus, if the server supports the RETURNING clause, one will be added to the INSERT statement so that those values supplied in the trigger will be returned and applied upon posting. It is still needful to supporess the Required property if you want to take advantage of this. Normally you would set the bsAfterInsert flag in the BufferSynchroFlags property to make it return the values but this will work even if that flag hasn't been set.

 

I fixed things so that TIBOTable will properly use the horizontal dataset refinement capabilities if the conditions are suitable. The main thing is having a descending index on the primary key of that table being used. With that in place you will get the ability to virutalize where the record pointer is anywhere within a large dataset without needed to fetch in all of the records. For example, a call to Locate() will immediately jump to the desired record and if you scroll in either direction then new records will be fetched in. Also, a call to Last will immediately jump to the end and fetch in more records if you call Prior. This makes IBO very efficient with extremely large datasets. If you do not want the behavior introduced (that was supposed to be there all along) then you can set the property AllowHorizontalRefinement to false or the AutoFetchAll property to true and this behavior will be suppressed. This is also suppressed if you have the table in the detail position of a master-detail relationship.

 

I also fixed a few general issues having to do with horizontal dataset refinement where a certain sequence of calls would result in the dataset becomming closed instead of properly locating a record when a call to Locate() was made. There was also some problems when changing the FetchWholeRows property that caused some inefficiency in a Locate() operation that has been cured up.

 

I fixed a bug when calling TIBODataset.FindKey() with multiple columns in the key. It gave a field not found error because it was not parsing them out individually properly.

 

I fixed a problem where parameter values set in the TIBODataset.AfterPrepare event were lost and were not applied when the dataset was opened.

 

I fixed a bug when generating the SQL to insert a record into a table that only had a single column.

 

I fixed a bug introduced in build 7 that had a call to Commit leaving datasets with a CommitAction of caInvalidateCursor in a truncated state if they hadn't already fetched all of their pending records. This was promptly addressed with a patch in build 7a because this was a rather serious flaw. There is now a regression test that will prevent this from happening again.

 

I fixed a race condition that happened under certain circumstances when a TIBODataset is set to Unidirectional = true and the dataset had its IsEmpty method called.

 

I added in a check to prevent someone from setting both CachedUpdates and PessimisticLocking to true. They both cannot work properly at the same time so this condition should be prevented.

 

I fixed the timing and sequence of how and when TIBODataset error events are fired when doing inserts, edits and deletes. The UpdateError event was being fired even when there weren't cached updates being processed so that was suppressed. Also, if an Abort exception is raised it will make it so that no further error events will be triggered. This was also secured with a regression test.

 

I touched up the tutorials and got them to work better with IBO 5.x as well as fixed things so that they can be compiled with the evaluation version of IBO.

 

7/3/2013 Version 5.2.0 [Build 7]

 

I added the ability to use the new flag fopInMemory in the TIB_BDataset.FilterOptions property. What this does is make it so that your Filter clause will be performed in memory instead of parsing it into the SQL statement on the server. This works well for a situation where you have a dataset that fetches in all possible records and you want to apply different filters against it without having to refresh the dataset on the server. This resulted in a drastic performance improvement for some situations where filters were being applied and reapplied and it all was carried out in local memory. There were a few limitations that only apply to Delphi 5. Also, a few features that the server supports are not supported yet. These are the SIMILAR TO clause and the IN() operator. The BETWEEN and LIKE operators are supported along with parenthesis, AND, OR and all of the =, <, >, etc. operators. You should keep your filter composed of FIELDNAME <operator> LITERAL entries. If you put the name of a field instead of a literal it will just treat the fieldname as a literal.

 

I added the ability to implement a customized encoding/decoding mechanism into your application easily. I added the TIB_Connection.ColumnCoding property that works in conjunction with the OnColumnCoding event. This new feature enables you to use a simple encryption (obfuscation) of your data. I added the IB_Parse.Str2Str() routine to do a simple data mangling that can be used with this new feature.

 

I fixed a problem with the TIBODataset and its coordination with a TIBOUpdateSQL object. In some cases it was not properly executing the OnUpdate events associated with it.

 

I added support to more accurately deal with NaN and INF (infinity) values in floating point precision.

 

I improved the handling of server cursors so that they are directly tied to the transaction that started them. This is an additional level of consideration that needs to be taken when using the IB_TransForUpdate feature. In some cases a cursor was getting left open when it shouldn't be. There was also an issue with refreshing a dataset that needed to be improved so that it kept track of which transaction context it should be using. If the IB_TransForUpdate has uncommitted changes then it should use it when selecting records from the server.

 

I fixed a recent change that made it so that IBO did not compile in Lazarus.

 

I added the ability to set the CacheBuffers in IB_SQL tool. I also improved IBO's ability to handle this figure such that it will allow a setting over 255 now. Be advised that this setting may be prevented from being effective by other factors.

 

I added the transaction handle information to the IBF_Status information form.

 

I fixed a bug in the IB_Parse.LikeCompare() routine. It was not handling some cases where a somewhat complex use of wildcards was happening.

 

I added support for the SQL ROLE NAME in the TIBOSecurityService.DisplayUser() method.

 

If you use a parameter name that includes a relation name with the column name I am now including the column name in both the sqlname and in the alias name XSQLVAR data structure. This was necessary for deciphering which parameters should be subject to the new ColumnCoding feature so that input parameters would also have the encoding and decoding mechanisms applied.

 

5/22/2013 Version 5.2.0 [Build 6]

 

I added support for Delphi/C++Builder XE4.

 

I have also resolved all known issues with the Lazarus port (for non-visual components).

 

I made several improvements and additions to the regression testing application:

    procedure Test_CursorGenInsEditDel;

    procedure Test_IBOQueryNumericFields;

    procedure Test_LocateWithSubselect;

    procedure Test_LocateEdgeFluke; (issue not fixed yet)

    procedure Test_MasterSourceRecordCountSync;

    procedure Test_IBOTable_LocateOnLookupField;

    procedure Test_AppendRecordCursorPosition;

    procedure Test_TransactionEfficiency;

 

I made some very substantial improvements and performance optimizations to the TIB_StringList class.

 

I reworked the handling of DefaultTransaction behavior to be more consistent and to more fully respect the AllowDefaultTransaction setting.

 

I fixed a few issues in the IBOExtract component so that it works with InterBase and Firebird properly and each of their special features.

 

I fixed an issue of handling Unicode characters properly in the IBOServices component.

 

I added a new property SQLCustomKeySelect to increase the level of flexibility you can get with the SQL being sent to the server. IBO would normally take your query and derive a SELECT statement to fetch just a single record for you. But, in some cases it is not possible to derive such a query so I am allowing the programmer to plug in one that should be suitable. This will allow you to use, for example, stored procedures to provide a fully scrollable dataset that individual records can be efficiently fetched from that dataset.

 

I added a global function variable to allow you to cusomize how a default session instance is made.

 

I fixed a bug where in some cases the Delphi variable Screen was nil and I was not safeguarding against that.

 

I improved identifier name comparison to handle more complex situations properly.

 

I made it so that a number larger than 255 can be used in the IBO_BUFFERS setting when making a database connection.

 

I fixed an issue having to do with a Status: TIB_TransactionStatus property being incorrect under certain circumstances.

 

I fixed a counter rollover issue in an area where I am relying upon GetTickCount.

 

I improved the detection of an aggregate query. I now investigate inside of a CAST() operator.

 

I changed the behavior of how a TIB_Cursor.Insert is posted. Before it would clear out the buffer since the record was considered posted. However, because there is the capability of values being returned via the posting process I determined that these values should remain in the buffer, including any new values that came back from the post.

 

I made it so that a physical transaction is not started when an individual record is being pulled out of the in-memory buffers. It was an inefficient oversight on my part that this was even happening at all.

 

I improved the handling of floating point values inside the Assign() method.

 

I made it so that you can do a Locate() operation against a TLookupField in the TDataset realm.

 

I improved TIBODataset to handle when a MasterSource.Dataset is assigned or not in relation to how the SQL that is sent to the server is concerned. If a master dataset reference is cleared or newly assigned then the query should have its SQL invalidated so that it will refresh the query properly.

 

 

5/1/2013 Version 5.2.0 [Build 5]

 

Due to customer requests, I have reinstated official support for Delphi 5 and C++Builder 5.

 

3/28/2013 Version 5.2.0 [Build 4]

 

I am dropping official support for Delphi 5 and C++Builder 5.

 

This is a significant change in behavior:
I made it so that when an Insert is posted in a TIB_Cursor that it will allow the values to be retained in the buffer. Previously I was clearing them out. This is because it is possible for values to be returned back to the row inserted and if the row is cleared out then those values will be lost.

 

I enhanced the algorithm used in the TIB_Column.ByName() method to lookup a field so that it is a bit more versatile in the handing of double quoted all uppercase reserved tokens. I also enhanced the way that INSERT and UPDATE statements are generated such that they use what is in the SELECT statement so that it will keep consistent with what is prepared. This has the benefit of using double quoted reserved tokens that you put in your SELECT statement properly. Otherwise, you would have to turn on the ability to check for reserved tokens everytime a field name is referenced and that imposes a performance hit.

 

I fixed the RemoveDatabase method of TIB_Connection so that in the case of a local database and there is an attachment error due to an unsupported ODS version it will still go ahead and just use the file system to delete the file if it can.

 

I fixed a problem in the TIB_StringList class having to do with sorting lists based upon the item name and the handling of duplicate entries.

 

I fixed the handling of unicode characters in the IBOServices unit.

 

I included new sample applications for XLSQL Reporting components.

 

The TIB_JPEGImage and TIB_DateTimePicker controls have been enabled for Free Pascal Compiler. There is a 3rd party dependancy for the date time picker that will need to be installed into Lazarus. It is the TZVDateTimePicker control.

 

I fixed an issue of the RETURNING clause showing up when it shouldn't when using Firebird 1.5 and the PessimisticLocking property. I also had to fix an issue with TIBOExtract in how it handles the GLOBAL TEMPORARY tables for Firebird 1.5.

 

I fixed a bug in the SQLIsAggregate method where if an aggregate condition was inside of a CAST() operation that it was not detected. I enhanced my parser to peel off a CAST() and to look and see what is inside of it so that this property will behave more reliably.

 

I fixed an issue so that when I am performing the KeyLinksAutoDefine operation it will handle identifiers correctly in terms of case sensitivity and whether it is double quoted or not.

 

I merged in a customer's fix for handling of TIB_ColumnFloat and TIB_ColumnDouble when the value of NAN was involved in an Assign() method call.

 

I fixed an issue with the TIBOBaseTable component and how it deals with persistent fields.

 

I put in a check to make sure when EnableControls is called that DisableControls was called previously. If it wasn't called previously it will now raise an exception.

 

I added a new property SQLCustomKeySelect that allows you to take control over the SQL statement that retrieves a single record from the server based upon the Bookmark value from the KeyLinks. This is similar to how you put in your own custom EditSQL or InsertSQL or DeleteSQL statement only this one is to fetch a single record instead of to insert, edit or delete a single record. Please see the comments in the source code in the interface where the property is defined to get the details on how to use it.

 

I added the SQLCustomKeySelect property to the TIBODataset component class.

 

I fixed a bug with the AppendRecord() method in the TIBODataset component class. It was not properly initializing the values of a newly inserted or appended record to NULL.

 

I am in the process of making the parsing routine for the full text searching engine to be more flexible so that better internationalization and normalization rules can be customized.

 

1/25/2013 Version 5.2.0 [Build 3]

 

I added remote debugging file output to the packages for Delphi 2009+.

 

I updated the units for integrating with InfoPower and added a package group file for it in the addon folder. I moved the units IPIBODataset.pas into the main source folder as well.

 

I did some work on the regression testing application and added three new tests.

 

I created a new installation system using batch files. Please see the HowToInstall.rtf file for more information on this.

 

I modified all usage of {$INCLUDE <file>} to use direct path notation to avoid having to configure external paths to find them when compiling.

 

I added TIB_Column.AsBCD in order to support use of precision greater than 4 decimal places.

 

I enhanced TIBODataset to use the TFMTBCDField for columns with precision greater than 4 decimal places.

 

I fixed a bug in the handling of the TIB_Column.RelAliasName property. With a complex query using multiple JOINs it was possible to get an incorrect value to this property.

 

I moved the GetGlobalRegistry mechanism out of IB_Components to IB_Utils.pas so that I could eliminate the dependency of IB_Components from IB_Utils. This allows for smaller executable sizes for any utility applications that may be written that don't need any database involvement. I needed this to create a console utility app for the installer routines I recently wrote. I also removed some code that dealt with graphics dependent routines to the units they were called from to eliminate those dependencies out of IB_Utils.pas.

 

I enhanced the parsing routine ExtractListItems() that extracts lists out of delimited strings. I needed the ability to pass in custom delimiters and to deal with quotes as delimiters.

 

I fixed the TIBODataset.InternalAddRecord problem that was only in XE3.

 

I fixed a memory leak that only showed up when calling FetchSingle with a buffered dataset and the KeyLinks data was blank. This also showed up when calling Open with a TIBOQuery and your statement was an execute procedure with output. That's because it resolved this operation via the internal dataset's FetchSingle method.

 

I enhanced TIB_Query to allow you to call Open with an execute procedure statement. It will just perform a FetchSingle operation and fix the buffer with a single row containing the results.

 

I enhanced TIBOTable when persistent TField objects are used to only include the data columns in the SELECT statement that is underlying it. If you need to add all fields in the fields editor and you already have some fields declared, you might need to first remove the ones that are there and then add in the additional fields you were looking for.

 

I included a fix provided by Dany Marmur that surfaced when he ported an app to a Windows Service application. In some cases a local variable was not being properly initialized.

 

I enhanced the parsing of the Filter clause to deal with the use of the NOT operator better.

 

I fixed a sorting issue in the TIB_StringList class.

 

I added the NoAutoUndo property to TIB_Transaction.

 

I enhanced the Locate() method to properly take the trimming rules into consideration.

 

I fixed the use of the NOCASE ColumnAttribute setting in search criteria so that when a NOCASE equivalent is left blank, which means to use the UPPER() version of it, that it would get the proper FullFieldName value with the RelAliasName instead of the RelName. The NoCaseFieldName was being derived when the TIB_Column instance was created but the true RelAliasName is not yet available and so just the RelName was used. I plug in a little macro so that the retrieval of the RelAliasName is delayed to when it has become available.

 

I fixed up some aspects of the Contact sample application.

 

I added a new property SQLCustomKeySelect to take more control over how IBO fetches an individual row that is associated with a bookmark based upon the KeyLinks property. There are some cases where IBO is unable to automatically derive a working SELECT statement that retreives just a single row based on the KeyLinks. This property allows you to plug in a statement that will work so that very complext queries can have all the same capabilities as simpler ones.

 

12/27/2012 Version 5.2.0 [Build 2]

 

I added a SearchPath setting in the package source file options for XE+ so that you can use the build groups to build all packages for all platforms and configurations.

 

12/4/2012 Version 5.2.0 [Build 1]

 

New Installation Requirements:

It is VERY important that you completely uninstall IBO prior to applying this update. I have changed the output directory of the package files such that the old package files will remain and cause conflicts. Please see the docs\HowToInstall.rtf file in order to be taken step by step through installing this new release.

 

The package source files have all been brought to conform to the same naming convention and all of their settings have been made uniform throughout. They all store their compiled files within the sub-folder structure according to a consistent sub-folder structure according to Delphi version, platform and configuration.

 

New components:

XL SQL Reports has been included in this release. It is still needing some finishing touches. There will be more complete documentation on this new addition in a future sub-release. In short, this allows you to dump out Excel spreadsheets using a marked up specialized SQL to produce the file.

 

Core Improvements and Fixes:

I added in support for the new InterBase blr token blr_boolean_dtype = 17 in order to handle array columns of type BOOLEAN.

 

I enhanced the way memory is allocated for the storage of blobs being written to. I now allocate blocks of memory based upon the segment size defined for the column. Previously I would make a reallocation of memory everytime the buffer size needed to increase. This would cause a lot of overhead if making multiple calls to Write() or WriteBuffer() with small increments. This change will result in increased memory usage but will reap the benefit of drastically improved performance for certain operations that make incremental writes to a blob.

 

I fixed an issue having to do with retreiving the SegLen and the DefaultSource values for a TIB_Column instance. They were using the FullFieldName instead of the RelName + '.' + SQLName to reference their associated values in the schema cache. FullFieldName includes the relation's alias that is specific to your query and the SchemaCache information knows nothing about your query. As a result, the properties were not retrieving these values from the schema cache properly.

 

I enhanced the way UPDATE statements are generated so that it will use the actual text from your SELECT statement. By so doing I can check for the case where an array element is put in the select list and omit it from the list of columns to be updated since such a statement is not allowed. This is because when the UPDATE statement is being automatically generated it goes off of columns that have a SQLName given for them from the server. Because the server includes the SQLName of the array column element as if it was the entire array column being represented, I must somehow distinguish that and prevent it from being included in the UPDATE statement.

 

I fixed an issue with the KeyLinksAutoDefine functionality. I started pulling in the UNIQUE keys in addition to looking at the PRIMARY KEY. However, I didn't configure the stringlist holding them to allow for duplicate entries. Therefore, there was a case where one or more of the keys were not being considered as a candidate. I also improved the logic for making sure the columns it assigns for the key links are actually in the query being used and I put priority on the primary key over the other unique key columns. Actually, it puts priority on whichever is the first in the table's list of columns, which is typically the primary key. The intention is to always use the PK when possible. I only want to use cached schema data and I didn't have a way to pin down the primary keys without querying metadata on the spot. I want to avoid server overhead for better performance.

 

I added CloseDatasets methods to the TIB_Connection and TIB_Transaction components.

 

I made it so that comments in your SQL and DDL are kept in the statements when sent to the server.

 

I included support for the GLOBAL TEMPORARY tables in the DDL export component TIB_MetaData and in the Source tab of the IB_SQL tool by fixing the GetCreateTableSQL() method.

 

In some cases it was possible to get stuck in an infinite loop when calling the IsEmpty() method and when working with datasets while the query is merely prepared and there were just records in the buffer from inserts. This problem of infinite looping is now fixed in both cases.

 

I fixed a problem when working with cached updates and when there are records inserted in both the master and the detail datasets. Under some circumstances the detail cursor position would jump to Eof unexpectedly. I fixed it so that now the cursor stays where it belongs in that case.

 

There was an inconsistency between InterBase and Firebird in the handling of when a cursor is created on the server when performing singleton select operations. I had to put in code to check against errors due to having cursors open or closed when they should or shouldn't be.

 

I fixed some problems in the handling of BOOLEAN based columns and getting and setting variants.

 

General Improvements and Fixes:

I added a TIBOWideStringField descendent class to TWideStringField because the way it implemented its GetAsVariant behavior it would not properly return a null if the column value was null. It just returned a blank string instead. My subclassed version gives the proper and consistent behavior of dealing with NULL values properly.

 

I added a TIBOBlobField descendent class so that when the variant value is requested it will return a variant array of byte instead of a string of ansi characters. This is a more appropriate way to deal with binary data than a string.

 

I made the StoredProcName property in the TIBOStoredProc component more friendly where SQLDialect 3 names go.

 

I added a RemoveDatabase method to the TIB_Connection component. This will do what it takes to remove the database physically if necessary and it does not raise an exception unless the database is present and it cannot be removed. If it is not there to start with then no exception is raised.

 

I improved the handling of BLOB values in the TIBODataset components. There were some zero length blobs being generated when there should have just been a NULL put in the column.

 

I added the AsTrimString readonly property to TIB_Column so that a trimmed version of the AsString value can be had.

 

I adjusted the SQLDialect default value to use the SQL_DIALECT_CURRENT constant instead of hard coding it to SQL_DIALECT_V6. I also simplified things so that statements will get the SQLDialect value more accurately and efficiently.

 

I fixed a bug in the TIB_Import component. Under certain conditions there was a single byte from the input file that would get ignored. It had to do with the block boundaries it uses when pulling in chunks of data from the input file. I also improved its ability to deal with UNIX vs. WIN line termination.

 

I reworked the way AUTODDL ON|OFF works in the TIB_Script component. I used to just turn the transaction's ServerAutoCommit feature on and off and let the server itself perform the auto commit. But, there was a bug in the Firebird engine that would enable database files to become corrupted. So, in order to avoid that bug, I am just calling a commit retaining after each statement where there is an active transaction handle.

 

There was an assembler chunk of code in the IBO Admin components that needed to be converted to pure PASCAL in order to compile on 64 bit.

 

I touched up the logic that governs the use of the RETURNING clause on INSERT statements that are automatically created when an insert is posted. It was suppressing it in a case where there is still benefit from having it. It's always a good idea to have a RETURNING clause, especially if you are assigning key values inside of triggers. I added this case to regression testing.

 

I fixed a problem related to using an UPDATE statement with a RETURNING clause via TIBOQuery as a dataset by calling Open. If there was an exception when executing the statement it quietly returned an empty dataset instead of raising an exception. Now it will raise the exception as it should.

 

I put a few minor enhancments in the IB_Monitor component. It now gives a more meaningful description of XSQLVAR.SQLType information and it includes the Rows Affected information when doing a singleton select of some kind, which could be an UPDATE statement with a RETURNING clause. I also added in the ability to determine the MonitorGroups and the StatementGroups in the IB_MonitorDialog component. It also shows the SQLDialect used in API calls. I also fixed a minor bug in the display of error messages when being interpreted from the messages file.

 

I added an OnErrorEx event so that you could also get the status_vector array of error codes returned from the server. The OnError event will remain such that backwards compatibility will be maintained. It will be deprecated in a future release.

 

I enhanced the behavior of combining input parameters so that it would combine parameters where they are both of type text (non-blob) and they have different character sets. Previously I prevented them from being combined. Now, in the case where one of them is character set NONE I am allow it to be coerced to be the same character set as the other parameter.

 

There have been some additional contributions to the Lazarus support. Progress is being made on the visual controls. The XSpin.pas unit and XSpin.res resource file got moved into the visual\delphi subdirectory. This is so that an alternative spin control can be defined in lazarus. I was also able to get the regression testing app working in Lazarus and fixed a number of issues. I also went through the package source files and worked them over a bit so that they match the naming convention of the Delphi package files better. There were some areas where the performance was quite lacking. We were attempting to have IBO be fully UTF8 compliant but there just isn't enough support for this string type with good performance. Iterating through a string is very expensive because it cannot just directly address a character in the buffer based on a pointer offset. It has to scan the entire string and do analysis of where surrogates are in order to do a proper character position based referencing. So, Lazarus will stay at the same level as Delphi prior to Delphi 2009. While it does work to some extent with UTF8 string values, by no means should it be considered fully capable of working with UTF8 metadata as well.

 

I included project files so that the IB_SQL, IB_RPL and IB_FTS admin tools can be compiled in the earlier versions of Delphi. These are found in the apps folder under the d567 and d200567 folders. I combined them since the formats between each of these 3 versions of Delphi were compatible.

 

I needed to tighten up my use of buffers in some of the queries in the IB_Schema.pas unit. Some queries I had to write using raw API routines and manually allocated buffers. These are the items that are required while handling other schema cache related queries. If I didn't write these few queries using the raw level there would be an infinite loop. These areas showed up as a result of improving the SQL trace monitor to show the base address of the record and then the offset for each field in the record. I picked up on some anomolies and discovered that some values had garbage information attached to them. This was only an issue in Lazarus because Delphi would allocate its local variables wiped clean wheras Lazarus does not wipe clean memory it allocates for local variables.

 

I added the StartedTicks property to the TIB_Process component. This allows you to know exactly when the process began executing. I used the ability to profile performance problems in Lazarus and was eventually able to solve them by way of it.

 

 

Full Text Searching Improvements and Fixes:

I added a Dataset property to the TIB_FTS_Search component so that it will properly bind everything for you automatically instead of making you do method calls to it in order to have everything work. You can still use it the old way as well.

 

It is possible to use negative phrases by putting a minus sign directly in front of the phrase. This makes the phrase work just like a negative word works.

 

It is now possible with Firebird 2.x+ to put a wildcard character inside of phrases at the end of words so that words inside the phrase can be partially matched. The phrase matching can now also be punctuation tolerant as well. You will need to manually add the CONTAINS_PHRASE stored procedure for these enhanced features to be recognized in existing full text search databases. Some additional effort with a UDF would allow this to work in InterBase. Contact me privately if this need exists and I will help you make the necessary adjustments.

 

Any new full text search indexes created in a Firebird 2.x+ database with the fts base freshly loaded will have the CONTAINS_PHRASE stored procedure added automatically. The SQL for creating this stored procedure is in the source\fts\IB_FTS_Scripts.dfm in the scLoadContains TIB_Script component. If this procedure isn't added to your database then it will just use the built-in CONTAINING operator, which is not punctuation tolerant and does not allow for processing wildcards in search phrases. Getting this to work in InterBase is simply taking the stored procedure and modifying it to work in InterBase.

 

I fixed a minor glitch in the IB_FTS admin tool. It was adding a period to the end of table.key list entries when it shouldn't be. This caused the actual value to not appear because it didn't match a value in the list.

 

I fixed an access violation that would happen under certain conditions when populating data in a newly created full text search index. It was relying upon the database/connection having a default TIB_Transaction and was getting an AV when there wasn't one. I now have it so that it creates its own internal default transaction.

 

I added a method AddSearchIndex() for adding in full text searching indexes in code so that you don't have to use the GUI tool to administer your indexes. All index creation and population, etc. can now be done purely in code. I added a regression testing procedure to make sure this works correctly.

 

I added the CONTAINS_PHRASE stored procedure to the IB_FTS admin tool. Adding this stored procedure enables much better phrase based searching as noted above.

 

I made it so that various system tables will be filtered out of the drop down lists in the IB_FTS admin tool.

 

 

10/10/2012 Version 5.0.2 [Build 53]

 

I included XE3 support.

 

Added AsLongWord property to TIB_Column.

 

I enhanced the behavior when executing a CREATE DATABASE statement to take into account the DEFAULT CHARACTER SET setting. It will make the IB_Connection component have the CharSet and CharID of that character set.

 

I fixed a problem where connecting to an ODS 9 or earlier database shouldn't attempt to default to use the UTF8 Charset because it is unsupported. It will just default to NONE instead.

 

I included support for Delphi 5, 6, 7, 2005, 2006 and 2007.

 

 

8/21/2012 Version 5.0.2 [Build 52]

 

I fixed a problem with duplicate parameters of the same name not being resolved to a single parameter when they were of type DATE or TIME. They are all now resolved to a TIMESTAMP parameter so that they will also resolve with other parameters of type DATE, TIME or TIMESTAMP if they are given the same parameter name. I also made it so that CHAR columns will coerce to VARCHAR if they are in a duplicate situation together. It will also make the length go to the longest of the two being combined.

 

I fixed a problem having to do with executing statements during the BeforeDisconnect event of the connection. I was preventing new transactions from starting if the connection was in csDisconnectPending state. I softened this up so that it is possible to do things in the BeforeDisconnect event without causing a problem.

 

I enhanced the handling of BufferSynchroFlags so that it will coordinate with the use of the RETURNING clause in DML statements more accurately and efficiently. If you include all of the fields in the query in the RETURNING clause of your custom InsertSQL or EditSQL then you can avoid having to have the record refetched because it will know all of the needed information was in the returned values. This change also cured a blind spot where the record wasn't being refetched (synchronized) as it was in the past before I included support for the RETURNING clause. Before it just looked to see if a row was returned and if so then in some cases it would wrongly suppress the refetch. It assumed all values of interest were included in the RETURNING clause.

 

I also improved the performance of using EditSQL and LockSQL so that it won't refetch the record prior to executing the statement if these properties are used. It now assumes you are operating on searched values without the need of positioned updates that require an open cursor on the server for editing. I also included very detailed tests for this in the regression testing app.

 

I added a new protected property to the internal TIB_BindingCursor so that I could keep accurate metrics in the regresion testing app to make sure IBO is functioning as efficiently as possible. The property simply increments each time a "QuickFetch" is performed and is called QuickFetchGen.

 

I reduced the number of calls to TIB_Connection.Characteristics in order to try and improve performance.

 

I added in a check for exceptions during the TIB_Statement.SysStoreParamValueLinks method so that it won't interrupt an Unprepare or component destruction. If there is an error it will simply omit that particular value that the error occurred on.

 

I enhanced the IB_SQL tool so that in the Browse form when looking at Generators it will handle the character set variations better. In some cases there were string truncation errors that prevented this from working properly. This fix is only valid for Firebird because I made use of the EXECUTE BLOCK statement to work around the issues.

 

I also improved the IB_SQL automated command-line ability to dump a database via the DataDump feature. I added a new switch /path=<OutputDir> so that you can determine where the files should be placed. I also made it so that you can store the tables and columns you want excluded in a layout. You use the switch /layout=<LayoutName> in order to tap into the settings associated with that Layout. If your layout is in a group you can use this format /layout=<GroupName>\LAYOUTS\<LayoutName> in order to access it. FYI: The switch to tell it to do a data dump is /action=datadump. I also added the ability to sort the fields in the export by their natural order instead of in their alphabetical order.

 

I improved the logic to look for a failed connection errcode so that IBO will respond more gracefully to failed or shutdown connections.

 

8/9/2012 Version 5.0.2 [Build 51]

 

I added in functionality to properly decipher the connection character set when you are using the dbHandleShared property. I also enhanced the routines that handle the CharSet to CharID conversions so that they will fall back on the metadata information if necessary. They were also moved to the SchemaCache class and out of the IB_Utils unit.

 

I put in a few changes to help optimize the performance when preparing queries.

 

I fixed a bug in the full text search mechanisms when using a phrase search. In some cases it wasn't finding matches it should have found due to the handling of single quote characters.

 

I fixed a bug with SearchedEdits being set to false. It was getting a server cursor in order to perform the update but in the process of doing that in some cases it would override the new values you were trying to post to the server. Now, it puts the updated fetch in the Old values buffer instead of overwriting the values in the New values buffer.

 

I removed some code that Delphi 3 needed in handling integers. In some cases it would turn an invalid value from the AsString property into -MaxInt instead of raising an exception as it should.

 

I fixed a bug in Delphi 5 handling of variants in the FindKey() method. It didn't handle the varInt64 type properly so I just cast it to a string and then it worked as it should.

 

6/8/2012 Version 5.0.2 [Build 50]

 

I fixed an access violation when having the following type of query with two parameters of similar but different types that have the same name:
select  *

from rdb$database

where cast(rdb$relation_id as integer) = :Param1

   or cast(rdb$relation_id as decimal(9,2)) = :Param1

 

I also added some smarts to have a date only parameter and a timestamp parameter adjusted to both be of type timestamp when they are parameters of the same name. This is necessary so that they can be consolidated into a single parameter of the exact same type.

 

I fixed a problem in the TIBODataset feature to get the value for a column from the master dataset when inserting a record into a detail dataset. If you used the fully qualified fieldname in the WHERE clause instead of just the fieldname it would fail to recognize the proper value for linking them together.

 

I added a property to TIB_Dataset called UseReturningClause so that you can have control over whether or not the RETURNING clause will be used in the automatically generated DML statements when inserting and editing records. There are times when you won't want the extra overhead of this feature, such as when using the TIB_DataPump.

 

5/22/2012 Version 5.0.2 [Build 49]

 

I fixed the BLOB_ID invalid bug that happened in conjunction with using the IB_TransForUpdates property.

 

5/11/2012 Version 5.0.2 [Build 48]

 

I fixed the BLOB_ID invalid bug by identifying temporary blob id's and loading them in immediately. This could cause an apparent performance degradation as the overhead to get the blob data will happen right along with the fetch operation.

 

I fixed an issue where the NativeCharLen wasn't getting set just right and if your database was a multi-byte character set then it could have affected you. Where this showed up was in the IB_SQL tool if you went to edit a stored procedure the CHAR and VARCHAR lengths were multiplied too long instead of properly reflecting the character length instead of the byte length.

 

I did quite a bit of work on the IB_Doc tool I am developing. It's actually an app I wrote in the past now being made generic and included in the IBO library. It is still far from ready for general use so please just ignore it for now. The same goes for the web/server files too.

 

Carlos Cantu added a feature to the IBF_Monitor form so that it would AutoScroll.

 

I added some additional data points to the SQL monitor output.

 

I fixed an AV in the TIB_CtrlGrid control.

 

4/5/2012 Version 5.0.2 [Build 47]

 

I fixed a performance issue that crept into Build 44 having to do with the dialog that appears when records are being fetched.

 

I made an improvement to the behavior when the CallbackInc property is set to allow callbacks, which are more or less just various points where Application.ProcessMessages is called. There was a problem when repeatedly setting a new filter text and the dataset could get closed and remained closed instead of refreshing properly.

 

I fixed a problem where in some cases the SQL hourglass cursor would not return to the normal default screen cursor when it should.

 

I made it so that the ftString and ftWideString are interoperable/compatible with TIBODataset.

 

I added a new event AfterPosted to the TIB_Dataset so that you can get a hook after the post had totally completed. This could be useful to cope with a recent change where the AfterPost event was adjusted to take place prior to a CommitRetaining of the posted change if AutoCommit is set to true. If you want to be sure the changes are committed then you can use this new event.

 

I added the ability to use SET AUTO DDL in the TIB_Script. This is to maintain compatibility to other tools. This turns on the transaction's ServerAutoCommit feature. Unfortunately, there was a bug in Firebird's ServerAutoCommit implementation that was recently fixed so it's possible you may run into trouble with this. I plan to detect the bug and to simply send explicit COMMIT commands to emulate the ServerAutoCommit capability.

 

I fixed a problem in TIBODataset with UTF8 BLOB columns not being properly encoded because it was defining them as TMemoField instead of TWideMemoField. This seemed to happen right after a database was directly created.

 

I added blob segment data in IB_Monitor when doing a put blob segment call.

 

3/30/2012 Version 5.0.2 [Build 46]

 

I reworked the logic to make sure there was an efficient and accurate way to relate a TField to its corresponding internal TIB_Column object. There were some cases where you could get an "Unexpected column alignment" error that was actually not really a problem.

 

I added a global flag to the TIBODataset handling called StripDoubleQuotesFromFieldNames so that if you do not want to bother with double quotes around your TField.FieldName property values, you can set this flag to true.

 

I fixed the problem where the DDL extract utility was including RDB$ADMIN as a ROLE. This is a system generated role that should not be appearing in the DDL output of the database extract.

 

I enhanced the Metadata extract utility to include the SUSPEND token in the body of the procedures whne using CodePass cpAuto so that there won't be errors due to those procedures not being select procs.

 

3/28/2012 Version 5.0.2 [Build 45]

 

I fixed a bug in the Screen.Cursor handling to respect the YieldLevel properly and to be more robust when you are changing the YieldCursor from one value to another. It would get thrown off if you changed it midstream. Now, if you change it the Screen.Cursor is changed immediately if it is currently in effect so that it won't neglect to set it back to default.

 

I fixed a bug in the handling of field names that have special characters. I was hard coded to decode them as UNICODE_FSS when I should be decoding them as whatever the connection character set is. This caused an "Unexpected column alignment" assertion check to fail when it should not have failed.

 

I finished up the fix in Build 44 having to do with Blob columns.

 

I added the GetServerDefaults property to the IB_Query editor.

 

I added handling for USER and CURRENT_USER if they are a server default value.

 

I added a check when working with Blob columns and TDataset so that if you are using them in write mode it will check for an edit state and raise a proper exception instead of crashing on an access violation.

 

3/23/2012 Version 5.0.2 [Build 44]

 

I added DrawingStyle as a published property of TIB_Grid control. I also fixed a bug having to do with the boolean indicator not being centered properly in the cell.

 

I enhanced binary blob handling so that it will use a variant array of bytes to store its contents instead of a rawstring. This way potential transliteration issues are avoided.

 

I fixed a problem where a dataset is prepared and then search criteria was put into the data links and then the dataset was put into search mode and then posted without the search criteria being taken into consideration. This is because when it was put into search mode it caused the query to be flagged as having valid SQL when it really didn't.

 

I enhanced the dialog that pops up while records are fetching so that when it is done it will be freed so that it won't hog resources.

 

2/23/2012 Version 5.0.2 [Build 43]

 

I cleaned up the handling of Boolean fields. In some cases it was causing the greyed state to result in a blank value instead of a NULL value. There was also a case where a buffer was left in an ambiguous state by being NULL that tripped up the boolean value processing such that when it is set to NOT NULL it would get confused and possibly throw an exception needlessly.

 

I made the TIB_Column.RowData and OldRowData declared as RawByteString instead of String.

 

I put an extra layer of checking whether the dataset is in an edit state when a column is modified.

 

2/22/2012 Version 5.0.2 [Build 42]

 

I improved the handling of calls to LocateRecord() where for some reason in some cases the variant passed in as the value to search for was taken in as variant of type varByte which caused an exception if it was compared to a value greater than MaxByte. There was some exception handling that would catch the problem and react to it, but it wasn't as efficient as avoiding the problem to start with. I avoid it by looking at the variant type and casting all whole numbers to an int64 variant. There was also an issue when a VarArray was passed in with the values and you didn't use a zero based variant array. I now have it tolerant of a lower bound other than 0.

 

I worked on making the array support routines more efficient with buffering of the array data. It will now even pull slice data out of cached array data. But, if the array hasn't been pulled into the cache, a slice request will still just go directly to the server. I do not cache slice requests unless the slice requested happens to be the whole array.

 

2/20/2012 Version 5.0.2 [Build 41]

 

I fixed a bug in the handling of the PessimisticLocking property. This bug was introduced in build 36f. This bug may cause changes to be lost because it clears the lock by doing a LosePoint after the edit has posted but prior to the transaction being activated. I closed this gap by adding the property ActivatePendingCount to the TIB_Transaction. This tracks the fact that a post was made and that the transaction is awaiting activation. It used to be activated immediately, but I needed to defer this and didn't take PessimisticLocking login into account at that time. I added this to the regression testing app so that this won't get broken in the future.

 

I made changes to allow for array columns to be edited in the memo popup from the IB_Grid when EditLinksAuto is set to true.

 

2/15/2012 Version 5.0.2 [Build 40]

 

I fixed a bug in the handling of varchar array columns. I was not allocating sufficient buffer space to deal with them properly and so there was a footer overrun that FastMM4 handily detected and brought to my attention. This problem was showing up by causing the IB_ArrayGrid to have access violations due to the corrupted memory issue of overrunning its buffer space.

 

I enhanced the versatility of using KeyLinksAutoDefine. In some cases it would attempt to add in the RDB$DB_KEY of a table to work as the KeyLinks value. However, in some cases this would cause the statement to fail to prepare. I now detect this and set a flag to prevent IBO from adding in the DB_KEY and attempt to prepare the statement again without it. Thus, it will go ahead and work after a retry if the SQL statement is otherwise correct. No exception will be raised but there will be evidence of a failed prepare that shows up in the SQL trace monitor results.

 

I made some enhancements to the batch execute feature recently added so that the IB_Export of SQL statements will have a format that is easier to read for tables with numerous columns.

 

2/14/2012 Version 5.0.2 [Build 39]

 

I fixed a problem with TIBOTable and CachedUpdates. In one case it was possible to call ApplyUpdates and the associated transaction was not properly activated.

 

I added a new feature to the TIB_Script component so that it is possible to create a database, including array data, from a script file. This has been made possible by implementing the AsString property for the IB_ArrayColumn object. I added a new SET command called BATCH_EXECUTE that allows you to setup a prepared statement with ? input parameters. Here is an example of how you can use it:

 

SET BATCH_EXECUTE 'INSERT INTO COUNT_TEST( ID, COL1, COL2 ) ' +

                  'VALUES( ?COUNT_TEST.ID' +

                  ', ?COUNT_TEST.COL1' +

                  ', ?COUNT_TEST.COL2 )';

0, 'Zero',  '0';

1, 'One',   '1';

2, 'Two',   '2';

3, 'Three', '3';

4, 'Four',  '4';

5, 'Five',  '5';

6, 'Six',   '6';

7, 'Seven', '7';

8, 'Eight', '8';

9, 'Nine',  '9';

SET BATCH_EXECUTE '';

COMMIT;

 

You pass in the raw data that you want executed as the following statements and set the BATCH_EXECUTE item to blank in order to resume normal script execution.

 

 

2/9/2012 Version 5.0.2 [Build 38]

 

I made additional improvements to the handling of the Screen.Cursor to remove flickering.

 

I fixed a bug in the SchemaCache.IndexDefs SEGS param value. It was not formatted correctly.

 

I fixed a bug in the handling of VARCHAR array column values. If it was totally blank via all #0 characters, I needed to return a blank string instead of a full string of #0's.

 

I added functionality to make IBO more consistent about when a record is synchronized after an insert or an edit. There was a different behavior depending on the setting of PreparedInserts, for example. I also added the same logic to when you provide your own custom value for InsertSQL.

 

I tightened up the handling of AbortFetching and FetchingAborted so that it is possible to resume normal operations after calling AbortFetching. The flag will automatically be reset when a typical data navigation is requested. Thus, the FetchingAborted flag will only pertain to the last data navigation call. NOTE: You may need to make use of the FetchingAbortedGen property instead of the plain old FetchingAborted property so that you are not thrown off by other factors, such as a TIB_Grid repainting itself and clearing the flag before your code checking for that flag's value is executed. This property (FetchingAbortedGen) allows you to mark the level with a local variable storing its value prior to an operation (like a While not Eof do ... loop) and then to monitor it during its processing and to jump out if that value gets incremented by a call to AbortFetching.

 

I use the FetchingAbortedGen property this way because it's possible to have application "callbacks". These "callbacks" are really just Application.ProcessMessages() calls taking place inbetween fetches (depending on your CallbackInc property setting). Thus, if a mouse click results in something where AbortFetching is called, your process can detect that and act accordingly. For example, this happens with the TIB_Grid. If you click a cell while the dataset is fetching, it will automatically cause the dataset to cancel its fetching efforts by calling AbortFetching. The idea is to have the grid override so that the user can grab control away from a previous call, like when CTRL+END is pressed and the dataset is scrolling to the end and fetching records in the process.

 

Thus, code that used to look like this:

 

begin

  IB_Query1.Open;

  while ( IB_Query1.Active ) and

        ( not IB_Query1.Eof ) and

        ( not IB_Query1.FetchingAborted ) do

    IB_Query1.Next;

end;

 

should now be rewritten as this to be robust:

 

var

  FAGen: integer;

begin

  FAGen := IB_Query1.FetchingAbortedGen;

  IB_Query1.Open;

  while ( IB_Query1.Active ) and

        ( not IB_Query1.Eof ) and

        ( FAGen = IB_Query1.FetchingAbortedGen ) do

    IB_Query1.Next;

end;

 

 

1/30/2012 Version 5.0.2 [Build 37]

 

I cleaned up the way the OnUpdateError notification is handled for the TDataset based components. I also added a protected virtual procedure UpdateError so that you can customize your own sub-class to handle errors in a more specific manner throughout your application.

 

I fixed a problem with TIBODataset and AssignSQLWithSearch when FieldsIndex is being used.

 

I fixed another problem with the screen cursor flickering between the busy state and the yield state.

 

1/26/2012 Version 5.0.2 [Build 36l]

 

I fixed a bug in the array column support for DECIMAL() array columns. I was not handling the scale factor properly. I also needed to add in support for int64 based array columns.

 

I added TIBOArrayField for working with array columns in TIBODataset.

 

In the process of the above changes, many array handling routines were moved to IB_Utils.pas.

 

I fixed an inefficiency problem where under certain circumstances a blank BlobID or ArrayID was needlessly being fetched from the server. Since it will always result in 0 bytes being returned, I simply put it to 0 bytes without involving the server.

 

I fixed a bug in the TIB_Monitor so that when the ProfilerConnection is not connected it won't raise an exception about it. Just quietly ignoring to do any profiling is preferrable.

 

1/25/2012 Version 5.0.2 [Build 36k]

 

I fixed a bug in the TIB_StringList.IndexParamValue property.

 

I fixed a bug in IBODataset where you had a database with default character set of NONE and you connect with UTF8 charset it would leave an extra space at the end of a literal text string.

 

I added support for ftFixedWideChar to IBODataset components.

 

1/24/2012 Version 5.0.2 [Build 36j]

 

I fixed a bug that showed up in the IBF_Query form that is used for the design-time component editor. It wasn't saving the ColumnAttributes settings properly.

 

1/23/2012 Version 5.0.2 [Build 36i]

 

I improved the new Screen.Cursor handling algorithm. The screen cursor was going invisible in some cases.

 

I fixed a painting problem with the button bars for Delphi 2009, 2010 and XE.

 

1/20/2012 Version 5.0.2 [Build 36h]

 

I fixed a bug in the script parsing logic that detects a TRIGGER or STORED PROCEDURE statement in order to allow the semicolon be the statement terminator without a problem. Thanks to Sean Palmer who pointing out this problem and helped me to fix it by sending a sample app. I also included this problem in the regression testing application.

 

Thomas Steinmaurer pointed out a problem with the component editor for the TIB_Connection. If you made a connection to a database then it would reflect the ForcedWrites and ReservePageSpace status in their respective checkboxes. But, this had the effect of storing a setting other than just leaving it to the default setting. Thus, applications would try to make set it to true or false when a connection was requested instead of just leaving it alone. This problem became more clear when a non-SYSDBA/OWNER user attempted to connect and failed with an error due to lack of permission.

 

Thanks to the suggestion of Carlos Cantu, I implemented a way to avoid the screen cursor flickering so much when performing quick operations repeatedly. If you have a TIB_Session with UseCursor set to true and the TimerInterval is set to something above zero then you will be able to notice the screen cursor avoiding flicker. It relies on the session's internal timer to see if there is no more active work going on. If enough time has elapsed, the screen cursor will be returned to normal. There is some fine tuning of the session's timer interval so that the screen cursor will behave in a consistent and accurate manner. I also added the RestoreCursorTicks property so that you can fine tune the timing involved in this new feature.

 

I adjusted the behavior of CheckTransaction() so that when preparing statements it will make use of the transaction of the schema cache, which is a read-committed and read-only transaction. This makes IBO more friendly for garbage collection as well as more precise when working with tiConcurrency/tiConsistency isolation level because it won't prematurely start the physical transction that locks in your snapshot view. Credit also goes to Carlos Cantu for helping with this.

 

1/19/2012 Version 5.0.2 [Build 36g]

 

I fixed a glitch in the TIBODataset handling of TParams when the SQLWhere clause is changed while the query is prepared. If a new parameter is included in the SQLWhere, IBO was not adding in a new TParam object. I now cause an immediate re-prepare when the SQLWhere is modified so that the TParams will be repopulated immediately as well.

 

I finalized the support for DMLCaching to be included in the IBODataset classes.

 

1/18/2012 Version 5.0.2 [Build 36f]

 

I fixed the case where DMLCache events being received while in insert mode could lead to a needless exception being raised. It will now set a flag so that when the Insert is posted it will process the DMLCache event. In the future I will try to have it process the event even while in Insert mode without interfering, if at all possible.

 

I surfaced the DMLCacheFlags property to the TIBODataset class so that TIBOQuery and TIBOTable can make use of the DML caching capabilities. I also surfaced the GetServerDefaults property to TIBODataset as well.

 

I adjusted the timing of when a post of a dataset will cause the transaction to be activated such that it will happen (by default) after the AfterPost event has been processed. This allows other actions that need to take place inside the AfterPost event to be included in the processing of the post. Note: It is also acceptable if you want the transaction activated to go ahead and call it directly in the AfterPost event and then it won't be called subsequently. This is so because I use a newly added property called ActivateSequence. It is a simple counter that increments each time Activate is called and rolls over again as needed. Thus, I can distinguish if the Post yet needs to be activated when all of the events dealing with the post are completed and then I Activate the transaction if it has not yet been Activated since the post actually took place on the server.

 

1/17/2012 Version 5.0.2 [Build 36e]

 

I fixed a glitch in the IsEmpty() method from my recent enhancement to it. I added it to the regression testing so that it will remain solid in its expected behavior.

 

I discovered that using CacheStatementHandles can be problematic so I have set its default value to false until I get to the bottom of what caused a glitch in someone's application. It could actually be an issue with Firebird as well. But, things will stay more clean if a new handle is acquired more regularly instead of using the same handle over and over again for any number of statements.

 

I continue to make improvements to the regression testing application so that it is easier and more productive to work with. Each run will now produce a distinct set of log files.

 

1/16/2012 Version 5.0.2 [Build 36d]

 

I fixed the ServerSQL and ClientSQL properties which were causing other things depending on them to malfunction. For example, the RecordCount property of a detail dataset in a master detail relationship did not return the correct number of records because the WHERE clause items of the master detail were missing from the ServerSQL property when the ClientSQL property was derived.

 

1/16/2012 Version 5.0.2 [Build 36c]

 

I added in compiler directives so that it is easier to produce CONSOLE applications.

 

I modified the IsEmpty property and turned it into a method so that you can optionally pass in a MinRows factor. Thus, you can efficiently see to what degree your dataset is empty without resorting to use of the RecordCount property, which can be very inefficient and even inaccurate with some queries.

 

I started making an application where most all reported issues can go into a console application to check for a regression of problems. Thus, prior to making any release I can check the basic functionality of IBO and assure no formerly corrected bugs have returned. I will also begin to insist that bug reports be submitted in such a way that this application is modified so that their bug reproduces in the application as modified by them. This way it will remain a permanent part of the regression testing system. I will probably make this publically available on SVN so that it will be easier to maintain with many people collaborating.

 

The TIBODataset class changed the default setting of PreparedInserts from true to false. I've found that this setting degrades overall performance and I happened to run into a bug with Firebird under this default setting. Therefore, I am configuring the properties PreparedEdits and PreparedInserts to always store their value in the DFM and altering the default value of PreparedInserts to true in order to avoid that bug under default circumstances. The bug is actually in conjunction with the RETURNING clause that requires the BufferSynchroFlags property to include bsAfterInsert for the bug to bite. It also seems to require other obscure aspects in the data itself to get bitten. I plan to submit a bug report with a sample app to reproduce the problem for the Firebird team.

 

I made a slight adjustment to the statement parsing logic in the TIBODataset class so that input parameter TParam objects will be created even prior to the statement being prepared. They are created simply as a result of there being an input parameter in the SQL statement provided. It will parse for parameters each time the SQL text is modified.

 

I adjusted the behavior of the TIBODataset.Required property to take into consideration the PreparedInserts and/or PreparedEdits value being true. If these are true then the presense of a DEFAULT value on the server cannot impact things because a DEFAULT only applies when a column is NOT included in the INSERT statement. Thus, there will be columns showing as Required that previously were not showing as Required even though they were defined as NOT NULL columns.

 

I needed to touch-up the routine to parse out the FIRST and SKIP values correctly. This problem yet showed up in the RecordCount property because it caused it to return an incorrect result.

 

1/12/2012 Version 5.0.2 [Build 36b]

 

I fixed a very obscure problem where when using TIBOTable and a commit happened after an edit when bsBeforeEdit flag was set and all records had been fetched and FetchWholeRows was false, the current record was blanked out until the record pointer was moved.

 

1/11/2012 Version 5.0.2 [Build 36a]

 

I fixed the persistence of input TParam objects in TIBOStoredProc. Thanks to Carlos Cantu for his help.

 

1/10/2012 Version 5.0.2 [Build 36]

 

I fixed a problem when connecting to Firebird 1.5 database that was created with charset NONE as its default character set. It was setting the NativeCharLen property to 0 which caused the data to be trimmed. Credit goes to Ronny Cordes of Sita Software for providing the bug report and the fix.

 

I adjusted the behavior of the default character set mechanism to only use UTF8 as the connection character set when the database server being connected to is Firebird 2.5 or higher because of its strictness in dealing with malformed strings. Otherwise, it will continue to be acceptable to connect with NONE as the character set as it has always been in the past.

 

I removed the length limitation on the message string passed in when an EIB_ISCError or EIBO_ISCError exception object is created for Delphi 2006 and higher. This limitation should no longer be required with the memory manager that Borland started using at that time.

 

I added a new DEFINE in the IB_Directives.inc file for controlling whether the CheckForReservedTokens behavior is active while in design-time. You may not want to have to deal with double-quoted reserved tokens at all and so this would allow you to turn this off totally.

 

I fixed a bug introduced in the last sub-release from addressing problems in the parsing routines. There should be some performance improvement in this release since I am fixing the bugs by tightening up my parsing code and eliminating unnecessary parsing operations when the results were already derived from a previous parsing of the SQL and it hadn't changed.

 

I fixed the painting problem with the button bars in XE2. Credit is due to Brian Culverwell for turning me on to how to fix the problem.

 

I fixed the problem with TIB_StoredProc not properly displaying output values. I also added in two additional transaction mode flags so that a stored procedure being executed can be recognized.

 

I added support for the ROWS clause to also work in the dataset's RecordCount logic.

 

I fixed an access violation in the TIB_BlobStream class introduced in the last version due to working on adding in support for array varchar strings that have multiple bytes per character.

 

1/3/2012 Version 5.0.2 [Build 35]

 

I have changed the behavior of FieldByName(). In the past I have allowed the SQLName column by iteself to satisfy a match but this has led to confusion when there is an AS aliasname given to other fields that matches another field's SQLName. I have decided if you want to use FieldByName() based on the SQLName value instead of the AliasName value that you must qualify it with the relation name. This way it eliminates the possible confusion of returning a column with an AliasName or with a SQLName if they are matching. I have also added a global variable to govern the use of a behavioral change I am making to the FieldByName() logic. Set UseSQLNameUnqualifiedInByNameLookup to true if you need the old behavior restored.

 

I enhanced the getLitSafeStrPos() routine to be able to work with both single quotes as well as double quotes. Previously it only safeguarded against literals in double quotes. Thanks to Frank Reim for pointing out the need for this improvement.

 

I changed the way the filter expression is processed for case insensitive processing. Rather than use the operator UPPER() on the expression side, I just upper case whatever is there in the code, which is most likely a literal string value. This way the ability of indexes with the UPPER() operator can be used in an optimized way with the resulting filter expression that is sent to the server. Thanks again to Frank Reim for this improvement.

 

I made it so that when using a CTE (common table expression) with TIBOQuery/TIB_Query that the individual row CurrentCursor and BufferCursor internal objects produce valid SELECT statements to fetch individual rows. Previously it would just return an error message to check the KeyLinks. However, even with valid KeyLinks assigned it would still fail. The fix was to have an unprepared statement with a CTE to be properly seen as a SELECT statement. The IsSelectSQL property was returning false when it should have returned true.

 

1/3/2012 Version 5.0.2 [Build 34]

 

I added support for array columns to work through the AsString property. I included this in the IB_Export component so that array data can be included. I also added support for array slice data in the SQL trace monitor.

 

1/1/2012 Version 5.0.2 [Build 33]

 

I added support for the SIMILAR TO clause in the Filter expression.

 

I worked on the IBF_DataDump form so that it will also take into consideration the possibility to dump out SQL files. There were also some things in this form that needed finishing up. It wasn't saving and restoring settings the way other forms do and it wasn't respecting the export format properly.

 

I added two new SET commands to IB_Script. BATCH_PREFIX and BATCH_SUFFIX. This is so you can remove redundant portions of subsequent statements in a batch until you set them back to blank. I made the IB_Export use this new feature when it dumps out INSERT statements so that the resultant SQL file will be smaller and cleaner to read.

 

I made the new RETURNING clause for updates feature dependant upon whether the BufferSynchroFlags property indicates that the extra effort to keep the buffers synchronized is desired. This is to improve the performance of the baseline operations by eliminating potentially useless overhead. If all columns are represented in the RETURNING clause then the previous action to also re-fetch the record will be suppressed as that would be a duplication of effort. However, if your query has a column in it that doesn't have a corresponding column in the table, such as a correlated sub-query or an expression of some kind, the record re-fetch will still take place in addition to the row being returned from the update operation.

 

Added UseConnectionPool property to the TIB_ConnectionBar so that you can utilize connection pooling with this control.

 

I made it so that when a connection is requested and a value for CharSet is not supplied that it will get the default character set of the database and use it as the connection CharSet property. If the database has NONE as the default character set then IBO will look for a new connection parameter called DEFAULT CHARSET and make use of it so that NONE will not be used as the connection CharSet. If this parameter is blank then IBO will now use UTF8 as the CharSet. This will show up in the value that is indicated by the connection's CharID property and it will appear in the CharSet property as well, but the connection's Params property will not have a CHARACTER SET value plugged into it. The CharSet property merely shows the CharSet used for the connection (FConnectedCharSet) while it is Connected = true. When disconnected the CharSet property will go back to showing blank to reflect what is in the Params stringlist for the connection.

 

I put in a way for a statement being executed via ExecuteImmediate() (such as when executing a TIB_Script) to be retried when it has a malformed character in it. For example, if you have an umlat in the comments of a stored procedure it can cause an error when it tries to store the source of the stored procedure into the UNICODE_FSS system table.

 

I fixed a couple bugs having to do with select statement using FIRST and/or SKIP. It was not working properly if you set the FetchWholeRows property to false. Now, if you have a FIRST and/or a SKIP token in your query then the FetchWholeRows property will be ignored. I also improved the RecordCount property so that it will take the FIRST and SKIP settings into consideration. If you have just a simple numeric value or if you are using just an input parameter then the RecordCount property will be successful. This is even true while the query is merely prepared.

 

I enhanced the Splitter data pump item so that the splitter character can be a string and not just a single char.

 

In order to be Unicode compliant for internal settings of TIB_StringList param values, I had to replace the use of the GetCharValues() and SetCharValues() routines. I replaced them with stLitCriteria() and cvLitCriteria(), which are Unicode compliant. If you are directly manipulating the internal storage of TIB_StringList param settings you will need to watch out for the new format too. I have it still supporting the old format for the time being but it is considered deprecated. Both methods were able to co-exist together with the Unicode compliant method being defacto now.

 

12/28/2011 Version 5.0.2 [Build 32]

 

I fixed a potentially serious bug in the IB_TransForUpdate transaction processing. Under some circumstances the dataset was not properly recognizing the IB_TransForUpdate transaction and was just using the IB_Transaction setting instead. This would result in an error if you had made your transaction a read only transaction because it would have tried to post an edit/insert/delete through it instead of the other.

 

I fixed a bug I recently introduced in the pessimistic locking functionality that caused access violations if you had an exception during the attempt to lock the record. This came about while I was implementing the RETURNING clause for it so that when the lock is acquired you can also get the most recent version of the record on the server at the same time.

 

12/27/2011 Version 5.0.2 [Build 31] (had a bad bug)

 

I overhauled the TIB_Export component to use the more advanced encoding capabilities so that it is possible to control what encoding the exported file will be in. I also changed some of the names of the properties to be more platform and encoding independant. CRLF to NewLine and ASCII to Text. I also added in a new export format of efText_SQL. This will create a script file containing INSERT statements that can be directly executed in the IB_Script component.

 

12/24/2011 Version 5.0.2 [Build 30] (had a bad bug)

 

I tightened up the qualifications for allowing input parameters with the same name to be taken as duplicates. Previously I only took the sqltype into consideration but I have now added sqlscale. This will make it so that character set and collation will be taken into consideration for Firebird 2+. Two columns of differing charset data should not be treated as equivalent. The same goes for numeric columns that have different scaling.

 

I fixed a bug having to do with the Blob IsLoaded logic. The array of BlobNode records associated with TIB_Row were not being initialized with BlobSize of -1 to indicate that no blob was loaded. Instead, it was allocated and initialized to BlobSize of 0, which in some situations made it appear that the blob was loaded when it actually wasn't. Fortunately, the logic to actually load the blob was not fooled, which is why this bug was difficult to detect. The result of this wasn't to show an empty blob but rather to trick visual controls into actually loading the blob as if it was set to auto load.

 

I fixed a bug in the statement parser where it wouldn't add in a FOR UPDATE clause correctly if a semicolon was used at the end of the statement. I enhanced the parsing routines to provide additional information about the potential placement of a clause in a select statement.

 

I have reworked and improved the TIB_UpdateSQL statement processing in order to better handle a bug in the Firebird engine having to do with combining RETURNING with a positioned update (WHERE CURRENT OF). When this bug is hit a global flag is set so that there won't be a continuation of the inefficiency of adjusting and preparing the failed statements over and over again.

 

I fixed the IB_Monitor so that it would dump out the input XSQLDA values prior to the statement being executed in the case that the output would affect their associated values. In some cases the input buffers and output buffers were pointing to the same memory and thus it made output values appear to be input values as well.

 

I enhanced the INSERT and UPDATE statement processing so that it automatically takes advantage of the RETURNING clause (Firebird 2.x+ only) so that any trigger assigned values can be brought back to the client. This will be particularly useful if you are having triggers assign ID values for your keys or if you have COMPUTED columns. Keep in mind that these values won't be available until after the record is posted to the server. If you need your key values prior to posting then you will need to make your trigger code only assign key values if they are not already provided.

 

I fixed an AV at prepare time of INSERT statements introduced by recently added code to try and figure out an insert statement's table so that input parameters could know what table they are associated with. This is to help ensure all input parameters of blob columns get handled with the appropriate charset information.

 

I modified the behavior of locating and loading a client library. I made it look specifically in the executable's directory for each of the 4 possible client library names so that it will give preference to any of the 4 clients being in the same path. Before it would just look for the general client library name and only behave correctly for fbclient.dll since it is first. If you put an IBTOGO client in the same path as your EXE it would still grab a fbclient.dll in the system directory.

 

I fixed problem with encoding and decoding of TStrings that was left over from the previous attempt to fix it. I fixed most of it but there was still a part remaining to make totally conforming with the new encoding functionality in Delphi 2009+. I also included the methods to save and load text files.

 

12/20/2011 Version 5.0.2 [Build 29]

 

I fixed a memory consumption problem due to the apparent memory problem of the TTimer component. If you create and destroy instances of TTimer you get lost bytes of memory. They are not reported as an actual leak (by FastMM4) but if a program created and destroyed TIB_Session instances then it also caused TTimer instances to be created and destroyed. I made it so that TIB_Session only instantiates its internal TTimer component if you actually set the TimerInterval to a non-zero value in order to avoid the needless memory consumption.

 

I fixed a memory consumption problem in the code to get the connection characteristics information. There was a string that was getting information appended to it instead of being reset to a blank string prior to getting the characteristic information. This caused a string to grow and use up memory needlessly under certain circumstances.

 

I included consideration of the connection's CharSet property in the connection pooling logic.

 

I fixed a bug in the destruction phase of the TIB_Session instance. It wasn't closing all of the transactions prior to destroying its owned instances which in some cases caused an exception because the transaction would try to get a session association in order to close the transaction when the session was trying to destroy itself. This caused the transaction to create a new reference counted session instance to do what it needed to do, which was an unnecessary overhead. This could have also caused a memory consumption issue in some cases.

 

12/13/2011 Version 5.0.2 [Build 28c]

 

I fixed a problem in the logic that KeyLinksAutoDefine relies upon to set valid KeyLinks. In some cases IBO was giving you the RDB$DB_KEY instead of taking advantage of primary keys that were available. This showed up because a query with BufferSynchroFlags were set to synchronize on the after insert event and it is impossible to know the DB_KEY of a record until after it has been fetched. Thus, it was quietly being purged from the buffer which make it look as if the inserted record had dissappeared.

 

12/12/2011 Version 5.0.2 [Build 28b]

 

I fixed a problem havingto do with the usage of TIB_RichEdit and Unicode RTF data. I needed to implement encoding and decoding in the layer of code when a TStrings is streamed in and out. This is because if you use the TStrings.Text with the rich text editor then it put it in PlainText mode. Thus, you would lose all of your formatting. Now the TIB_RichEdit control works with Unicode without losing formatting. This necessitated using features that are only available in later versions of Delphi so this fix will not be able to benefit versions prior to Delphi 2009.

 

12/9/2011 Version 5.0.2 [Build 28a]

 

I fixed a problem in the internal logic of the Locate() and Lookup() methods. If you had multiple key columns and you had one or more of them that varied between being NULL in value and NOT NULL then depending on how the timing was the locate cursor could have been prepared with an ineffective SQL statement and failed to return results when the records were in fact there on the server. This only affected situations where the records for the dataset were not all fetched into the buffers. Thus, it was a combination of rather rare circumstances that brought this to the surface.

 

12/6/2011 Version 5.0.2 [Build 28]

 

I enhanced the handling of the CharSet information for columns and parameters. When the connection CharSet is NONE then it is necessary to pay attention to the actual CharSet of the column in the database because the server won't do any transliteration for you with the CharSet of NONE on the connection. Therefore, I had to figure out ways to associate input parameters to their actual column type in the database. There may be some parsing required, but you can avoid this if you use fully qualified parameter names. This is done simply by prefacing the parameter name as follows :TABLE.COLUMN. If this is done, then IBO can use the correct CharSet information from the metadata.

 

I also fixed a problem where input parameters for BLOB columns were defaulting to NONE instead of defaulting to the connection CharSet. This resulted in the Malformed String error in some cases. It is also possible that some malformed data could be in your database as a result of this problem so it would be a good idea to make a careful check of your data since some encoding and decoding may not have been performed properly on blob memo columns.

 

I worked around a problem with Firebird 2.0 when using WHERE CURRENT OF in cursor based update statements and the UPDATE statement used the table name and the relation alias name as the same as the table name. For some reason this confused the parser and it returned an ambiguous alias error. I now detect when the table name and the table alias are the same and simply omit including the table alias in the statement, which avoids the problem.

 

I added a protected virtual method so that subclasses of TIB_Statement with an unassigned TIB_Transaction reference can be dealt with in a custom way instead of just raising an exception. This also will allow all internal statement, cursor and buffered queries to attempt to resolve an unassigned transaction with their parent component. This will also make it so that when an exception is raised it will be from the actual component that owns any of the internal components.

 

I fixed a bug in the TIB_Currency control. It was dropping off the negative when a number was -0.nn.

 

I added the pipe and tilde characters into the range of valid characters for macro field names.

 

I fixed a problem with C++ Builder 2006 where there was a function that returned an array, which failed to compile. I changed it to a procedure with an "out" parameter to solve the problem. This was an obscure internal function so it's highly unlikely that any application code will be affected. If so, the problem will become immediately apparent when your build fails. It was in IB_Utils.pas and was the MD5String() function to return an MD5 digest.

 

11/30/2011 Version 5.0.2 [Build 27]

 

I worked around what appears to be a bug in Firebird. When executing an EXECUTE BLOCK statement using the TIB_DSQL component it opens a cursor on the server. Therefore, when you would do an execute call the 2nd time it would raise an exception complaining about a cursor already being open. I detect this unexpected exception and call the close cursor API call and then resubmit the execution again.

 

I put the older method of deriving and storing the jumble key in the system registry. The newer method of using binary storage instead of string storage didn't work on Free Pascal Compiler.

 

I fixed an index out of bounds error for FPC when getting the default character set for a column.

 

I improved the parsing of the Filter property to allow for numerical equations with + - / * operators in it.

 

11/23/2011 Version 5.0.2 [Build 26]

 

I fixed a bug in the handling of the contents of the TIB_MemoEdit. It was accessing the column data in such a way that the encoding and decoding routines were being bypassed.

 

I fixed a parsing bug in the handling of Filter statements. (ACOL = 5.2) was being misinterpreted such that the period in 5.2 was causing a break instead of 5.2 being treated as a distinct real number value.

 

I fixed a bug in the destruction phase of the TIB_Dataset where it was possible to get an error message stating that the transaction did not have a valid connection when it was simply in the process of being destroyed. This doesn't occur in all cases so most will not have ever noticed this condition.

 

11/17/2011 Version 5.0.2 [Build 25]

 

I fixed a problem having to do with TIBODataset and master detail relationships. When a database is being disconnected it would close and unprepare datasets which could cause the parameters of the detail query to be refreshed when its master dataset was being unprepared. It tried to close and open the detail query during the disconnect phase and was prevented due to the transaction ignoring the request to start a new transaction while in disconnect phase. Thus, it gave an invalid transaction handle error. Now I guard against this by checking for the disconnect phase before refreshing detail datasets.

 

I made some enhancements in the handling of default connections for statements and transactions. I recently tightened things up so that statements and transactions didn't arbitrarily assign themselves to connections in order to avoid problems that could result from this. But, in the case of applications that only have a single connection component, it makes sense to allow the former flexibility since there isn't any possible problem from referencing the only available connection. Therefore, if your application only has a single connection, it shouldn't be necessary to go throughout your application and plug in all the references. If you need more than one connection and you still want flexibility then you need to make use of the TIB_Session.DefaultConnection property.

 

I fixed a problem having to do with input parameters being refreshed when a TIBODataset is in the process of being unprepared. This eventually led to an invalid transaction handle error.

 

I fixed the method in IBF_Base.pas that checks the position of a form when it position is saved and reloaded so that it is sensitive to multiple monitors and so that it works more effectively to keep a form from not being visible anywhere on the screen. This should make it so that the forms that come up with the various component editors will not appear somewhere off the screen and be unusable.

 

I fixed the recently rewritten routine to get a generator value to properly handle Unicode generator names.

 

I put the XSpin.pas unit back into the product because it was so difficult relying on the TSpinEdit component provided by Delphi/CPPB. In some versions its there as TSpinEdit and in others it is as TCSpinEdit. There is no official support for those components so I decided I better just use the TXSpinEdit control that I have used in the past.

 

11/15/2011 Version 5.0.2 [Build 24]

 

I fixed the error message complaining about an invalid transaction handle when a long series of calls to ExecSQL were called that were classified as DDL statements. This caused various storage flags to get invalidated and for schema data to be quieried over and over again which revealed a glitch in the code to retrieve the character set information. This bug was introduced fairly recently so it shouldn't affect older versions of IBO.

 

I fixed a bug having to do with parsing SQL that prevented the Filter from working if the statement had a FOR UPDATE clause and ended with a semicolon.

 

I further enhanced the handling of retrieving generator values so that the default behavior would remain the same instead of making it use up a transaction each time a generator value was acquired. But, I added an optional parameter to the Gen_ID() method so that you could pass in NIL for the transaction object which would tell the routine to simply generate its own transaction handle and commit it. This way if you need a generator value that won't be lost in the case of an embedded server crash, this will work.

 

I also added a global variable in the IB_Schema.pas unit:

 

var

  GenValueCrashProof: boolean = false;

 

This forces IBO to always retrieve generator values in a transaction that is committed immediately so that they are totally crash proof.

 

 

11/9/2011 Version 5.0.2 [Build 23]

 

I added get/set methods to override the AsRawString and AsWideString properties for the TIB_ColumnBlob class. It was funnelling the AsRawString and AsWideString properties through the AsString property which caused problems. We simply want a raw dump of the bytes out of the column without any encoding of character set information happening for the AsRawString property.

 

I put a check in the iboDecode() routines for Delphi 7 that detects when this routine fails to provide a value. When it fails, instead of passing back a blank string, I now return the raw bytes.

 

I enhanced the routine to acquire a value from a generator such that it uses a dedicated transaction handle for each request. This was necessary in order to improve the reliability of the embedded server so that if there was a program crash the generator increments would not be lost. For some reason the increments to the generator are not made permanent in the database until the transaction used to acquire it was committed or rolled back.

 

I improved the property editor for the TIB_Connection.DefaultTransaction property. Instead of showing the internal transaction that the connection object creates it will show <blank>.

 

I fixed a bug having to do with the IB_TransForUpdate property in conjunction with the TIB_Connection.DefaultTransaction property being blank and no transaction being assigned to your statement or dataset for either the IB_Transaction property or the IB_TransForUpdate property. When in the process of preparing a statement/query it was possible for some of the column settings (e.g. ReadOnly) to get lost and revert to their defaults until there was a layout change triggered that caused them to be calculated again.

 

11/7/2011 Version 5.0.2 [Build 22]

 

I fixed a problem with event alerters introduced in build 19 when I rewrote the API call to register the events. When using multiple events in a list it was inverting them such that if the first even was triggered then it would indicate that the last one was triggered. If the second one was triggered then it would say the second to last one was triggered. 

 

I enhanced the Fields[] and Params[] array properties such that the statement will be prepared if it is not already prepared when a column object is sought from it. This makes for cleaner code in the application so that you don't have to make an explicit call to Prepare prior to accessing the Fields[] or Params[] property to get at a column object.

 

11/3/2011 Version 5.0.2 [Build 21]

 

I fixed a problem having to do with statements not being assigned an explicit transaction object and then getting an invalid statement handle error when calling ExecSQL. When it would go to get a transaction object during the process of executing the statement it would assign a transaction object and in this process it unprepared the statement leaving it unable to execute. I found that calling unprepare when assigning a new transaction object is not needed so now the statement gets the new transaction object and proceeds to execute without being unprepared.

 

I made some changes in order to get IBO to compile on Free Pascal Compiler/Lazarus again.

 

10/28/2011 Version 5.0.2 [Build 20]

 

I finished up making the TIB_Import component work with Unicode and UTF-8 file formats for input. (Delphi 2009+ only)

 

I split some more of the packages so that there are all runtime and designtime packages. I also split the project group between runtime and designtime.

 

I fixed a parsing bug in the mkLitCriteria() routine in IB_Parse.pas.

 

10/21/2011 Version 5.0.2 [Build 19]

 

I have put extensive work into getting ready for XE2 64-bit support. I created a data type called PointerInt that will give me an integer that matches the size of the pointer being compiled. I used this in all places where a pointer is cast as an integer in order to do pointer math or where pointers are passed as integer parameters to functions. This affected many units that I won't list. I also had to rewrite all routies that relied upon assembler code. In particular, I had to rewrite the way event alerters register events.

 

I had not yet added in the capability to work with IB Togo clients.

 

IB_Export.pas unit was extensively rewritten.

IB_Import.pas unit is yet in the process of being extensively rewritten.

 

I added a number of constants for IB that had not been included in my header unit.

 

I split the RPL, FTS and Admin packages into separate design-time and run-time packages.

I split the project group file into design-time and run-time package group files.

 

10/3/2011 Version 5.0.2 [Build 18]

 

I fixed a problem recently introduced with the handing of connection level property settings for the dataset fields name resolution. I added in the ability to match up column names based upon the name only without the relation name but neglected to also cause it to ignore matches on entries that have a relation name given. The affected routines in IB_ParseEx.pas were GetColParamValueEx() and GetColAttrTxt().

 

I fixed a stack overflow error in Delphi 5 when a TIB_Connection component was added to your form.

 

I fixed a problem with Delphi 6 with regard to the handling of strings. The Delphi 6 compiler was also thrown off by the way I was using typecasting in the iboEncodeX() and iboDecodeX() routines. Because of this there will not be any default UTF8 processing for Delphi 6 as well as Delphi 5. The same goes for the equivalent CPPB versions.

 

I remedied the Version Info in the packages for Delphi/CPPB 5&6 to reflect the current release. I also removed the flag indicating that they were in pre-release mode. Thus, IBO should now be production worthy for Delphi/CPPB 5&6.

 

9/28/2011 Version 5.0.2 [Build 17]

 

I fixed a problem having to do with cached updates in connection with invalidating records. There was a problem that would appear when a record node released its data due to being invalidated and when the cached update was being processed it would raise an error message that was unnecessary.

 

I fixed a problem with calculated fields handling when a record is deleted. In some cases it complained about an invalid bookmark when it should have not raised the exception.

 

I am working out an inconsistency in how earlier versions of Firebird returned prepared column data. When running a query against the metadata it would return the character length instead of the byte length in the API SQLLen parameter. This caused the CharLen to get reduced when it should not have been. This resulted in the values being returned being truncated to a third of its size. I am having to check the specific version of Firebird running and making adjustments to the CharLen that is calculated.

 

Calling SchemaVersionInfo() when there wasn't a table created to hold the SCHEMA_VERSION information would resut in a silent Abort exception being raised. This is undesirable. Rather than raise a silent exception I am simply having it quietly return a totally empty list.

 

I added a line of code in the IB_Editors.pas unit in its unit initialization section to set the global variable CheckForReservedTokens to true so that during design-time there will be proper handling of system reserved tokens (double quotes added to fieldnames that are reserved). What happened before is it defaulted to false but then when an IBF_SQL frmSQL instance was created (e.g. opening connection editor dialog form) it would set it to true. Thus, the IDE seemed to be inconsistent in how it handled reserved tokens.

 

 

8/26/2011 Version 5.0.2 [Build 16]

 

I added 4 properties to the TIB_CheckBox control so that it can function on just a bit or a character of a data field's value. Set the DataOffset property to identify which bit (for numeric columns) or character (string columns) that it should reference. CustomValChecked, CustomValGrayed and CustomValUnchecked allow you to set the single character value that you want to use in the underlying string's character offset.

 

I added 2 properties to the TIB_Edit control so that it can function on just a substring of a data field's value. Set the DataOffset property to tell where the substring starts and set the DataOffsetLen property to tell how many characters long the substring shall be.

 

I fixed an issue where a TIB_ColumnArray object was not getting its PadChar property set correctly. It should use the ASCII #32 (space) character for fixed length string types unless they use the OCTETS charset or their BINARY column attribute is set. I also needed to add proper respect for the PadChar setting inside the SysGetVarArray() routine. There were strings coming from the server with #0 characters in them instead of #32 characters.

 

I fixed a problem in the TIBODataset where if a delete fails and its the last record in the dataset the underlying buffer would get flagged with a row state of rsNone which prevented you from doing an edit on the record, or another delete attempt after the first attempt errored out.

 

8/21/2011 Version 5.0.2 [Build 15]

 

I fixed a parsing problem having to do with using the ORDER BY clause inside of an EXECUTE BLOCK statement. In some cases it was having ASC appended to it which caused the INTO clause to get messed up.

 

I was able to resolve the problem with Delphi/CPPB 5 & 6 where the EXE would produce memory corruptions and problems when code optimization was turned on. This had to do with the routines for encoding and decoding strings. I was using typecasting that the compiler didn't handle correctly. I used compiler directives to separate out Delphi 5 & 6 and removed the typecasts that were problematic.

 

8/11/2011 Version 5.0.2 [Build 14]

 

I fixed a stack overflow error when using InterBase or Firebird version less than 2.1.

 

7/16/2011 Version 5.0.2 [Build 13]

 

I fixed a problem where the record count of a dataset was being executed without making sure it had a physical transaction started first. Passin in a NIL transaction handle to the ExecuteImmediate() API call with a SELECT statement caused a bugcheck condition in Firebird 2.5 that then led to a host of other problems since it wouldn't execute any further commands.

 

7/15/2011 Version 5.0.2 [Build 12]

 

I fixed a parsing problem with the Filter property. It was not properly handling things like (ACOL <> -1). It was splitting the -1 into the - and then treating the 1 separately. It also was not handling the || string concatenation operator. Both instances are now fixed.

 

7/14/2011 Version 5.0.2 [Build 11]

 

I made it so that calling Locate() will not cause fetches to the server looking for records if all fetches have already been performed (fetchall) and a match is not found. Typically I would go ahead and look on the server to see if a new or updated record matching the Locate() criteria was there and then pull it into the buffer. However, this adds a fair amount of overhead when a matching record is not there and especially so if there isn't going to be a new or updated version on the server. Therefore, I have added a new option to the Locate() call with the locate option of lopCheckOnServer.

 

I fixed the problem with TIBODataset reporting the byte length of string columns instead of the character length of the string columns. Of course this only showed up when using character sets that have more than one byte per character.

 

I also added TIBOWideStringField to the registered TField objects in the design-time package registration unit. Somehow I had overlooked this which made it a problem when you wanted to use persistent field definitions.

 

7/13/2011 Version 5.0.2 [Build 10]

 

I improved the behavior of the Schema Cache Table creation logic so that there wouldn't be exceptions raised making debugging an unpleasant process with annoying dialog boxes appearing for predictable errors. I also did the same thing for when the Schema Cache Table is not present when it is looked for.

 

I fixed a problem in the IB_Constants.pas unit for the German Translation.

 

I restored the original behavior of the IndedFieldNames property of TIBOTable to act as it did before to allow you to put with the field name the DESC or ASC operator to indicate whether you wanted ascending or descending sorting on the field. I recently broke this behavior by having the space character serve as a terminator character so that DESC was treated as a separate field name.

 

I improved handling of array columns as input parameters. You need to make the name of the parameter reflect the table and field name of the actual array it is based upon so that the TIB_ColumnArray object can retreive the correct array description data to make use of. You make the paramater name as the :TABLE.COLUMN so if my table was TEST and the column was ARRAYCOL then my parameter would be named :TEST.ARRAYCOL and then it will use the correct descriptors. See BlobInserts sample application for an example of how array data can be inserted via input parameters in a very efficient manner.

 

I also added some additional information to the SQL trace monitor output for array handling.

 

 

7/8/2011 Version 5.0.2 [Build 9]

 

I fixed a problem in the MD5 algorithm that was causing memory to become corrupted and thus various other strange errors. In Delphi 2010 it was causing a stack overflow. In Delphi 5 and 6 it was causing access violations.

 

I fixed a problem in IB_SQL (TIB_UtilityBar) having to do with the DataDump utility. It wasn't preserving the excluded tables and columns properly in the layout's settings. I added two command-line switches to the IB_SQL too in order to tell it to run the DataDump setup for a particular layout. /Layout=<layout name> and /Action=DataDump will cause the datadump to run in the current working directory and then terminate. This is intended for use via automated batch file.

 

 

7/7/2011 Version 5.0.2 [Build 8]

 

I added in a check to make sure a transaction assigned to a statement had the statement's connection assigned to the transaction. This avoids sending an invalid transaction handle for a particular connection to the API. Some versions of the database would crash as a result of this instead of returning an API error.

 

I fixed a bug having to do with an Assert() that checked for data loss of columns in TIBODataset being assigned through the TIBOBlobStream object. It was imposing a length check on Blob columns in an inappropriate manner. They were being limited to 8 bytes in length, which is the length in bytes of the Blob ID. This problem would only show up if asserts were turned on.

 

7/6/2011 Version 5.0.2 [Build 7]

 

I fixed a problem where the ReadOnly property of a TIB_Transaction was causing a dataset to be read-only even though it had a IB_TransForUpdate TIB_Transaction assigned that was not ReadOnly. I had not properly made the ReadOnly property take into consideration that it needed to go off of IB_TransForUpdate when one is assigned.

 

With the addition of the IB_TransForUpdate property it is now possible to have the AutoCommit behavior do a full hard commit instead of just a savepoint, which retains the transaction. So, I added a property called AutoCommitRetains so that you can control which behavior you prefer. It will default to true since that is the existing and expected behavior.

 

I also adjusted things so that all dynamic statement prepare calls will be handled through the connection's schema cache transaction. This should improve the efficiency of transaction usage in the case that many statements can be prepared and awaiting execution and they might not be executed. This makes it so that no additional transaction resources will be required by those statements.

 

I fixed a problem where a TIB_Cursor would return an exception if you called Last when it was already Open. It would try to open the query again and complain about it already being opened.

 

 

7/5/2011 Version 5.0.2 [Build 6]

 

I improved the code that handles the creation of the IBO$SCHEMA_VERSION table so that it uses its own transaction context to do what it needs to do. IN some cases it was failing to create the table properly.

 

I fixed a bug introduced in the previous version that caused a stack overflow upon opening a connection when using SchemaCacheDir.

 

I made it so that when a statement or dataset has IB_Transaction set to nil but the IB_TransForUpdates is set to some explicit value that the statement or dataset will use the connection's internal read-only transaction for non-write operations instead of whatever setting for DefaultTransaction that might be set. The idea here to have it ignore the connection's DefaultTransaction is so that it automatically utilizes a read-only transaction instead so that it is less likely to cause the OAT to get hung up.

 

Added capability to detect when a common table expression is used and improved handling of them. This was to address a bug having to do with CalculatedFields being ignored when a CTE was used in the query. This problem is now fixed.

 

7/1/2011 Version 5.0.2 [Build 5]

 

I included some fixes having to do with getting server defaults posted on Mantis and an issue from the previous build that caused a stack overflow.

 

I included a fix for the MouseDown handing of TIB_Grid with regard to the IndicateRow and IndicateTitles properties and the DblClick method. There was a double-click blindspot in my logic. Thanks to Sven for the fix.

 

Adjusted some things to get rid of needless hints and warnings.

 

Fixed the installer for the eval and regular installation.

 

 

6/2/2011 Version 5.0.2 [Build 4]

 

I improved the logic for showing the source DDL for columns with regard to Character Sets and Collations.

 

I improved the SQL source logic for INT64 columns so that it will take the sqlsubtype into consideration. Now, instead of making everything DECIMAL( 18, x ) it will use BIGINT and NUMERIC( 18, x ) as appropriate.

 

I rewrote the schema cache routine that gets character set information for columns so that it uses all raw API level mechanisms in order to avoid having a race condition during the creation of column objects for higher level queries. I am also including metadata information in this so that metadata queries are properly handled when encoding/decoding.

 

I am taking advantage of the feature in Firebird 2.1+ to put the charset ID and collation ID in the sqlsubtype. This will make a slight performance improvement for prepare time.

 

5/27/2011 Version 5.0.2 [Build 3]

 

I fixed a bug in the TDataset compatible TIBODataset class so that very long string fields will work properly when a value is assigned to them. In some cases it was not retaining the value assigned.

 

I fixed a bug in IB_RPL_Base.pas eliminating the need for FN_BLOBS_EQUAL since in Firebird 2.5 it causes a crash. It is no longer necessary to rely upon a UDF to compare blobs so I put in a check for the server version and eliminated it for Firebird 2.1 and higher.

 

I added TIBOWideStringField class in order to overcome problems with the normal field for versions of Delphi prior to D2006. There were bugs and deficiencies in the standard VCL code I could not overcome otherwise.

 

I fixed a bug having to do with the parsing of Filter values.

 

I added more column related detail to the IB_Monitor output.

 

I fixed a bug where the TIBODataset class would sometimes report an error when using duplicate param names for parameters that were not compatible for being handled as duplicates.

 

5/11/2011 Version 5.0.2 [Build 2]

 

I fixed a bug with incremental searching and NULL values in the mix.

 

I updated the German translation of IB_Constants with a missing item.

 

I updated the list of reserved tokens to include tokens from the various ANSI SQL definitions as well as the recent versions of Firebird and InterBase. Thanks to Thomas Steimaurer (maker of IB Log Manager http://www.upscene.com/products.audit.iblm_main.php) for doing the bulk of this.

 

I fixed some problems in the IB_SQL tool having to do with storing layout information in the registry. When you would do drag and drop of a layout from one group to another it would leave a copy of the layout behind when it should have moved it. Also, under certain circumstances, you could get duplication of layouts and sub-groups. The Query Forms have been broken for most of the beta period and I just discovered it and fixed it. I recently broke the database file searching dialog and fixed it too. This form went through a very rigourous rewrite when it was ported to Lazarus and I am just now getting to the finishing touches.

 

I fixed some bugs in the IB_RPL application (Replication). Thank to Ann Lynnworth of HRef Tools http://www.href.com for her assistance.

 

IB_Directives.inc:

Added the IBO_50_OR_GREATER directive for IBO 5 only. Use of this directive will show up in the IBO 4.9.x  code to make it easier to maintain both versions of code. This will also provide a way to keep track of  what is different functionality-wise between the two versions.

 

IBA_Statement.imp:

Fixed a problem where character set information was being queried from the database for the schema cache  at a point where it was causing problems because it was happening right inside of a query being prepared.  I put a check in the BeforePrepare timing so that it gets the character set info from the database ahead  of time. Thanks to Thomas Steinmaurer for his help with this bug.

 

IBA_BDataset.imp:

Fixed the automatice Refresh that takes please when changing Filtered, FilterOptions or FilterText so  that it will do a a refresh with refresh action of raKeepDataPosOrRowNum regardless of what it is set at.

 

IBA_Dataset.imp:

Enhanced the logic of getting a column's ReadOnly status to respect the IBO_MODIFIABLE attribute for  calculated fields.

 

IBA_Column.imp:

I adjusted how FullFieldName works. I am putting the alias name along with the information from the underlying relation and field. This is  the format: MyRel[MyRelAlias].MyCol[MyColAlias]. The alias is put in square brackets. This behavior is different than in IBO 4.9.x.

 

IB_ParseEx.pas:

Fixed the SQLTokens list to correct the sort order of some items and added more items.

 

Moved some routines out of IBA_Statement.imp to this unit.

 

5/6/2011 Version 5.0.2 [Build 1]

 

I fixed a bug introduced when I changed AnsiCompareStr() and AnsiCompareText() to CompareStr() and CompareText(). It caused the incremental searching to fail when using WIN1250 character set, and presumably other similar character sets.

 

5/4/2011 Version 5.0.1 [Beta 10]

 

I added the ability to set the Filter and Filtered property of TIB_Query in the query editor.

 

I added protection against attempting to assign an invalid bookmark string (hextext rawstring) to a Row's RowData property. This is likely not utilized by many but this could introduce an error message where before it just silently ignored an invalid string.

 

I added a little optimization so that the BySQLNo() lookup of a TIB_Column will go faster in some situations.

 

I fixed a bug having to do with input parameters. I had input parameters that were configured as NOT NULL but this is a problem in some cases. The way I had it is if an assignment of a value was made to an input parameter, it would be coerced to be NULL capable. In the case of master-detail column value assignments, it is very careful to not make any changes to a column/param's value unless there is a difference. Thus, if both columns were showing IsNull = true, there was no assignment made, which is what would have properly coerced the input parameter to allow the NULL to be recognized. My fix was to simply coerce all input parameters to allow NULL and not wait for an actual value assignment to take place.

 

I added more feedback in the SQL trace monitor to help give indication of what the columns are. It will now tell the count and total bytes of VARCHAR columns and the total bytes of CHAR columns.

 

I fixed two parsing bugs. One of them had to do with filter statement processing. The other had to do with the IsLitCriteria() routine falsely detecting.a string of only numbers to be a literal representation when it is not. It was looking for a number like #13 and even though numbers are valid, I neglected to take the requirement of the '#' symbol into consideration.

 

I separated out two new units. They are IB_ParseEx.pas and IB_StringList.pas. They are both part of the core package. You may need to add these units to the uses clause of your application's units. I also split the IB_Components.pas implementation portion into several separate include files. The Delphi IDE was unstable working with a unit so large as IB_Component.pas was. It was 45,000+ lines and 1.6MB. Also, I think it will help with future version control to have things broken out. Obviously this disrupts things some, but I'll take the pain sooner rather than later.

 

I finished the revisions to the horizontal dataset refinement feature I have been working on to increase performace and efficiency, as well as to simplify the code and to eliminate some potential quirks.

Note: This feature is yet only intended for datasets that are not sorted on a column that has null values.

 

I fixed a problem with the setting to adjust the buffers in the connection DPB. I also added two overloaded versions of BuildDPB() method for greater ease to add in DPB items inside the OnCustomDPB event. I also added the information from the DPB to the SQL trace monitor. The password is redacted.

 

 

5/3/2011 Version 5.0.1 [Beta 9]

 

I fixed a problem having to do with string trimming (truncation). By default IBO will automatically, and silently, trim off extra characters that will not fit into the buffer space provided. When using the UTF8 character set the server allocates 4 bytes for every character which would easily store more characters in the storage space than logically intended. Therefore, I need to do character based trimming instead of storage byte based trimming. This is what I have now accomplished.

 

I made a performance tweak to IB_Grid to handle tables with lots of fields better.

 

I started making a UnicodeString avenue to work between visual controls and the data components.

 

I fixed a bug having to do with RDB$xxxxx columns not being recognized as UNICODE_FSS.

 

I significantly reengineered the way horizontal dataset refinement is implemented. I added two additional internal cursors so that statements won't have to get reprepared over and over again as the buffered dataset is worked with. This enabled the code to become simpler as well as it increased the performace of interacting with the dataset. This will make the phase of preparing the query take a little longer because there are additional cursors that need to be prepared, but it allows for a much smoother operation. This also laid the foundation necessary to work with records that have a NULL value in the column that the dataset is sorted by. As it is right now, if horizontal dataset refinement is in effect, no records with NULL in the column being sorted on will appear in some cases. I hope to get this remedied in a future sub-release. It is a rare occasion that you would be using horizontal dataset refinement with NULL values in the column so I do not consider this ultra high priority. If you need this, let me know so I can up its priority.

 

In connection with the above changes, I enhanced the Open() method of TIB_BDataset such that you can pass in the following when calling it:

 

function SysOpen( const ABookmark: RawByteString = '';

                  const ARefineStr: string = '';

                  const ARowNum: integer = Low( integer )): boolean;

 

What will happen is if you pass in a bookmark, it will open the dataset with that bookmark as the selected record. If the bookmark is not found, then it will use the row number provided. The refine string is used for horizontal dataset refinement. This narrows down the subset of records surrounding the desired record so that the query can open and scroll to that record quickly. This is for use when you have configured the OrderingLinks property and the OrderingItemNo is <> 0 and you are using the POS attribute in OrderingLinks.

 

I optimized an aspect of the statement parser so that it would cache a frequently used value instead of parsing the statement each time the property was requested in order to derive the value. In the process of doing this, I added a routine to IB_Parse called GetSQLIsExecuteBlock().

 

I finished up getting array columns working with UTF8 encoding.

 

I got most of the CalculatedFields functionality working with UTF8 encoding. Still more to verify.

 

I made it so that the UtilityBar will close certain windows when there isn't a valid connection.

 

I fixed a bug having to do with the IB_Events component. It caused an error from the server due to registering an empty list of events. I enhanced the component to deal with an empty event list gracefully. It will appear that the component is registered but simply will not send anything to the server. This way, if your program changes the contents of the Events list, they will automatically be detected and registered. This is because I made the Events list able to be changed while it is registered. And, if it is changed, it automatically unregisters the old and re-registers the new. I wanted to keep that ability rather than just forbidding a blank list.

 

4/29/2011 Version 5.0.1 [Beta 8]

 

I fixed a bug in TIB_BDataset.Locate() and added the StartPos parameter so that a search can be limited to only certain rows following a given row.

 

I reworte the TIB_LocateEdit control. It's behavior will be entirely different. I will have more to say when it is finished.

 

I have reworked some things to do with the login and error dialog forms.

 

Lots of code cleanup.

 

 

4/25/2011 Version 5.0.1 [Beta 7]

 

I fixed the handling of the ParamValueLinks properties so that they work better. Instead of giving them a raw binary storage I changed them to a string literal format that will handle control characters without corrupting the string list container.

 

I improved the parsing of the ORDER BY clause so that it wouldn't choke on complex entries.

 

I fixed TIBOLargeIntField to handle the VarValue property.

 

I fixed the problem with AssignSQLWithSearch() for TIBOQuery when the source had master-detail and/or params.

 

I corrected the error messages returned so that they would properly respect the character set.

I also made it so that if the database being connected to has a default character set and there isn't a character set provided by the client that it will adopt the behavior as if it had connected with the database's default character set.

 

I fixed horizontal dataset refinement to work properly with queries that have input parameters.

 

I fixed the AutoLabel problem where font settings in the DFM were getting lost.

 

I cleaned up more Unicode conversion code using the inline procedures I made for this purpose.

 

I fixed the problem where the error "This shouldn't happen 4" would appear.

 

4/22/2011 Version 5.0.1 [Beta 6]

 

I rearranged the work-around code handling of an old InterBase/Firebird bug in the isc_xxx_execute2() api calls to be under a compiler directive instead of a constant. See BUG_EXEC2 in IB_Directives.inc.

 

I fixed the bug in TIB_Currency so that it would function properly without zapping off the decimal places. I actually ended up substantially rewriting it and I added a new property called DeleteClearsText that tells what behavior the Delete key should have. The previous behavior was that when the Delete key was pressed it cleared the whole value. I decided some people may not like that behavior so I added that property in order to disable it and cause it to work like a normal TIB_Edit.

 

I fixed the handling of identifier names in TIBODataset where double quoted identifiers are concerned. It was dropping the double quotes and making the identifier name upper case in some instances. It now properly respects double quoted identifiers and keeps the proper case for the FieldName. This change may cause existing applications with streamed TField definitions to error when the form or module is loading. In this case, you will need to edit your DFM in order to correctly match your column name, including the double quotes, and correcting the case.

 

I fixed a bug in the AsRawString property. It was returning incorrect data for CHAR columns.

 

I fixed a bug in IBF_Browse form. It was not properly querying for references to generators in stored procedure and triggers. I look for it in the BLR using a special string that was not being assembled correctly. I had to fix the AsRawString property in addition to this fix for it to work all the way around.

 

I restored a work-around of an old API call that had bugs. Unfortunately, at least one bug still exists. It has to do with the isc_dsql_exec_immed2() API call. It does not properly handle identifier names that are double quoted. I reported it to the Firebird SQL developers. Hopefully they will fix it. For now it will attempt the API call and if there is an error it will use a dynamic prepare and execute it that way. Thus, it will cause a performance degredation and it will put failed API calls in the SQL trace.

 

I made it so that columns defined with the character set OCTETS will correspond with the field type ftBytes for CHAR and ftVarBytes for VARCHAR for TIBODataset components.

 

I changed the SQL DDL generation for the CreateTable method of the TIBODataset class. Now it will create a CHAR column and VARCHAR column for the ftBytes and ftVarBytes properties. It uses the CHARACTER SET OCTETS for those columns. I also have it include more data on the Blob columns if they are available.

 

I fixed a bug in the ExecuteImmediate2() method that had an improper API setting. For some reason it was hard coded to make the call using SQLDialect 1 instead of 3. Thus, it was rejecting quoted identifiers. Now it works beautifully.

 

Note: There is some work going on to organize the button edit feature of the IB_Edit control so this control might not be stable in the next few releases. Please keep a close eye on this control and especially with its use of the button. I am adding in a new unit called IB_EditButton.pas to accommodate this.

 

 

4/18/2011 Version 5.0.1 [Beta 5]

 

I fixed a bug having to do with BufferSynchroFlags not working in conjunction with cached updates properly. It will synchronize the record just prior to going into edit mode and after the process of committing updates, the records are invalidated if they were edited or inserted so that when they are fetched back into the dataset their fresh values from the server will be acquired.

 

I have started laying the foundation to deal with UTF8 strings in string processing routines. I am using inline functions to encapsulate the various differing string types in a more organized manner.

 

I made some improvements to the schema cache queries to omit information from the system tables.

 

Did more work towards supporting Lazarus.

 

 

4/17/2011 Version 5.0.1 [Beta 4]

 

Fixed the issue where BlankIsNull was not being respected in TIBODataset.

Fixed the issue where BufferSynchroFlags was not being respected by CachedUpdates.

 

 

4/15/2011 Version 5.0.1 [Beta 2&3]

 

Worked on the sample applications and new features.

 

 

4/11/2011 Version 5.0.1 [Beta 1]

 

Fixed a problem where when applying cached updates the AsString, AsInteger, etc. properties were not behaving consistently to reflect the values of the record being processed. Even though you shouldn't use them during the apply updates cycle, and you should use OldValue, NewValue and CurValue, I think the AsXXXX properties should simply return the equivalent of the NewValue consistently. This is now so.

 

Fixed an issue where multiple parameters named the same in a statement were not being combined properly into one parameter object.

 

Fixed logic flaw in the IB_Parse.getStrPos() routine. I was not actually using it anywhere until recently when I discovered it was flawed. If you have made use of this routine in your applications, you will need to verify that you are not relying on the faulty logic.

 

Fixed problems in the IB_Monitor output where wide strings were not being displayed correctly.

 

Fixed an issue of the KeyLinksAutoDefine feature not working properly when the primary key column was an identifier that needed double quotes surrounding it.

 

Fixed an issue in IBOQuery/IBOTable where it wasn't comparing field names correctly in an Assert() so it was erroneously triggering the alert.

 

Initial transfer of source code from IBO 4.9.13 [Beta 16].