<!--#include file="lib_rsfast_perf.asp"-->
<%
' v06.05
SUB RSfast(byref parmdict)
    IF cmdexec(parmdict)=true THEN
        EXIT SUB
    END IF

    DIM totalstart, totalelapsed,accmdb
    totalstart=timer()

    ' Access database build OLEDB connection string START
    accmdb=lcase(parmdict.item("accdb"))
    If accmdb="" THEN
        ' nothing to do    
    ELSE
        IF instr(accmdb,":")>0 THEN
            ' no reason to map path, they supplied it!
        ELSE
            accmdb=server.mappath(accmdb)
            parmdict.item("accdb")=accmdb
        END IF
        parmdict.item("conn")="PROVIDER=Microsoft.Jet.OLEDB.4.0;DATA SOURCE=" & accmdb & ";"
    END IF

    Call PerfKeyAddUpdate(parmdict)
            
    ' Caching and Data-Fetching START
    Call CachePrep(parmdict)
    Call CachePrepFile(parmdict)

    DIM thedata,thefields, cachedata,CacheIsRelevant, Cachename
    cachename=parmdict.item("cachename")
    parmdict.item("cachegrab")="no"
    parmdict.item("cachebuild")="no"
    CacheIsRelevant=CacheCheck(parmDict)
    SELECT CASE CacheIsRelevant
    CASE False
        Call DataFetch(parmDict,thedata,thefields)
    CASE True
        If application(cachename & "_building")=TRUE THEN
            Call DataFetch(parmDict,thedata,thefields)
        ELSE
            IF cacheExpired(parmDict)=TRUE THEN
                Call CacheBuild(parmDict)
            END IF
            IF cacheEmpty(parmDict)=TRUE THEN
                Call CacheBuild(parmDict)
            END IF
            Call CacheGrab(parmDict,cachedata,thefields)
            thedata=split(cachedata,"#r#" & vbcrlf)
        END IF
    END SELECT

    parmdict.item("querytimeout")=false
    IF response.isclientconnected()=false THEN
        parmdict.item("querytimeout")=true
        Call PerfKeyAddUpdate(parmdict)
        EXIT SUB
    END IF
    
    DIM problemencountered, problemdetails
    problemencountered=false
    If parmdict.item("errornum")<>0 THEN
        problemdetails="error source: " & parmdict.item("errorsource") & "<br>"
        problemdetails=problemdetails & "error #: " & parmdict.item("errornum") & "<br>"
        problemdetails=problemdetails & "error desc:" & parmdict.item("errordesc") & "<br>"
        problemdetails=problemdetails & "error name:" & parmdict.item("errorname") & "<br>"
        response.write problemdetails
        parmdict.item("thiserror")=parmdict.item("errornum")
        'application.contents.remove("errorsdetailed")
        problemencountered=true
    END IF

    If problemencountered=false THEN
        Call DataDisplay(parmDict,thedata,thefields)
    END IF
    IF response.isclientconnected()=false THEN
        parmdict.item("querytimeout")=true
        Call PerfKeyAddUpdate(parmdict)
        EXIT SUB
    END IF
    totalelapsed=timer()-totalstart
    parmDict.item("timetotalms")=totalelapsed*1000

    ' Now calculate further stats
    ' Thanks to Mike "micro-optimization" Shaffer
    parmdict.item("timeopensec")=parmdict.item("timeopenms") \ 1000
    parmdict.item("timequerysec")=parmdict.item("timequeryms") \ 1000
    parmdict.item("timefetchsec")=parmdict.item("timefetchms") \ 1000
    parmdict.item("timedisplaysec")=parmdict.item("timedisplayms") \ 1000
    parmdict.item("timetotalsec")=parmdict.item("timetotalms") \ 1000

    parmdict.item("timeopenmin")=parmdict.item("timeopenms") \ 60000
    parmdict.item("timequerymin")=parmdict.item("timequeryms") \ 60000
    parmdict.item("timefetchmin")=parmdict.item("timefetchms") \ 60000
    parmdict.item("timedisplaymin")=parmdict.item("timedisplayms") \ 60000
    parmdict.item("timetotalmin")=parmdict.item("timetotalms") \ 60000

    Call PerfKeyDataUpdate(parmDict)

    ' reset cache should NEVER remember between calls
    application.contents.remove("cachename")
    application.contents.remove("cachemin")
    application.contents.remove("errorsdetailed")

    response.write vbcrlf & "<!-- RSFAST SUCCESS -->" & vbcrlf
END SUB

SUB Cache2Array(byref parmDict,byref theArray())
    If parmdict.item("debug")=true THEN    
        response.write "Cache2Array called"
        response.flush
    END IF
    ' Now transfer cache to Array
    thearray=split(application(cachename & "_cachedata"),"#r#" & vbcrlf)
END SUB

