<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.

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.

You'll need at least JDK 1.6 for this to work:

<cffunction name="createWRXPath" 
	access="public" 
	returntype="boolean" 
	output="no">
 
	<cfargument name="strPath" 
		type="string" 
		required="yes" 
		hint="an absolute physical path 
		to a directory, not a file">
 
	<cfargument name="iMinDepth" 
		type="numeric" 
		required="no" 
		default="4" 
		hint="minimum depth to set permissions">
 
	<cfscript>
 
		var local = structNew();
 
		local.strPath = GetDirectoryFromPath(
			JavaCast('string',arguments.strPath));
 
		local.objFile = CreateObject('java'
			,'java.io.File').init(local.strPath);
 
		if (arguments.iMinDepth gt 4) {
			local.iMinDepth = arguments.iMinDepth;
			} else {
			local.iMinDepth = 4;			
		} // end if (arguments.iMinDepth gt 4)
 
		// create the path
		local.objFile.mkdirs();
 
		// if that hasn't succeeded, return false
		if (not DirectoryExists(local.strPath)) return false;
 
		local.l = ListLen(local.strPath,'/');
 
		local.strPartPath = '/';
 
		// now descend into the path from top down, 
		//   set permissions for every directory lower 
		//  than level iMinDepth
 
		for (local.i=1; local.i lte local.l; local.i++) {
 
			local.strPartPath &= 
				ListGetAt(local.strPath,local.i,'/') & '/';
 
			if (local.i gte local.iMinDepth) {				
				local.objFile = CreateObject('java'
					,'java.io.File').init(
					    local.strPartPath);
 
				local.objFile.setReadable(TRUE,FALSE);				
				local.objFile.setWritable(TRUE,FALSE);
				local.objFile.setExecutable(TRUE,FALSE);
 
			} // end if (local.i gte local.iMinDepth)
 
		} // end for (local.i=1; local.i lte local.l; local.i++)
 
		return TRUE;
 
	</cfscript>
 
</cffunction>

Example for usage:

<cfscript>	
	variables.strFile  = '/var/www/MYCACHE/123/123456/123456789.cache';
	variables.strPath  = GetDirectoryFromPath(variables.strFile);
	variables.bSuccess = createWRXPath(variables.strPath,4);	
	writeOutput(variables.bSuccess);
</cfscript>

Here's how to reproduce:

<cfset fSource = '/var/www/somepathto/test.jpg'>
<cfimage action="resize" source="#fSource#" destination="#fSource#" overwrite="yes" height="100" width="200" />

This will throw an exception:

An exception occured while trying to write the image. Ensure that the destination directory exists and that Coldfusion has permission to write to the given path or file. cause : java.io.FileNotFoundException: /var/www/somepathto/test.jpg (No such file or directory)

After that, the original file /var/www/somepathto/test.jpg is gone.

We tried to workaround the issue by creating a temporary file and then moving this to the original destination. This doesn't work reliably either:

<cfset fSource = '/var/www/somepathto/test.jpg'>
<cfset fTemp = '/var/www/somepathto/' & createUUID() & '.' & ListLast(fSource,'.')>
<cfimage action="resize" source="#fSource#" destination="#fTemp#" overwrite="yes" height="100" width="200" />
<cffile action="move" source="#fTemp#" destination="#fSource#">

This does sometimes work, sometimes it leaves a stale NFS handle like .nfs0000000000998aa000000 in the directory. Same thing (stale NFS file handles) happens when we copy the file and delete the temporary file with CFFILE.

We didn't use to see this kind of behaviour before the update, so I guess that there must be some kind of correlation. The stale filehandles disappear as soon as the ColdFusion server is being stopped or restarted.

For now we'll probably replace CFIMAGE with calls to ImageMagick - but this is tedious and we'd very much like to continue using CFIMAGE for such tasks.

Any ideas?

UPDATE:We noticed that the issue only affects specific JPG files. ImageMagick doesn't run into issues with any of those files, but CFIMAGE does. We haven't yet found out the exact nature of the problem, but it seems like Adobe Photoshop may be the culprit. Here's one of the files that cause CFIMAGE to throw the exception and delete the file:

