While migrating one of our ColdFusion 8 servers to Railo I stumbled over a small problem with the cftransaction tag today. Consider this snippet of code:
<cftransaction action="begin">
<cftry>
<cfquery name="variables.qTestQuery"
datasource="#variables.strDs#">
SELECT version();
</cfquery>
<cfcatch type="database">
<cftransaction action="rollback">
</cfcatch>
</cftry>
</cftransaction>
Done.
This was running fine on ColdFusion 8.0.1, Railo 3.1.2.019 on the other hand complained:
Start and End Tag has not the same Name [cftransaction-cfcatch]
5: </cfquery>
6: <cfcatch type="database">
7: <cftransaction action="rollback">
8: </cfcatch>
9: </cftry>
The issue is easily resolved - and probably won't hit you as long as you're using a more recent IDE with better Code Assist thank DreamWeaver MX 2004, as this will automatically provide a closing tag for the <cftransaction action="rollback">. To make Railo happy, just use
<cftransaction action="rollback" />
or
<cftransaction action="rollback"></cftransaction>
The version with the self-closing tag makes more sense to me, though ColdFusion Builder will provide you with the latter variation.
The following problem has come up during a file caching implementation: We've got a directory /var/www/MYCACHE; our filecaching mechanism uses a key-based directory structure to store files there. So let's suppose our key would be 123456789, we'd like to store the file 123456789.cache under /var/www/MYCACHE/123/123456/123456789.cache. This would make sure that no directory needs to hold more than 1,000 nodes.
All would be well if we could be sure that the user jrun (i.e. the user that owns our ColdFusion process) was indeed the only user ever to access this directory structure. In our case we want to be able to access this structure with PHP, too, which runs as mod_php on the webserver, thus as user www-data. To avoid permission problems, we want to assign a permission of 0777 to all directories in the structure upon creation.
UPDATE 2: There is actually an issue with ColdFusion Cumulative Hotfix 4, though it's not the Hotfix itself, it's the installation instructions explicitly telling you to skip installing another hotfix if you're not on JVM 1.5. Don't skip installing hf801-71557, even when you're on JVM 1.6 - that has fixed it with our installation.
A quick followup on a previous post ColdFusion UDF to get Unix timestamp from date: Here's a oneliner that provides you with the complimentary function to get a date from a Unix timestamp - as I've discovered that the dateAdd() route mostly recommended on the net not only suffers from being quite clumsy, the result is off by one hour, too - at least when DST is on.
So to get a date from a Unix timestamp in ColdFusion, you can use this oneliner:
<cfset dtMyDate = createObject('java','java.util.Date').init(javaCast('long',iUnixTS*1000)) />
You may know from previous blog posts that I strongly advise every ColdFusion developer to familiarize himself/herself with the thing that actually makes ColdFusion tick, i.e. with Java. Everybody who writes a single line of CFML should know about the possibilities of extending ColdFusion by directly accessing the underlying Java methods of certain objects. One of the datatypes where actually using Java may make a lot of sense is the string object.
ColdFusion string literals are just plain old Java strings. If you grab a string from e.g. a query object like variables.qMyQuery.myTextColumn, you need to be careful though - even if you think you just have one tuple returned, you've got something other than a string object on your hands. In such a case you need to either specifically target a certain row (like variables.qMyQuery.myTextColumn[1]) or you wrap it up in a JavaCast like Javacast('string',variables.qMyQuery.myTextColumn).
I finally found a moment to actually do some benchmarking on some of the built-in ColdFusion functions against their Java counterparts. This is not a benchmark of Java vs. ColdFusion performance, mind you, it's about deciding whether to use Java-methods inside of ColdFusion vs. ColdFusion's built-in string functions.
UPDATE: We have now found the cause of the issue. Please scroll to the end of the article for explanation and workaround.
In one of our latest projects we need to access a MySQL 5.1 server (5.1.45) from ColdFusion 8 (8,0,1,195765). Creating the datasource was no problem, the datasource does verify okay - but there obviously is some bug or incompatibility in ColdFusion that causes the connection to be anything but reliable.
For some legacy MySQL database application I really need Unix timestamps - and I need them in ColdFusion, so MySQL's UNIX_TIMESTAMP just wasn't sufficient for the job. At first I though I could get away with a simple DateDiff - and the result did look plausible. A closer look revealed however that there is probably something fishy going on with DateDiff in ColdFusion. I strongly suspect Daylight Saving Time, though I can't really say at this moment.
This function might be convenient if you need to create a seo-friendly URL from a headline that could contain special characters such as German umlauts or accented letters; spaces would be replaced by dashes as recommended by Matt Cutts of Google. Unrecognized characters in a certain Unicode range will finally be replaced by x's, everything that's still not recognized will simply be dropped.
Full text searching is and probably will be for a long time an interesting challenge for any database driven application. Of course ColdFusion already offers a couple of options, though I found most of them somewhat lacking in features or quite complicated to set up.
As we're running mostly on PostgreSQL as database backend, we used to rely solely on the built-in TSearch2 full text search methods of that database. But over the years we have accumulated so much data, some of which is nicely distributed over several tables (the dark side of normalization), that we were really yearning for a less table based and more document focused indexing mechanism - and more speed than TSearch2 could deliver.
Verity never really quite met all of our needs and was a real pain to set up and maintain. CF 9's Solr, which is based on Lucene, might be a mighty step forward, but we're still running on ColdFusion 8, so I really cannot say a lot about handling and performance of the new indexing beast.
For our use cases (i.e. indexing of articles, products in our CMS as well as our forums), Sphinx (for SQL Phrase Index) has shown some amazing results - and we're using it for a couple of months now. In this article I'll show you how to compile, set up and use Sphinx in your ColdFusion application to retrieve search results from documents stored in a PostgreSQL or MySQL database.