SUB CacheBuild(parmDict)
    If parmdict.item("debug")=true THEN    
        response.write "<hr>CacheBuild called<br>"
        response.flush
    END IF
    parmdict.item("builtcache")=true
    DIM cachename,cachedata,cachefields
    application(cachename & "_building")=true
    cachename=parmdict.item("cachename")
    
    parmdict.item("cachefetch")=true
    Call DataFetch(parmDict,cachedata,cachefields)
    parmdict.item("cachefetch")=false

    application(cachename & "_cachedata")=cachedata
    application(cachename & "_cachefields")=cachefields
    ' Now Expire The Cache
    ' cachename_cacheExpires
    application(cachename & "_cachecreated")=now()
    application(cachename & "_cachemin")=parmdict.item("cachemin")
    If parmdict.item("debug")=true THEN    
        response.write "Cachecreated=" & application(cachename & "_cachecreated") & "<br>" & "<br>"
        response.write "cachemin=" & application(cachename & "_cachemin") & "<br>"
        response.flush
    END IF
    parmdict.item("cachebuild")="yes"
    application(cachename & "_building")=false
END SUB    

FUNCTION cacheCheck(parmDict)
    ' Returns True/False whether data is cache affected
    DIM cachename
    cachename=parmdict.item("cachename")
    If cachename="" THEN
        cachecheck=False
    ELSE
        cachecheck=True
    END IF
END FUNCTION

FUNCTION cacheEmpty(parmDict)
    If parmdict.item("debug")=true THEN    
        response.write "<hr>CacheEmpty called<br>"
        response.flush
    END IF
    DIM cachename, cachedatakey, cachedata
    cachename=parmdict.item("cachename")
    ' If cache is filled with data, return TRUE
    cachedatakey=cachename & "_cachedata"
    cachedata=application(cachedatakey)
    If cachedata="" THEN
        cacheEmpty=True
    ELSE
        cacheEmpty=False
    END IF
    If parmdict.item("debug")=true AND cacheempty=True THEN    
        response.write "CacheEmpty=TRUE<br>"
        response.flush
    END IF
    If parmdict.item("debug")=true AND cacheempty=False THEN    
        response.write "CacheEmpty=False<br>"
        response.flush
    END IF
END FUNCTION

FUNCTION cacheExpired(parmDict)
    If parmdict.item("debug")=true THEN    
        response.write "<hr>CacheExpired function called<br>"
        response.flush
    END IF


    ' If cache is out of date return TRUE
    DIM whenexpires, cachename, cachemin, cachecreated
    cachename=parmdict.item("cachename")
    cachemin=application(cachename & "_cachemin")
    cachecreated=application(cachename & "_cachecreated")
    whenexpires=dateadd("n",cachemin,cachecreated)
    cacheExpired=false
    
    ' This deals with timebased caches
    If now()>=whenexpires THEN
        cacheExpired=True
    END IF
    ' This deals with Empty Caches
    If cachecreated="" AND cachemin="" THEN
        cacheExpired=False
    END IF


    ' Debug Stuff
    If parmdict.item("debug")=true AND cacheExpired=True THEN    
        response.write "whenexpires=" & whenexpires & "<br>"
        response.write "CacheExpired=TRUE<br>"
        response.flush
    END IF
    If parmdict.item("debug")=true AND cacheExpired=False THEN    
        response.write "CacheExpired=FALSE<br>"
        response.flush
    END IF
END FUNCTION
    

SUB CacheGrab(byref parmDict,byref ParmData,byref parmFields)
    If parmdict.item("debug")=true THEN    
        response.write "<hr>CacheGrab called<br>"
        response.flush
    END IF    
    DIM cachename
    cachename=parmdict.item("cachename")
    parmData=application(cachename & "_cachedata")
    parmFields=application(cachename & "_cachefields")
    parmdict.item("cachegrab")="yes"
END SUB

SUB CachePrep(parmDict)
    If parmdict.item("debug")=true THEN    
        response.write "<hr>CachePrep called<br>"
        response.flush
    END IF
    DIM cachename,cachemin,cachehour,cacheday
    cachename=parmdict.item("cachename")
    IF cachename<>"" THEN
        cachename="rsfast_query_" & parmdict.item("keycurrent")
        parmdict.item("cachename")=cachename
    END IF
    cachemin=parmdict.item("cachemin")
    cachehour=parmdict.item("cachehour")
    cacheday=parmdict.item("cacheday")
    If parmdict.item("debug")=true THEN    
        response.write "cachemin=" & cachemin & "<br>"
        response.write "cachehour=" & cachehour & "<br>"
        response.write "cacheday=" & cachemin & "<br>"
        response.flush
    END IF    
    cachemin=cachemin+(cachehour*60)+(cacheday*1440)
    parmdict.item("cachemin")=cachemin
    If parmdict.item("debug")=true THEN    
        response.write "cachemin TOTAL=" & cachemin & "<br>"
        response.flush
    END IF
    IF cachemin>0 THEN
        cachename="rsfast_query_" & parmdict.item("keycurrent")
        parmdict.item("cachename")=cachename
    END IF    
END SUB

