function isNumber( sStr )
{
    return LSisNumeric( sStr ) AND sStr EQ Val( sStr );
}

This was called 6468 times (33 cols, 196 rows, once for each cell). The job took 766ms. Simply changing it to:

function isNumber( sStr )
{
    return LSisNumeric( sStr ) AND Not Compare( sStr, Val( sStr ) );
}

…dropped the time to 501ms.

<cfscript>
     for (i=1; i lt 250000; i=i+1) {
          x = i;
     }
</cfscript>

<cfscript>
     var tick = 0;
     var i = 0;
     var x = 0;
     var top = 250000;
     for (i=1; Compare(i, top); i=IncrementValue(i) ) {
          x = i;
     }
</cfscript>

The second loop applies the 3 best practices of using VAR, Compare() and IncrementValue(). Guess what the runtimes are? ~980ms for the first loop, but only 63ms for the second loop!

<cfscript>
    //Determines whether a datetime string contains only date data
    function isDateOnly( sStr )
    {
        try {
            ts    = ParseDateTime( sStr );
            dte    = ParseDateTime( DateFormat( sStr, "MM/DD/YYYY" ) );
            return Not DateCompare( ts, dte );
        } catch( Any e ) {
            return false;
        }
    }

    //Determines whether a datetime string contains only time data
    function isTimeOnly( sStr )
    {
        try {
            ts    = ParseDateTime( sStr );
            tme    = ParseDateTime( TimeFormat( sStr, "HH:mm:ss.l" ) );
            return Not DateCompare( ts, tme );
        } catch( Any e ) {
            return false;
        }
    }

    // Replacement for isNumeric(), since Assert( isNumeric( "100E4" ) )
    // With this, you can Assert( Not isNumber("100E4") ) and Assert( Not isNumber("10200,10300") )
    function isNumber( sStr )
    {
        return LSisNumeric( sStr ) AND Not Compare( sStr, Val( sStr ) );
    }

    Application.isDateOnly = isDateOnly;
    Application.isTimeOnly = isTimeOnly;
    Application.isNumber = isNumber;
</cfscript>

Later used by

<cfscript>
    function generateClassForExcel( sCellData )
    {
        if(         Application.isNumber( sCellData )    )    return "class=""gen"" x:num";    // hack: adds the x:num attribute to the td
        else if(    Application.isDateOnly( sCellData )    )    return "class=""dt""";
        else if(    Application.isTimeOnly( sCellData )    )    return "class=""tm""";
        else if(     isDate( sCellData )                )    return "class=""dttm""";
        return "class=""txt""";
    }

    function writeTable( qQuery )
    {
        writeOutput("<table>" & chr(13) );
        for( r = 1; r LTE qQuery.RecordCount; r++ )
        {
            writeOutput( "<tr>" & chr(13) );
            for( c = 1; c LTE ListLen(qQuery.ColumnList); c++ )
                writeOutput("<td #generateClassForExcel(qQuery[c][r])#>#qQuery[c][r]#</td>#chr(13)#");
            writeOutput( "</tr>" & chr(13) );
        }
        writeOutput("</table>" & chr(13) );
    }
</cfscript>

Using the above code for a 33 col x 196 row query took +200 seconds. So I performed some optimizations.
Here are the steps I took to optimize the code, and how the stats changed as I went:

Here is what the final optimized code looked like:

function generateCellWithClass( sCellData )
{
    var ts        = "";
    var dte        = "";
    var tme        = "";

    if( Not Compare( sCellData, Val( sCellData ) ) )
        return "<td class=""gen"" x:num>" & sCellData & "</td>";

    else if( isDate( sCellData ) )
    {

        ts        = ParseDateTime( sCellData );
        dte        = ParseDateTime( DateFormat( sCellData, "MM/DD/YYYY" ) );
        if(    Not DateCompare( ts, dte ) )
            return "<td class=""dt"">" & sCellData & "</td>";

        tme        = ParseDateTime( TimeFormat( sCellData, "HH:mm:ss.l" ) );
        if(    Not DateCompare( ts, tme ) )
            return "<td class=""tm"">" & sCellData & "</td>";

        return "<td class=""dttm"">" & sCellData & "</td>";

    }

    return "<td>" & sCellData & "</td>";

}