Here's another image causing problems.

The first image has Exif data indicating it has been created with Adobe Photoshop CS3, the second bears a similar mark, only this time it's Adobe Photoshop 7.0. A colleague of the graphics artist persuasion has opened and then saved the images in Photoshop as "Web JPG" - these converted files do not show any problems. There is however another option to save images as JPG, or so I am told, which actually produces the broken images. Broken for CFIMAGE, that is, as ImageMagick doesn't complain. So I still see this as a bug in CFIMAGE, and what's more disturbing, it seems to be some incompatibility with Adobe's very own Photoshop, if I am not too much mistaken.

I'd still be very happy if somebody could shed a little more light on the issue, though. Are there any workarounds that allow us to deal with the issue, other than switching from CFIMAGE back to ImageMagick?

UPDATE 2: I think I have now identified the cause of the issue - it seems to be an error in the installation instructions of Cumulative Hotfix 4. See "Installing the hot fixes", Step 2:

2. (Applies only if you are using JDK 1.5, else ignore the step) Do the following:...

What you really should ignore is the bit inside the brackets, or so it seems. After installing hf801-71557, the images that used to cause CFIMAGE to crash are now being processed without any problems.

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)) />

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.

The test subject here is a string of 2848 characters length, pulled from our live article database, which should provide a realistic use case. The JavaCast has already been done, so if we're working with string data that may not be represented by actual Java string objects at the time of access, we may need to account for some additional processing cycles to do the JavaCast in order to be able to use Java methods on it. I ran the tests several times on the same machine, making sure the results where actually reproducable on each run. The tests have been performed on ColdFusion 8 Enterprise running in a 64-bit multi-instance configuration. If you're running CF9, your mileage may vary, though I wouldn't expect the results to point in a very much different direction.

On to the tests.

len() vs. length()

<cftimer type="outline" label="coldfusion len">
	<cfloop from="1" to="10000" index="variables.i">
		<cfset variables.iCfLen = len(variables.strText) />
	</cfloop>
</cftimer>
<cfoutput>#variables.iCfLen#</cfoutput>
 
<cftimer type="outline" label="java length">
	<cfloop from="1" to="10000" index="variables.i">
		<cfset variables.iJLength = variables.strText.length() />
	</cfloop>
</cftimer>
<cfoutput>#variables.iJLength#</cfoutput>

Results: ColdFusion 76ms vs. Java 104ms.

Find() vs. indexOf()

<cftimer type="outline" label="coldfusion find">
	<cfloop from="1" to="10000" index="variables.i">
		<cfset variables.iCfFind = Find('Singularity',variables.strText) />
	</cfloop>
</cftimer>
<cfoutput>#variables.iCfFind#</cfoutput>
 
<cftimer type="outline" label="java indexOf">
	<cfloop from="1" to="10000" index="variables.i">
		<cfset variables.iJindexOf = variables.strText.indexOf('Singularity') />
	</cfloop>
</cftimer>
<cfoutput>#variables.iJindexOf+1#</cfoutput>

Results: ColdFusion 67ms vs. Java 115ms.

& vs. concat()

<cftimer type="outline" label="coldfusion &">
	<cfloop from="1" to="10000" index="variables.i">
		<cfset variables.strCFconcat =  variables.strText & variables.strText/>
	</cfloop>
</cftimer>
 
<cftimer type="outline" label="java concat()">
	<cfloop from="1" to="10000" index="variables.i">
		<cfset variables.strJconcat = variables.strText.concat(variables.strText) />
	</cfloop>
</cftimer>

Results: ColdFusion 120ms vs. Java 172ms.

ReReplace() vs. replaceFirst()

<cftimer type="outline" label="coldfusion ReReplace">
	<cfloop from="1" to="10000" index="variables.i">
		<cfset variables.strCfReReplace = ReReplace(variables.strText,'Singularity','Singularity 2', 'ONE') />
	</cfloop>