SUB CachePrepFile(parmDict)
    If parmdict.item("debug")=true THEN    
        response.write "<hr>CachePrep File called<br>"
        response.flush
    END IF
    ' Deal with File Based Caches
    DIM accdb, filemodcurrent, filemodnew
    IF accdb="" THEN
        ' nothing to do
    ELSE
        cachename="rsfast_query_" & parmdict.item("keycurrent")
        parmdict.item("cachename")=cachename
        parmdict.item("cacheday")=1
        
        accdb=parmdict.item("accdb")
        accdb=replace(accdb,":","_")
        accdb=replace(accdb,"\","_")
        accdb=replace(accdb,"/","_")
    
        Dim fso, f1
        Set fso = CreateObject("Scripting.FileSystemObject")
        Set f1 = fso.GetFile(strfilename)   
        filemodnow=f1.DateLastModified 
        set fso=nothing
        set f1=nothing
        filemodcurrent=application("rsfast_filecache_" & accdb)    
    
        If parmdict.item("debug")=true THEN    
            response.write "filemodnow=" & filemodnow & "<br>"
            response.write "filemodcurrent=" & filemodcurrent & "<br>"
            response.flush
        END IF    

        ' Dates are different kill the cache
        IF     filemodcurrent<>filemodnow THEN
            application(cachename & "_cachedata")="" 
        END IF
    END IF
END SUB

FUNCTION cmdexec(parmDict)
    If parmdict.item("debug")=true THEN    
        response.write "<hr>CmdExec called<br>"
        response.flush
    END IF
    
    DIM rscmd
    rscmd=parmdict.item("cmd")
    
    DIM appkey,lappkey, appcounter,tempcmdresult
    DIM removeapp(),highcount,counter
    REDIM removeapp(1000)

    SELECT CASE lcase(rscmd)
        CASE ""
            ' nothing to do
            cmdexec=false
        CASE "ver","version"
         parmdict.item("cmd-result")="6.05"
         cmdexec=True
        CASE "cache-empty"
            DIM emptycachename, emptycachedatakey, emptycachedatakeyf
            emptycachename=parmdict.item("cachename")
            emptycachedatakey=emptycachename & "_cachedata"
            emptycachedatakeyf=emptycachename & "_cachefields"
            If emptycachename="" THEN
                parmdict.item("cmd-result")="failed: cachename not supplied"
            ELSE
                application.contents.remove(emptycachedatakey)
              application.contents.remove(emptycachedatakeyf)
                parmdict.item("cmd-result")="success: cache " & emptycachename & " empty now"
            END IF
            cmdexec=true
       CASE "cache-empty-all"
            FOR EACH appkey IN Application.contents
                lappkey=lcase(appkey)
                IF instr(lappkey,lcase("_cachedata"))>0 THEN
                    appcounter=appcounter+1
                    removeapp(appcounter)=appkey
                END IF
                IF instr(lappkey,lcase("_cachefields"))>0 THEN
                    appcounter=appcounter+1
                    removeapp(appcounter)=appkey
                END IF
            NEXT
            redim preserve removeapp(appcounter)
            highcount=ubound(removeapp)
            for counter=0 to highcount
                application.contents.remove(removeapp(counter))
                tempcmdresult=tempcmdresult & removeapp(counter) & "<br>" & vbcrlf
           next
           If appcounter=0 THEN
                   parmdict.item("cmd-result")="Caches non-existent"
               ELSE
                   parmdict.item("cmd-result")="Caches ALL Cleared <br>" & tempcmdresult
               END IF
          cmdexec=true
        CASE "perf-clear"
            FOR EACH appkey IN Application.contents
                lappkey=lcase(appkey)
                IF instr(lappkey,lcase("rsfast_query"))>0 THEN
                    appcounter=appcounter+1
                    removeapp(appcounter)=appkey
                END IF
            NEXT
            redim preserve removeapp(appcounter)
            highcount=ubound(removeapp)
            for counter=0 to highcount
                application.contents.remove(removeapp(counter))
                tempcmdresult=tempcmdresult & removeapp(counter) & "<br>" & vbcrlf
           next
           If appcounter=0 THEN
                   parmdict.item("cmd-result")="Perfdata non-existent"
               ELSE
                   parmdict.item("cmd-result")="PerfData Cleared<br>" & tempcmdresult
               END IF
               
          cmdexec=true
        CASE ELSE
            parmdict.item("cmd-result")="unknown command"
           cmdexec=true
    END SELECT
END FUNCTION


SUB DataDisplay(parmDict, parmData(),parmFields)
    If parmdict.item("debug")=true THEN    
        response.write "<hr>DataDisplay called<br>"
        response.flush
    END IF

    DIM displayst,displayelapsed 
    displayst=timer
    
    If parmdict.item("debug")=true THEN    
        response.write "DataDisplay called<br>"
        response.flush
    END IF

   DIM cellcount,cellspersecond
    DIM template_header,    template_footer
    DIM rowheader,rowfooter,colheader,colfooter
    DIM fieldnull,fieldblank,template
    
    ' used for looping through query results
    DIM alldata, coldisplay,counter,howmany,rsinfo,thename,colcounter
    
    DIM rstemp, conntemp,rowcount,colcount
    
    DIM therow, fldname,fldnumb,fldvalue,fldtemplate
    DIM thisrow, datarow
    DIM whatever
    DIM parmtemplate, parmtemplatename

    parmtemplate=lcase(parmdict.item("template"))
    parmtemplatename=parmdict.item("templatename")
    ' Templates Are Applied As Needed START
    ' Probably need to replace dictionary items ONLY if they don't exist

    template=false
    SELECT CASE parmtemplate
    CASE "list", "listm"
      template_header="<select name='" & parmtemplatename 
      If parmtemplate="listm" THEN
              template_header=template_header & " multiple "
      END IF
      template_header=template_header & "'>"
      rowheader="<option>"
      rowfooter="</option>"
      template_footer="</select><br>"
      fieldnull="&nbsp;"
      fieldblank="&nbsp;"
      template=True
   CASE "table","tablepaged"
      template_header="<table border=1>"
      rowheader="<tr>"
      rowfooter="</tr>"
      colheader="<td>"
      colfooter="</td>"
      template_footer="</table>"
      fieldnull="&nbsp;"
      fieldblank="&nbsp;"
      parmdict.item("colnames")="display"
      template=true
    CASE ELSE
        ' nothing to do
    END SELECT

    IF template=false     THEN
        template_header=parmdict.item("template_header")    
        template_footer=parmdict.item("template_footer")    
        ' Load dictionary items into simple variable to avoid
        ' doing so many times in loop
        rowheader=parmdict.item("template_row_header")
        rowfooter=parmdict.item("template_row_footer")
        colheader=parmdict.item("template_col_header")
        colfooter=parmdict.item("template_col_footer")
        fieldnull=parmdict.item("fieldnull")
        fieldblank=parmdict.item("fieldblank")
    END IF

    ' Page x of x displays may need to appear in header/footer
    template_header=replace(template_header,"{page}",cstr(parmdict.item("page")))
    template_footer=replace(template_footer,"{page}",cstr(parmdict.item("page")))
    template_header=replace(template_header,"{pagemax}",cstr(parmdict.item("pagemax")))
    template_footer=replace(template_footer,"{pagemax}",cstr(parmdict.item("pagemax")))


    DIM highcount
     If parmdict.item("debug")=true THEN    
        response.write "ParmData Array Data=<Br>"
        highcount=ubound(parmData)
        response.write "Parm Data ubound=" & highcount & "<p>"
       for counter=0 to highcount
                  response.write "<b>ParmData(" & counter & ")</b>="
              response.write parmData(counter) & "<br>"
       next
       response.write "<hr>"
        response.write "ParmFields " & parmfields & "<br>"
        response.flush
    END IF
    
    DIM datafields
    datafields=split(parmFields,"#c#")
    
     If parmdict.item("debug")=true THEN    
        response.write "DataFields Data<Br>"
        highcount=ubound(datafields)
        response.write "DataFields ubound=" & highcount & "<p>"
       for counter=0 to highcount
                  response.write "<b>DataFields(" & counter & ")</b>="
              response.write DataFields(counter) & "<br>"
       next
       response.write "<hr>"
       response.write "<b>formatting info</b><br>"
       response.write "template_header=" & server.htmlencode(template_header) & "<br>"
       response.write "template_footer=" & server.htmlencode(template_footer) & "<br>"
       response.write "rowheader="       & server.htmlencode(rowheader)       & "<br>"
       response.write "rowfooter="       & server.htmlencode(rowfooter)       & "<br>"
       response.write "colheader="       & server.htmlencode(colheader)       & "<br>"
       response.write "colfooter="       & server.htmlencode(colfooter)       & "<br>"
       response.write "<hr>"
       for each whatever in parmdict
               IF instr(whatever, "fld_")>0 THEN
                   response.write whatever & "=" & server.htmlencode(parmdict.item(whatever)) & "<br>"
               END IF
       next
       response.write "<hr>"
    END IF

    ' Page x of x displays may need to appear in header/footer
    template_header=replace(template_header,"{page}",cstr(parmdict.item("page")))
    template_footer=replace(template_footer,"{page}",cstr(parmdict.item("page")))

    template_header=replace(template_header,"{pagemax}",cstr(parmdict.item("pagemax")))
    template_footer=replace(template_footer,"{pagemax}",cstr(parmdict.item("pagemax")))

    colcount=ubound(datafields)
    response.write template_header

    If parmdict.item("colnames")="display" THEN
        coldisplay=true
        response.write rowheader
    END IF

    FOR colcounter=0 TO colcount-1
        thename=datafields(colcounter)
        If coldisplay=TRUE THEN
            response.write colheader
            response.write "<b>" & thename & "</b>"
            response.write colfooter
        END IF
    NEXT    
    If coldisplay=TRUE THEN
            response.write rowfooter
    END IF
    
    rowcount=ubound(parmData)
    ' suck display out of cache

' check for field specific formatting
    Dim key, lkey, fieldspecific
    fieldspecific=false
    FOR EACH key IN parmdict
        lkey=lcase(key)
        IF instr(lkey,lcase("fld_"))>0 THEN
            fieldspecific=true
            EXIT FOR
        END IF
    NEXT


IF fieldspecific=True THEN    
    FOR therow=0 TO rowcount-1
        response.write vbcrlf & rowheader
        thisrow=parmdata(therow)
        datarow=split(thisrow,"#c#")
        FOR colcounter=0 TO colcount-1
            fldname=lcase(datafields(colcounter))
            fldvalue=datarow(colcounter)
'            IF trim(fldvalue)="#n#" THEN
'                fldvalue=fieldnull
'            END IF
            IF trim(fldvalue)="" THEN
                fldvalue=fieldblank
            END IF
            
            fldtemplate=parmdict.item("fld_" & fldname)
            If fldtemplate<>"" THEN
                fldvalue=replace(fldtemplate,"{0}",fldvalue)
                response.write fldvalue
            ELSE
                response.write vbcrlf & colheader
                response.write fldvalue
                response.write colfooter & vbcrlf
            END IF
            cellcount=cellcount+1
        NEXT
        response.write rowfooter & vbcrlf
    NEXT
ELSE
    DIM maxcolcount, maxrowcount
    maxrowcount=rowcount-1
    maxcolcount=colcount-1
    FOR therow=0 TO maxrowcount
        response.write vbcrlf & rowheader
        datarow=split(parmdata(therow),"#c#")
        FOR colcounter=0 TO maxcolcount
            'fldname=lcase(datafields(colcounter))
            IF trim(datarow(colcounter))="" THEN
                datarow(colcounter)=fieldblank
            END IF
            response.write vbcrlf & colheader & datarow(colcounter) & colfooter & vbcrlf
            cellcount=cellcount+1
        NEXT
        response.write rowfooter & vbcrlf
    NEXT

END IF
    response.write template_footer    
    
    displayelapsed=timer-displayst

    parmdict.item("timedisplayms")=displayelapsed
    parmdict.item("cellcount")=cellcount    
END SUB


SUB DataFetch(parmDict, parmArray,parmFields)
    on error resume next 
    If parmdict.item("debug")=true THEN    
        response.write "<hr>DataFetch called<br>"
        response.flush
    END IF

    ' used for timing
    DIM openst, openend, openelapsed
    DIM queryst, queryend, queryelapsed
    DIM fetchst, fetchelapsed
    DIM conntemp, rstemp
    
    DIM howmany,counter,thename,tempSTRdata,tempSTR
    Dim tempSTRfields,thefields

    openst = timer
    set conntemp=server.createobject("adodb.connection")
    If parmdict.item("debug")=true THEN    
        response.write "attempting to open connection<br>"
        response.write "conn=" & parmdict.item("conn") & "<br>"
        response.flush
    END IF
    conntemp.open parmdict.item("conn")
    If ErrorDisplay("dsnopen",conntemp,parmDict)=0 THEN
        ' nothing to do
    ELSE
        EXIT SUB
    END IF
    
   openend = timer
   openelapsed = openend - openst

       parmdict.item("timeopenms")=openelapsed

     If parmdict.item("debug")=true THEN    
        response.write "sql=" & parmdict.item("sql") & "<br>"
        response.write "Database Opened in " & openelapsed & "ms<br>"
        response.flush
    END IF
 
    ' If recordset is paged must be opened special
    queryst=timer
    IF cint(parmdict.item("pagesize"))>0 THEN
        set rstemp=Server.CreateObject("ADODB.Recordset")
        aduseclient=3
        rstemp.cursorlocation=aduseclient
        rstemp.cachesize=parmdict.item("pagesize")
        rstemp.open parmdict.item("sql"),parmdict.item("conn")
        rstemp.absolutepage=parmdict.item("page")
        pagemax=cint(rstemp.pagecount)
        parmdict.add "pagemax", pagemax
        paged=true
         If parmdict.item("debug")=true THEN    
            response.write "SQL=" & parmdict.item("sql") & "<br>"
            response.write "Recordset Opened for Paging!<br>"
            response.flush
        END IF
    ELSE
        If parmdict.item("debug")=true THEN    
            response.write "attempting to query data<br>"
            response.write "sql=" & parmdict.item("sql") & "<br>"
            response.flush
        END IF 
        set rstemp=conntemp.execute(parmdict.item("sql"))
    END IF
    If ErrorDisplay("queryexecute",conntemp,parmDict)=0 THEN
        ' nothing to do
    ELSE
        EXIT SUB
    END IF
   queryend = timer
   queryelapsed = queryend - queryst

       parmdict.item("timequeryms")=openelapsed

    fetchst=timer
     If parmdict.item("debug")=true THEN    
        response.write "SQL=" & parmdict.item("sql") & "<br>"
        response.write "Query Executed: " & queryelapsed & "ms<br>"
        response.flush
    END IF
    If rstemp.eof then
        parmdict.item("errorsource")="DataFetch"
        parmdict.item("errordesc")="No records <b>" & parmdict.item("sql") & "</b>" 
        parmdict.item("errornum")=1
        rstemp.close
        set rstemp=nothing
        conntemp.close
        set conntemp=nothing
         If parmdict.item("debug")=true THEN    
            response.write "EOF encountered!" & queryelapsed & "ms<br>"
            response.flush
        END IF
        'exit sub
    end if

    DIM parmtemplate
    parmtemplate=lcase(parmdict.item("template"))
    SELECT CASE parmtemplate
    CASE "list", "listm","table","tablepaged"
      parmdict.item("fieldnull")="&nbsp;"
    CASE ELSE
        ' nothing to do
    END SELECT
    
    ' Now Fill The Array
    ' Rockville#c#MD#c#20849#r#<vbcrlf>
    ' Dallas#c#TX#c#XXXXX#r#<vbcrlf>
    tempSTRdata=rstemp.getstring(,,"#c#","#r#" & vbcrlf,parmdict.item("fieldnull"))


    ' Now Fill The FieldMaps
    ' City#c#State#c#Zip#r#<vbcrlf>
    howmany=rstemp.fields.count
    for counter=0 to howmany-1
        thename=rstemp(counter).name
        tempstr=tempSTR & thename & "#c#"
    next
    tempSTRfields=tempSTR
    rstemp.close
    set rstemp=nothing
    conntemp.close
    set conntemp=nothing    
    If parmdict.item("cachefetch")=true THEN
        parmarray=TempSTRdata
    ELSE
        parmArray=split(tempSTRdata,"#r#" & vbcrlf)
    END IF
    parmFields=tempSTRfields
     If parmdict.item("debug")=true THEN    
        response.write "Data Before Split=<br>" & tempSTRdata & "<hr><br>"
        response.write "Fields Before Split=<br>" & tempSTRfields & "<hr><br>"
        response.flush
    END IF
    fetchelapsed=timer-fetchst
    parmdict.item("timefetchms")=fetchelapsed
END SUB


FUNCTION ErrorDisplay(parmSource,parmConn,parmDict)
    If parmdict.item("debug")=true THEN    
        response.write "<hr>ErrorDisplay called<br>"
        response.flush
    END IF
    ErrorDisplay=0
    DIM errvbs, errdesc
    errvbs=err.number
    errdesc=err.description
    parmdict.item("errorsource")=parmSource
     IF parmdict.item("debug")=true THEN    
        response.write "errvbs=" & errvbs & "<br>"
        response.write "errdesc=" & errdesc & "<br>"
        response.write "parmsource=" & parmSource & "<br>"
        response.flush
    END IF    
    DIM errordetails,customerror
    customerror=false
    If errvbs<>0 THEN
        SELECT CASE errvbs
            CASE -2147467259
                parmdict.item("errordesc")="Bad DSN" 
                parmdict.item("errornum")=2
                errordetails=parmdict.item("conn")
                ErrorDisplay=2
                parmdict.item("errorname")="error_dsn_bad"
            CASE -2147217843
                parmdict.item("errordesc")="Bad DSN Login Info"  
                parmdict.item("errornum")=3
                errordetails=parmdict.item("conn")
                ErrorDisplay=3
                parmdict.item("errorname")="error_dsn_bad_login"
            CASE -2147217865
                parmdict.item("errordesc")="Invalid Object Name"
                parmdict.item("errornum")=4
                errordetails="probably query has wrong table name - SQL= " & parmdict.item("sql")
                ErrorDisplay=4
                parmdict.item("errorname")="error_query_badname"
            CASE -2147217900
              parmdict.item("errordesc")="Bad Query Syntax"
                parmdict.item("errornum")=5
                errordetails=errdesc & " - SQL= " & parmdict.item("sql")
                ErrorDisplay=5
                parmdict.item("errorname")="error_query_badsyntax"
            CASE ELSE
                parmdict.item("errordesc")="VBscript Error #=<b>" & errvbs & "</b>,desc=<b>" & errdesc & "</b>"
                errordetails="n/a"
                ErrorDisplay=1
                parmdict.item("errorname")="error_unexpected"
        END SELECT
    END IF
     IF parmdict.item("debug")=true THEN    
           response.write "parmdict.item(""errordesc"")=" & parmdict.item("errordesc") & "<br>"
            response.write "parmdict.item(""errornum"")=" & parmdict.item("errornum") & "<br>"
            response.write "errordetails=" & errordetails & "<br>"
            response.write "errorDisplay=" & errordisplay & "<br>"
            response.write "parmdict.item(""errordesc"")=" & parmdict.item("errordesc") & "<br>"
    END IF    
    
    Dim errorname
    errorname=parmdict.item("errorname")
    IF rsparms.item(errorname)="" THEN
        ' nothing to do
    ELSE
        customerror=true
        parmdict.item("errordesc")=rsparms.item(errorname)
    END IF

    IF customerror=TRUE THEN
            parmdict.item("errordesc")=    replace(parmdict.item("errordesc"),"{details}",errordetails)
    ELSE
        IF parmdict.item("errorsdetailed")=true THEN    
            parmdict.item("errordesc")=parmdict.item("errordesc") & " details=<b>" & errordetails & "</b>"
        END IF    
    END IF

    DIM howmanyerrors,dberrnum, dberrdesc, dberrdetails, counter
    howmanyerrors=parmConn.errors.count
     IF parmdict.item("debug")=true THEN    
        response.write "howmanyerrors =" & howmanyerrors & "<br>"
        response.flush
    END IF    
    dberrdetails="<b>(details: "
    If howmanyerrors>0 THEN
        FOR counter= 0 TO howmanyerrors
            dberrnum=parmconn.errors(counter).number
            dberrdesc=parmconn.errors(counter).description
            dberrdetails=dberrdetails & " #=" & dberrnum & ", desc=" & dberrdesc & "; " 
       NEXT
       parmdict.item("adoerrornum")=1
       parmdict.item("adoerrordesc")="DB Error " & dberrdetails
    END IF
    'parmdict.item("errornum")=ErrorDisplay    
     If parmdict.item("debug")=true THEN    
        response.write "parmdict(""adoerrornum"")=" & parmdict("adoerrornum") & "<br>"
        response.write "parmdict(""adoerrordesc"")=" & parmdict("adoerrordisc") & "<br>"
        response.write "Leaving ErrorDisplay Function<br>"
        response.write "parmdict(""errornum"")=" & parmdict("errornum") & "<br>"
        response.flush
    END IF
END FUNCTION

%>

<%
' cachebuilds logged properly as of v06.03
SUB PerfKeyAddUpdate(parmDict)
    If parmdict.item("debug")=true THEN    
        response.write "PerfKeyAddUpdate called<br>"
        response.flush
    END IF
    DIM keyquery,keycurrent,keycounter,keycountermax
    
    DIM keyseparate, keyquerynotcached, keyquerycached
    keyseparate="; "
    keyquerycached="cached" & keyseparate & parmdict.item("sql") & keyseparate & parmdict.item("conn")
    keyquerynotcached="notcached" & keyseparate & parmdict.item("sql") & keyseparate & parmdict.item("conn")

    ' Check for FirstQuery ever
    IF application("rsfast_query_1")="" THEN
        application("rsfast_query_1")=keyquerynotcached
        application("rsfast_query_2")=keyquerycached
        application("rsfast_query_max")=2
        keycountermax=2
        keycurrent=1
    ELSE
        ' nothing to do
    END IF
    
    ' See if QueryPair already exists
    keycountermax=application("rsfast_query_max")
    keycurrent=-1
    FOR keycounter=1 TO keycountermax
        IF application("rsfast_query_" & keycounter)=keyquerynotcached THEN
            keycurrent=keycounter
        END IF
        IF application("rsfast_query_" & keycounter)=keyquerycached THEN
            keycurrent=keycounter-1
        END IF        
    NEXT

    ' Query doesn't exist, must add in pairs, i.e.
    ' query_1 is notcached, query2 is cached
    If keycurrent=-1 THEN
        application.lock
        keycountermax=application("rsfast_query_max")
        application("rsfast_query_" & keycountermax+1)=keyquerynotcached
        application("rsfast_query_" & keycountermax+2)=keyquerycached
        application("rsfast_query_max")=application("rsfast_query_max")+2
        keycurrent=keycountermax+1
        application.lock
    END IF
    
    IF parmdict.item("debug")=true THEN    
        response.write "keyquery="      & keyquery & "<br>"
        response.write "keycurrent="    & keycurrent & "<br>"
        response.write "keycounter="    & keycounter & "<br>"
        response.write "keycountermax=" & keycountermax & "<br>"
        response.flush
    END IF
    parmdict.item("keycurrent")=keycurrent
END SUB


SUB PerfKeyDataUpdate(parmDict)
    DIM keycurrent
    keycurrent=parmdict.item("keycurrent")
    IF parmdict.item("debug")=true THEN    
        response.write "keycurrent=" & keycurrent & "<br>"
        response.flush
    END IF

    DIM keycache
    keycache="notcached"
    IF parmdict.item("cachegrab")="yes" THEN
        keycache="cached"
    END IF    
    If parmdict.item("builtcache")=true THEN
        ' I suspect below line/variable can be removed!
        keycache="notcached"
    END IF    
    
    IF keycache="cached" THEN
        keycurrent=keycurrent+1
    END IF    
    
    IF parmdict.item("debug")=true THEN    
        response.write "keycache=" & keycache & "<br>"
        response.write "keycurrent=" & keycurrent & "<br>"
        response.flush
    END IF


    IF parmdict.item("querytimeout")=false THEN
        Call PerfKeyIncrease(parmDict,keycurrent, "_howmany",1)
        Call PerfKeyIncrease(parmDict,keycurrent, "_totalms",parmDict.item("timetotalms"))
        Call PerfKeyIncrease(parmDict,keycurrent, "_openms",parmDict.item("timeopenms"))
        Call PerfKeyIncrease(parmDict,keycurrent, "_queryms",parmDict.item("timequeryms"))
        Call PerfKeyIncrease(parmDict,keycurrent, "_fetchms",parmDict.item("timefetchms"))
        Call PerfKeyIncrease(parmDict,keycurrent, "_displayms",parmDict.item("timedisplayms"))
        Call PerfKeyIncrease(parmDict,keycurrent, "_cellcount",parmDict.item("cellcount"))
    ELSE
        Call PerfKeyIncrease(parmDict,keycurrent, "_timedout",1)
    END IF
    DIM thiserror
    thiserror=parmdict.item("thiserror")
    IF thiserror="" THEN
        ' nothing to do
    ELSE
       Call PerfKeyIncrease(parmDict,keycurrent, "_error_" & thiserror,1)
    END IF
END SUB

SUB PerfKeyIncrease(parmDict,parmkey, parmsuffix, parmValue)
    ' Increase This Key
    dim keylocal, keyavg, keycount
    keylocal="rsfast_query_" & parmkey & parmsuffix
    keycount="rsfast_query_" & parmkey & "_howmany"
    keyavg=keylocal & "_avg"

    IF parmdict.item("debug")=true THEN    
        response.write "keylocal="  & keylocal & "<br>"
        response.write "keycount="  & keycount & "<br>"
        response.write "keyavg="    & keyavg & "<br>"
        response.flush
    END IF

    application.lock
    application(keylocal)=application(keylocal)+parmvalue
    application.unlock
    ' Average This Key
    If application(keycount)>0 THEN
        application(keyavg)=application(keylocal)/application(keycount)
    END IF
END SUB

SUB PerfKeySet(parmkey, parmsuffix, parmValue)
    application("rsfast_" & parmkey & parmsuffix)=parmvalue
END SUB

FUNCTION PerfKeyGrab(parmkey, parmsuffix)
    DIM thiskey
    thiskey="rsfast_query_" & parmkey & parmsuffix
    perfkeygrab=application(thiskey)
END FUNCTION

SUB PerfDisplayAll
    DIM whatever, temp
    For Each whatever in Application.contents
        IF instr(whatever, "rsfast")>0 THEN
            Response.write "<b>" & whatever & "=</b>"
            temp=application.contents(whatever)
            response.write temp & "<br>"
        END IF
    Next 
END SUB


SUB PerfDisplayPretty
    DIM keycounter,keycountermax,perfpad,perfsep,perflb
    perfpad="&nbsp;&nbsp;&nbsp;"
    perfsep="<br><hr><br>"
    perflb="<br>" & vbcrlf
    
    keycountermax=application("rsfast_query_max")
    FOR keycounter=1 TO keycountermax
        response.write "Query #" & keycounter & "<br>"

        response.write perfpad & "Query: <b>"        
        response.write perfkeygrab(keycounter,"") & "</b>" & perflb

        response.write perfpad & "Query Count: <b>"        
        response.write perfkeygrab(keycounter,"_howmany") & "</b>" & perflb

        response.write perfpad & "Query Total ms ave.: <b>"        
        response.write perfkeygrab(keycounter,"_totalms_avg") & "</b>" & perflb

        '    response.write perfpad & "Query Cell Count: <b>"        
        '    response.write perfkeygrab(keycounter,"_cellcount") & "</b>" & perflb

        response.write perfpad & "Query Average Cell Count: <b>"        
        response.write perfkeygrab(keycounter,"_cellcount_avg") & "</b>" & perflb

'        response.write int(perfkeygrab(keycounter,"_cellcount_avg")/(perfkeygrab(keycounter,"_totalms_avg")/1000)) & "</b>" & perflb

        Call PerfDisplayNonZero(keycounter,"_totalms_avg","Cells Per Second: ")
        Call PerfDisplayNonZero(keycounter,"_error_1","Error #1 count:")
        Call PerfDisplayNonZero(keycounter,"_error_2","Error #2 count:")
        Call PerfDisplayNonZero(keycounter,"_error_3","Error #3 count:")
        Call PerfDisplayNonZero(keycounter,"_error_4","Error #4 count:")
        Call PerfDisplayNonZero(keycounter,"_error_5","Error #5 count:")            
        
        response.write perfpad & "Query Timeout Count: <b>"        
        response.write perfkeygrab(keycounter,"_timedout") & "</b>" & perflb
    
        IF response.isclientconnected()=false THEN
            EXIT FOR
        END IF
        response.flush
    NEXT
END SUB

SUB PerfDisplayNonZero(parmcounter,parmwhich,parmMsg)
        dim perflb, perfpad, grabvalue
        perflb="<br>" & vbcrlf        
        perfpad="&nbsp;&nbsp;&nbsp;"
        
        grabvalue=perfkeygrab(parmcounter,parmwhich)
        IF grabvalue>0 THEN
            response.write perfpad & parmMsg & " <b>" & grabvalue & "</b>" & perflb        
            'response.write int(perfkeygrab(parmcounter,"_cellcount_avg")/(perfkeygrab(keycounter,"_totalms_avg")/1000)) & "</b>" & perflb
        END IF
END SUB

SUB PerfDisplay(parmDict)
    dim linebreak
    linebreak="<Br>" & vbcrlf
    
    response.write "cachegrab=" & parmdict.item("cachegrab") & linebreak
    response.write "cachebuild=" & parmdict.item("cachebuild") & linebreak
    
   Response.write "total ms=" &  parmDict.item("timetotalms") & linebreak
   Response.write "open ms=" &   parmDict.item("timeopenms") & linebreak
   Response.write "query ms=" &  parmDict.item("timequeryms") & linebreak
   Response.write "fetch ms=" &  parmDict.item("timefetchms") & linebreak
   Response.write "display ms=" &  parmDict.item("timedisplayms") & linebreak
   Response.write "cellcount=" & parmDict.item("cellcount") & linebreak
   response.write "<hr>"

   Response.write "total sec=" & parmDict.item("timetotalsec") & linebreak
   Response.write "open sec=" &  parmDict.item("timeopensec") & linebreak
   Response.write "query sec=" & parmDict.item("timequerysec") & linebreak
   Response.write "fetch sec=" & parmDict.item("timefetchsec") & linebreak
   Response.write "display sec=" & parmDict.item("timedisplaysec") & linebreak
   response.write "<hr>"

   Response.write "total min=" & parmDict.item("timetotalmin") & linebreak
   Response.write "open min=" &  parmDict.item("timeopenmin") & linebreak
   Response.write "query min=" & parmDict.item("timequerymin") & linebreak
   Response.write "fetch min=" & parmDict.item("timefetchmin") & linebreak
   Response.write "display min=" & parmDict.item("timedisplaymin") & linebreak
   response.write "<hr>"
END SUB


%>