function writeTable( qQuery )
{
    var rowLimit = qQuery.RecordCount + 1;
    var colLimit = ArrayLen( qQuery.getColumnList() ) + 1;

    writeOutput("<table>" & chr(13) );
    for( r = 1; Compare( r, rowLimit ); r++ )
    {
        writeOutput( "<tr>" & chr(13) );
        for( c = 1; Compare( c, columnLimit ); c++ )
            writeOutput(generateCellWithClass(qQuery[c][r] & chr(13) );
        writeOutput( "</tr>" & chr(13) );
    }
    writeOutput("</table>" & chr(13));
}

Notice that there are no scopes, everything is calculated locally, and the code more efficiently walks the decision tree. It’s also a lot shorter.

Using the optimized version took only 187ms for the exact same 33×196 query!! From 215 seconds to 187ms…that’s a factor of what, 1150 times faster?

<cfobject>
    <cfscript>
        variables.generateCellWithClass = Application.generateCellWithClass; // copy the global function as a local instance
        function writeTable( qQuery )
        {
            ...
            generateCellWithClass(...);
            ...
        }
    </cfscript>
</cfobject>

Now writeTable() can call generateCellWithClass() without a scope name, gaining most of the optimization back.

<cffunction
    name="TableToQuery"
    returnType="query"
    output="false"
    hint="Convert a a flat delimited table (as a string) to a cfquery object."
    >
    <!--- ARGUMENTS --->
    <cfargument name="sTableData" type="string">
    <cfargument name="sColDelim" type="string" default="#chr(9)#">
    <!--- OPTIONAL ARGUMENTS --->

    <!--- BODY --->
    <cfscript>

        sCRLF = chr(13) & chr(10);

        // Replace alternate row delimiters with our default
        sTableData = Replace( sTableData, "#chr(13)##chr(10)#", "¶", "ALL" );
        sTableData = Replace( sTableData, "#chr(13)#", "¶", "ALL" );
        sTableData = Replace( sTableData, "#chr(10)#", "¶", "ALL" );

        // Replace empty items with a space, so our list functions don't drop them
        sTableData = Replace( sTableData, "#sColDelim##sColDelim#", " #sColDelim# #sColDelim# ", "all" );
        sTableData = Replace( sTableData, "#sColDelim#¶", "#sColDelim# ¶", "all" );
        sTableData = Replace( sTableData, "¶#sColDelim#", "¶ #sColDelim#", "all" );

        // get the columns for the table
        lCols = ListGetAt( sTableData, 1, "¶" );
        qData = QueryNew( Replace( lCols, sColDelim, ",", "all" ) );

        // load the data into the query
        for ( i = 2; i lte ListLen( sTableData, "¶" ); i = i + 1 )

        {
            nCurrRow = i - 1;
            QueryAddRow( qData );

            lRowData = ListGetAt( sTableData, i, "¶" );
            for ( j = 1; j lte ListLen( lRowData, sColDelim ); j = j + 1 )
            {
                sColData = Trim( ListGetAt( lRowData, j, sColDelim ) );
                if( sColData neq "" )
                {
                    // when exporting tab-separated format from Excel, values with double-quotes get escaped
                    // so we have to unescape them
                    sColData = Replace( sColData, '""', '"', "all" ); // remove double-quotes
                    if( Left( sColData, 1 ) eq '"' and Len( sColData ) gte 2 )
                        sColData = Mid( sColData, 2, Len( sColData ) );
                    if( Right( sColData, 1 ) eq '"' and Len( sColData ) gte 2 )
                        sColData = Mid( sColData, 1, Len( sColData ) - 1 );
                }
                QuerySetCell( qData, ListGetAt( lCols, j, sColDelim ), sColData, nCurrRow );
            }
        }

    </cfscript>
    <!--- RETURN --->
    <cfreturn qData>
</cffunction>

After:

<cffunction
    name="TSVtoQuery"
    returnType="query"
    output="false"
    >
    <!--- ARGUMENTS --->
    <cfargument name="sTableData" type="string">
    <cfargument name="sColDelim" type="string" default="#chr(9)#">
    <!--- OPTIONAL ARGUMENTS --->
    <cfargument name="bForceAllVarchars" type="boolean" default="false"> <!--- fixes errors when CF guesses the wrong data type for a col based on initial rows of data --->

    <!--- BODY --->
    <cfscript>

        var sCRLF            = chr(13) & chr(10);
        var aDataRecords    = 0;                    // sTableData parsed as an array
        var aColData        = 0;                    // aDataRecords[r] parsed as column values
        var qData            = 0;                    // the query we are building

        var aColNames        = 0;                    // Colnames for qData from sTableData
        var rows            = 0;                    // number of rows in sTableData
        var cols            = 0;                    // number of items in aDataRecords[r]
        var r                = 0;                    // row counter
        var c                = 0;                    // col counter
        var i                = 0;                    // general reusable counter

        // Replace alternate row delimiters with our default
        sTableData = Replace( sTableData, "#chr(13)##chr(10)#", "¶", "ALL" );
        sTableData = Replace( sTableData, "#chr(13)#", "¶", "ALL" );
        sTableData = Replace( sTableData, "#chr(10)#", "¶", "ALL" );

        // Replace empty items with a space, so our list functions don't drop them
        // Prep data
        sTableData = Replace( sTableData, "¶#sColDelim#", "¶ #sColDelim#", "all" );
        sTableData = Replace( sTableData, "#sColDelim#¶", "#sColDelim# ¶", "all" );
        sTableData = Replace( sTableData, "#sColDelim##sColDelim#", "#sColDelim# #sColDelim#", "all" );
        if( Left( sTableData, 1) EQ sColDelim )                // Handle the first column is unnamed
            sTableData = " " & sTableData;
        sTableData = Replace( sTableData, '""', '"', "all" ); // Excel escapes double-quotes when exporting: remove these

        // Store our data in an accessible format
        aDataRecords = ListToArray( sTableData, "¶" );        

        // fix up the columns
        aDataRecords[1] = ListChangeDelims( aDataRecords[1], ",", sColDelim );
        i = 1;
        while ( ListFind( aDataRecords[1], " " ) )     // Replace blank col names with a value
        {
            aDataRecords[1] = ListSetAt( aDataRecords[1], ListFind( aDataRecords[1], " " ), "unnamed_col" & i );
            i = IncrementValue( i );
        }
        aDataRecords[1] = ReplaceList( aDataRecords[1], " ,:,',__", "_,_,_,_" ); // column names cannot use these chars
        aColNames= ListToArray( aDataRecords[1], "," );

        // create the query
        if( bForceAllVarchars )
        {
            variables.dual = QueryNew( "" );
            qData = Application.QoQ( "select '' as " & ListChangeDelims( aDataRecords[1], ", '' as " ) & " from dual" );
        }
        else
        {
            qData = QueryNew( aDataRecords[1] );
        }
        QueryAddRow( qData, ArrayLen( aDataRecords ) - 1 );

        // load the data into the query
        rows = ArrayLen( aDataRecords ) + 1; // Convert LEQ to Compare() for performance
        for ( r = 2; Compare(r, rows); r = r + 1 )
        {
            aColData = ListToArray( aDataRecords[r], sColDelim );
            cols = Min( ArrayLen( aColData ), ArrayLen( aColNames ) ) + 1;
            for ( c = 1; Compare(c, cols); c = c + 1 )
                QuerySetCell( qData, aColNames[c], REReplace( aColData[c], "^[\s""]*([\s\S]*?)[\s""]*$", "\1", "ALL" ), r - 1 );
        }

    </cfscript>
    <!--- RETURN --->
    <cfreturn qData>
</cffunction>

Things to note:
• Everything is VAR’d
• Many operations done inside the main loops are moved to the outside
• Loop conditions are pre-evaluated as much as possible, and stored in a local var. Loop conditions use Compare() instead of LEQ, etc.
• Arrays are used instead of Lists. Arrays are indexed: you only have to parse the string once during ListToArray() instead of every time with ListGetAt()
• IF statements for the string manipulations are eliminated by combining everything into a regular expression. If I wanted further optimization, I’d use a Perl-compatible java regexp library, such as www.javaregex.com

You’re wondering the difference, right? I tried an upload with both functions, of 23k rows. The first one never finished, I killed it after 15 minutes. Or maybe it was 30 during lunch. Whatever. The second one runs in 20 seconds!!!