</cftimer>
 
<cftimer type="outline" label="java replaceFirst">
	<cfloop from="1" to="10000" index="variables.i">
		<cfset variables.strJreplaceFirst = variables.strText.replaceFirst('Singularity','Singularity 2') />
	</cfloop>
</cftimer>

Results: ColdFusion 331ms vs. Java 228ms.

ReReplace() vs. replaceAll()

<cftimer type="outline" label="coldfusion ReReplace">
	<cfloop from="1" to="10000" index="variables.i">
		<cfset variables.strCfReReplace = ReReplace(variables.strText,'Singularity','Singularity 2', 'ALL') />
	</cfloop>
</cftimer>
 
<cftimer type="outline" label="java replaceAll">
	<cfloop from="1" to="10000" index="variables.i">
		<cfset variables.strJreplaceFirst = variables.strText.replaceAll('Singularity','Singularity 2') />
	</cfloop>
</cftimer>

Results: ColdFusion 543ms vs. Java 629ms.

Conclusion

There seems to be a certain overhead involved in using the underlying Java methods instead of the build-in ColdFusion functions (or operators in case of the &). The difference is actually not that much, and depending on the data you work on, the Java approach might actually gain the upper hand in some cases.

However, based on these findings I would suggest you stick with ColdFusion for such simple cases; your CFML code will be more independent of the underlying VM (which may even be .NET) and easier to write, too, as most ColdFusion IDEs will not support mixed code completion for both CFML and Java.

This is no reason not to take a look behind the curtain, though. Where Java really shines from a ColdFusion developers view is in solving problems that couldn't be as elegantly solved in plain CFML. For example, you'll be able to implement a buffered stream writer instead of <cffile action="append" />, you'll have java.util.Calendar to do your bidding working with date/time-data, and you'll be able to use a wide range of external Java libraries from within ColdFusion, solving both trivial and most complex problems without you doing all the legwork coding the solutions.

On the other hand, when you actually have discovered some of the gems that are hidden in the Java foundation of ColdFusion, don't just blindly adopt everything you find there. You still need to do some testing to find the tool that fits your needs best.

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.

Here's my testcode:

<cfsetting requesttimeout="120">
 
<cfset variables.iStart = getTickCount() />
<cfset variables.strMyDS = 'myMysqlDB' />
 
<cffunction name="doCheckQuery" output="yes" returntype="void">
	<cfset var qCheckDB = ''>
	<cftry>
		<cfquery name="qCheckDB" datasource="#variables.strMyDS#">
			SELECT now();
		</cfquery>
		<cfdump var="#qCheckDB#">
		<cfcatch type="any">
			<cfoutput>
			#getTickCount()-variables.iStart# ms
			</cfoutput>
			<br />
			<cfdump var="#CFCATCH#">
			<cfabort>
		</cfcatch>
	</cftry>
</cffunction>
 
<cfscript>
	doCheckQuery();
	sleep(10000);
	doCheckQuery();
</cfscript>

In a perfect world, there's just nothing here that could go wrong, right? Okay, as long as the sleep-statements remains at something like under 15 seconds, output is as expected:

As soon as the sleep time is longer than 15 seconds, the second query fails. The exact time is somewhat inconclusive, sometimes 15000ms does work, sometimes it doesn't. 10 seconds seems to always work, whereas 20 seconds seems to always fail.

The stack trace shows the cause of the error to be a java.lang.NullPointerException:

java.lang.NullPointerException
	at com.mysql.jdbc.Statement.setMaxRows(Statement.java:2178)
	at coldfusion.server.j2ee.sql.JRunStatement.setMaxRows(JRunStatement.java:214)
	at coldfusion.sql.Executive.executeQuery(Executive.java:1276)
	at coldfusion.sql.Executive.executeQuery(Executive.java:1008)
	at coldfusion.sql.Executive.executeQuery(Executive.java:939)
	at coldfusion.sql.SqlImpl.execute(SqlImpl.java:325)
	at coldfusion.tagext.sql.QueryTag.executeQuery(QueryTag.java:831)
	at coldfusion.tagext.sql.QueryTag.doEndTag(QueryTag.java:521)
...

Funny thing is that we already do use MySQL with ColdFusion - connecting to version 5.0.51a-19~bpo40+1-log doesn't seem to suffer from the same symptoms.

After spending some time with Google I found this Thread "[CF8] java.lang.NullPointerException" on the Adobe Support forums.

Unfortunately none of the suggestions in there has helped us with the issue. I tried to create the datasource with both the MySQL 4/5 option and the "other" option using a JDBC URL. I tried switching "Maintain Connections" on and off - neither does make a difference. I tried adding &autoReconnectForPools=true&zeroDateTimeBehavior=convertToNull to the JDBC-URL like this:

jdbc:mysql://123.123.123.123:3306/mytestdb?prepareThreshold=3&charSet=UTF-8&autoReconnectForPools=true&zeroDateTimeBehavior=convertToNull

Doesn't help either. I replaced the mysql-connector-java-commercial-5.0.5-bin.jar that came with CF8 with the latest mysql-connector-java-5.1.12-bin.jar, restarted the instance, checked the classpath and tried again - same outcome.

The wait_timeout on the MySQL server is currently set to 60 (i.e. 60 seconds), which leads me to believe that this isn't the cause of the issue either - as do some posts of people who have tried to increase the value without any positive effect.

Now upgrading all of our CF8 servers to CF9, though a compelling idea it might be, is just not an option, especially when the latest post in the aforementioned thread seems to suggest that the supposed bug fix in CF9 just reveals some underlying bug that might or might not be an issue for us, too.

Could anyone share their experiences with accessing a MySQL 5.1 DB from CF 8? What did you do, which version of the JDBC driver did you use, which version of MySQL are you using, which connection parameters do you set in your JDBC URL?

Any help on this would be greatly appreciated!

UPDATE: After some further experimenting on this issue, I stumbled over a misconception on my behalf; I thought I had checked the wait_timout setting on the affected MySQL server:

mysql>  show variables where variable_name like 'wait_timeout';
+---------------+-------+
| Variable_name | Value |
+---------------+-------+
| wait_timeout  | 60    |
+---------------+-------+
1 row in set (0.00 sec)

So I couldn't exactly draw the line between the 60 seconds here and the 15 seconds problem found with my sample code. Now show variables in fact shows session variables, not the global setting. I don't know exactly what the "session variable" wait_timeout means exactly, I suspect nothing much, because the global variable actually wins, but here's how to determine the real setting:

mysql>  SELECT @@GLOBAL.wait_timeout;
+-----------------------+
| @@GLOBAL.wait_timeout |
+-----------------------+
|                    15 |
+-----------------------+

Ooookay - here are my 15 seconds. Now what I think happens here is that MySQL just closes the connection after 15 seconds of inactivity and ColdFusion/Jrun doesn't notice. Instead of removing the dead connection from the connection pool, it stays there zombified, ready to jump the next request with a null pointer exception.

The easiest workaround, and the one which we'll choose for now because I have actually tested it, is to set the value to something higher than 1200 seconds in your my.cnf like this:

[mysqld]
...
wait_timeout = 1300

... and restart the MySQL server. The default connection timeout in ColdFusion ist 1200 seconds, so if you set the value higher, you should be safe. I couldn't reproduce the error with my 5.1.48-MySQL text server after setting it to 1500, so I assume that this does in fact do the trick.

If for some reason you cannot change the MySQL timeout setting, you may have some luck changing the setting on the ColdFusion server side. To do so, you need to find and manually edit your neo-datasource.xml where all the datasources are configured; in a multi-instance configuration this file would be located at {jrun-dir}/servers/{instance-name}/cfusion.ear/cfusion.war/WEB-INF/cfusion/lib/neo-datasource.xml, in a standalone install you'll find it under {cf-dir}/lib/neo-datasource.xml.

You'd better use an XML editor that doesn't mess with the code and make a backup of the file before fiddling with the settings in there!

When you open that file, search for the datasource element that contains the configuration for the affected datasource. There you will find a snippet that looks like this:

<var name='timeout'>
  <number>1200.0</number>
</var>

Stop the ColdFusion-server/instance, change the timeout-setting here to some value less than that of your MySQL server's wait_timeout, restart the server/the instance and hope for the best - because I haven't tried that one yet and I don't know if it would have some negative impact in performance or stability of ColdFusion.

What I do know though is that if you decide to edit this file manually, you cannot ever use the ColdFusion administrator to change any settings of the changed datasource without the risk that ColdFusion will then overwrite your custom setting with the built-in default. So as I said before: Changing the settings on the MySQL server side just makes more sense if that is an option for you.

<cffunction name="CF2UnixTS" access="public" output="no" returntype="numeric"
	hint="calculates a Unix Timestamp from a DateTime value">
	<cfargument name="tsTheDate" type="date" required="yes">
	<cfscript>
	var local=structNew();
	local.objCalendar = createObject('java'
				,'java.util.Calendar').getInstance();
	local.objCalendar.clear();
	local.objCalendar.set(year(arguments.tsTheDate)
			,month(arguments.tsTheDate)-1
			,day(arguments.tsTheDate)
			,hour(arguments.tsTheDate)
			,minute(arguments.tsTheDate)
			,second(arguments.tsTheDate));
	local.iUnixTS = int(local.objCalendar.getTimeInMillis()/1000);
	return local.iUnixTS;	
	</cfscript>
</cffunction>

Usage example:

<cfscript>
	dtLocal = DateAdd('M',7,now());
	iUnixTS = CF2UnixTS(dtLocal);
	iDateDiff = DateDiff('s',CreateDate(1970,1,1),dtLocal);
</cfscript>
<cfquery name="getTS" datasource="#APPLICATION.strSomeDS#">
	SELECT UNIX_TIMESTAMP(<cfqueryparam cfsqltype="cf_sql_varchar" 
			value="#DateFormat(dtLocal, 'yyyy-MM-dd' ) 
			& ' ' & TimeFormat(dtLocal, 'HH:mm:ss' )#">
			) AS uxts;
</cfquery>
<cfoutput>
	dtLocal : #dtLocal# <br />
	iUnixTS : #iUnixTS# <br />
	getTS.uxts: #getTS.uxts# <br />
	DateDiff: #iDateDiff#
</cfoutput>

This gives me

dtLocal : {ts '2010-12-28 15:33:14'}
iUnixTS : 1293546794
getTS.uxts: 1293546794
DateDiff: 1293550394

The values from the UDF and the one generated by MySQL are the same. The DateDiff-value is off by minus one hour exactly.

Maybe I am doing something overly complicated here. Is there some easier way to get at the Unix timestamp of a date in ColdFusion?

<cffunction name="parse4URL" output="false" access="public" returntype="string" hint="returns a URL safe string">
<cfargument name="string" default="" type="string">
<cfscript>
var returnString = arguments.string;
var InvalidChars = "à,ô,ď,ḟ,ë,š,ơ,ß,ă,ř,ț,ň,ā,ķ,ŝ,ỳ,ņ,ĺ,ħ,ṗ,ó,ú,ě,é,ç,ẁ,ċ,õ,ṡ,ø,ģ,ŧ,ș,ė,ĉ,ś,î,ű,ć,ę,ŵ,ṫ,ū,č,ö,è,ŷ,ą,ł,ų,ů,ş,ğ,ļ,ƒ,ž,ẃ,ḃ,å,ì,ï,ḋ,ť,ŗ,ä,í,ŕ,ê,ü,ò,ē,ñ,ń,ĥ,ĝ,đ,ĵ,ÿ,ũ,ŭ,ư,ţ,ý,ő,â,ľ,ẅ,ż,ī,ã,ġ,ṁ,ō,ĩ,ù,į,ź,á,û,þ,ð,æ,µ,ĕ,À,Ô,Ď,Ḟ,Ë,Š,Ơ,Ă,Ř,Ț,Ň,Ā,Ķ,Ŝ,Ỳ,Ņ,Ĺ,Ħ,Ṗ,Ó,Ú,Ě,É,Ç,Ẁ,Ċ,Õ,Ṡ,Ø,Ģ,Ŧ,Ș,Ė,Ĉ,Ś,Î,Ű,Ć,Ę,Ŵ,Ṫ,Ū,Č,Ö,È,Ŷ,Ą,Ł,Ų,Ů,Ş,Ğ,Ļ,Ƒ,Ž,Ẃ,Ḃ,Å,Ì,Ï,Ḋ,Ť,Ŗ,Ä,Í,Ŕ,Ê,Ü,Ò,Ē,Ñ,Ń,Ĥ,Ĝ,Đ,Ĵ,Ÿ,Ũ,Ŭ,Ư,Ţ,Ý,Ő,Â,Ľ,Ẅ,Ż,Ī,Ã,Ġ,Ṁ,Ō,Ĩ,Ù,Į,Ź,Á,Û,Þ,Ð,Æ,Μ,Ĕ";
var ValidChars 	 = "a,o,d,f,e,s,o,ss,a,r,t,n,a,k,s,y,n,l,h,p,o,u,e,e,c,w,c,o,s,o,g,t,s,e,c,s,i,u,c,e,w,t,u,c,oe,e,y,a,l,u,u,s,g,l,f,z,w,b,a,i,i,d,t,r,ae,i,r,e,ue,o,e,n,n,h,g,d,j,y,u,u,u,t,y,o,a,l,w,z,i,a,g,m,o,i,u,i,z,a,u,th,dh,ae,u,e,A,O,D,F,E,S,O,A,R,T,N,A,K,S,Y,N,L,H,P,O,U,E,E,C,W,C,O,S,O,G,T,S,E,C,S,I,U,C,E,W,T,U,C,Oe,E,Y,A,L,U,U,S,G,L,F,Z,W,B,A,I,I,D,T,R,Ae,I,R,E,Ue,O,E,N,N,H,G,D,J,Y,U,U,U,T,Y,O,A,L,W,Z,I,A,G,M,O,I,U,I,Z,A,U,TH,Dh,Ae,U,E";
 
// trim the string
returnString = Trim(returnString);
returnString = StripCR(returnString);
// replace known characters with the corresponding safe characters
returnString = ReplaceList(returnString,InvalidChars,ValidChars);
// replace unknown characters in the x00-x7F-range with x's
returnString = returnString.ReplaceAll('[^\x00-\x7F]','x');
 
// Replace one or many comma with a dash
returnString = returnString.ReplaceAll(',+', '-');
// Other substitutions
returnString = Replace(returnString, "%", "percent","ALL");
returnString = Replace(returnString, "&amp;", " and ","ALL");
returnString = Replace(returnString, "&", " and ","ALL");
returnString = returnString.ReplaceAll('[:,/]', '-');
// Replace one or more whitespace characters with a dash
returnString = returnString.ReplaceAll('[\s]+', '-');
// And everything else simply has to go
returnString = returnString.ReplaceAll('[^A-Za-z0-9\/-]','');
// finally replace multiple dash characters with just one
returnString = returnString.ReplaceAll('-+','-');
// we're done
return returnString;
</cfscript>
</cffunction>

This should probably cover most of your needs if you need to deal with European languages.

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.

At the time of writing this article, the current version of Sphinx is 0.9.9-release. I assume you intend to deploy the Sphinx server on a Linux box (I'm using Debian Lenny) and are familiar with compiling code - if you're on Windows, you should get the binary distribution and see docs for installation.

The server you'll want to run Sphinx may or may not be the same as your ColdFusion box, though I'd recommend you set up a separate machine with a generous amount of RAM - Sphinx will store indexes completely in memory which explains the amazing search speed, so the more data you wish to index, the more RAM you should provide.

Next page: Compiling Sphinx