Index: openacs-4/packages/acs-bootstrap-installer/tcl/40-db-query-dispatcher-procs.tcl
===================================================================
RCS file: /usr/local/cvsroot/openacs-4/packages/acs-bootstrap-installer/tcl/40-db-query-dispatcher-procs.tcl,v
diff -u -r1.49.2.4 -r1.49.2.5
--- openacs-4/packages/acs-bootstrap-installer/tcl/40-db-query-dispatcher-procs.tcl	14 Feb 2021 21:08:02 -0000	1.49.2.4
+++ openacs-4/packages/acs-bootstrap-installer/tcl/40-db-query-dispatcher-procs.tcl	22 Feb 2021 14:05:57 -0000	1.49.2.5
@@ -16,21 +16,21 @@
 # The following code allows ad_proc to be used
 # here (a local workalike is declared if absent).
 # added 2002-09-11 Jeff Davis (davis@xarg.net)
-if {[namespace which ad_library] ne "" } { 
+if {[namespace which ad_library] ne "" } {
     ad_library {
         Query Dispatching for multi-RDBMS capability
 
         @author Ben Adida (ben@openforce.net)
         @author Bart Teeuwisse (bart.teeuwisse@thecodemill.biz)
 	@cvs-id $Id$
-    } 
+    }
 }
 
 if { [namespace which ad_proc] ne ""} {
     set remove_ad_proc_p 0
-} else { 
+} else {
     set remove_ad_proc_p 1
-    proc ad_proc {args} { 
+    proc ad_proc {args} {
         # we have to eat flags and then define the proc.
         set count 0
         foreach arg $args {
@@ -44,9 +44,9 @@
         set arglist [lindex $args $count]
         incr count
         set args [lrange $args $count end]
-        # args can be {docs body} {body} {docs -} 
+        # args can be {docs body} {body} {docs -}
         # make sure it is non empty and does not end in -
-        if {[llength $args] && [lindex $args end] ne "-" } { 
+        if {[llength $args] && [lindex $args end] ne "-" } {
             proc $name $arglist [lindex $args end]
         }
     }
@@ -59,29 +59,29 @@
 
 ad_proc -public db_rdbms_create {type version} {
     @return rdbms descriptor
-} { 
+} {
     return [list $type $version]
 }
 
 ad_proc -public db_rdbms_get_type {rdbms} {
     @param rdbms descriptor constructed by db_rdbms_create
 
     @return rdbms name
-} { 
+} {
     return [lindex $rdbms 0]
 }
 
 ad_proc -public db_rdbms_get_version {rdbms} {
     @param rdbms descriptor constructed by db_rdbms_create
 
     @return version identifier
-} { 
+} {
     return [lindex $rdbms 1]
 }
 
 ad_proc -public db_rdbms_compatible_p {rdbms_test rdbms_pattern} {
     @return 0 if test incompatible with pattern, 1 if miscible
-} { 
+} {
     # db_qd_log QDDebug "The RDBMS_TEST is [db_rdbms_get_type $rdbms_test] - [db_rdbms_get_version $rdbms_test]"
     # db_qd_log QDDebug "The RDBMS_PATTERN is [db_rdbms_get_type $rdbms_pattern] - [db_rdbms_get_version $rdbms_pattern]"
 
@@ -101,13 +101,13 @@
 	return 1
     }
 
-    # If the query being tested was written for a version that is older than 
+    # If the query being tested was written for a version that is older than
     # the current RDBMS then we have compatibility. Otherwise we don't.
     foreach t [split [db_rdbms_get_version $rdbms_test   ] "\."] \
 	p [split [db_rdbms_get_version $rdbms_pattern] "\."] {
 	    if {$t != $p} {return [expr {$t < $p}]}
 	}
-    
+
     # Same version (though not strictly "older") is OK
     return 1
 }
@@ -123,56 +123,56 @@
 
 ad_proc -public db_fullquery_create {queryname querytext bind_vars_lst query_type rdbms load_location} {
     FullQuery Data Abstraction Constructor
-} { 
+} {
     return [list $queryname $querytext $bind_vars_lst $query_type $rdbms $load_location]
 }
 
 # The Accessor procs
 
 ad_proc -public db_fullquery_get_name {fullquery} {
     Accessor for fullquery data abstraction
-    @param fullquery datastructure constructed by db_fullquery_create 
+    @param fullquery datastructure constructed by db_fullquery_create
     @return name
 } {
     return [lindex $fullquery 0]
 }
 
 ad_proc -public db_fullquery_get_querytext {fullquery} {
     Accessor for fullquery data abstraction
-    @param fullquery datastructure constructed by db_fullquery_create 
+    @param fullquery datastructure constructed by db_fullquery_create
     @return query text
 } {
     return [lindex $fullquery 1]
 }
 
 ad_proc -public db_fullquery_get_bind_vars {fullquery} {
     Accessor for fullquery data abstraction
-    @param fullquery datastructure constructed by db_fullquery_create 
+    @param fullquery datastructure constructed by db_fullquery_create
     @return bind vars
 } {
     return [lindex $fullquery 2]
 }
 
 ad_proc -public db_fullquery_get_query_type {fullquery} {
     Accessor for fullquery data abstraction
-    @param fullquery datastructure constructed by db_fullquery_create 
+    @param fullquery datastructure constructed by db_fullquery_create
     @return query type
 } {
     return [lindex $fullquery 3]
 }
 
 ad_proc -public db_fullquery_get_rdbms {fullquery} {
     Accessor for fullquery data abstraction
-    @param fullquery datastructure constructed by db_fullquery_create 
+    @param fullquery datastructure constructed by db_fullquery_create
     @return rdbms descriptor
 } {
     return [lindex $fullquery 4]
 }
 
 ad_proc -public db_fullquery_get_load_location {fullquery} {
     Accessor for fullquery data abstraction
-    @param fullquery datastructure constructed by db_fullquery_create 
-    @return load location 
+    @param fullquery datastructure constructed by db_fullquery_create
+    @return load location
 } {
     return [lindex $fullquery 5]
 }
@@ -218,7 +218,7 @@
 ################################################
 
 ad_proc -public db_qd_load_query_file {file_path {errorVarName ""}} {
-    A procedure that is called from the outside world (APM) 
+    A procedure that is called from the outside world (APM)
     to load a particular file
 } {
     if {$errorVarName ne ""} {
@@ -246,7 +246,7 @@
 
 ad_proc -public db_qd_get_fullname {local_name {added_stack_num 1}} {
     Find the fully qualified name of the query
-} { 
+} {
     # We do a check to see if we already have a fullname.
     # Since the DB procs are a bit incestuous, this might get
     # called more than once. DAMMIT! (ben)
@@ -287,12 +287,12 @@
         #   if {[catch {db_qd_log QDDebug "the ad_conn file is [ad_conn file]"} errmsg]} {}
         # }
 
-	# Now we do a check to see if this is a directly accessed URL or a 
+	# Now we do a check to see if this is a directly accessed URL or a
         # sourced URL
 
-        # added case for handling .vuh files which are sourced from 
-        # rp_handle_tcl_request.  Otherwise, QD was forming fullquery path 
-        # with the assumption that the query resided in the 
+        # added case for handling .vuh files which are sourced from
+        # rp_handle_tcl_request.  Otherwise, QD was forming fullquery path
+        # with the assumption that the query resided in the
         # rp_handle_tcl_request proc itself. (OpenACS - DanW)
 
         switch $proc_name {
@@ -353,23 +353,23 @@
 	# Get the first word, which is the Tcl proc
 	regexp {^([^ ]*).*} $proc_name all proc_name
 
-        # check to see if a package proc is being called without 
+        # check to see if a package proc is being called without
         # namespace qualification.  If so, add the package qualification to the
-        # proc_name, so that the correct query can be looked up. 
+        # proc_name, so that the correct query can be looked up.
         # (OpenACS - DanW)
 
         set calling_namespace [string range [uplevel [expr {1 + $added_stack_num}] {namespace current}] 2 end]
         # db_qd_log QDDebug "calling namespace = $calling_namespace"
 
-        if {$calling_namespace ne "" && 
+        if {$calling_namespace ne "" &&
             ![string match "*::*" $proc_name]} {
             set proc_name ${calling_namespace}::${proc_name}
         }
 	# db_qd_log QDDebug "proc_name is -$proc_name-"
 
-	# We use the ad_proc construct!! 
+	# We use the ad_proc construct!!
 	# (woohoo, can't believe that was actually useful!)
-	
+
 	# First we check if the proc is there. If not, then we're
 	# probably dealing with one of the bootstrap procs, and so we just
 	# return a bogus proc name
@@ -402,14 +402,14 @@
     }
 
     # db_qd_log QDDebug "generated fullname of $full_name"
-    
+
     # The following block is apparently just for debugging
     # aks - making debug output actually usable
     # if {[llength $proc_name] > 1} {
     #     set proc_name_with_parameters "[lindex $proc_name 0] "
     #     set i 1
     #     foreach parameter [lrange $proc_name  1 end] {
-    #         append proc_name_with_parameters "parameter$i: $parameter " 
+    #         append proc_name_with_parameters "parameter$i: $parameter "
     #         incr i
     #     }
     # } else {
@@ -426,15 +426,15 @@
     This procedure returns the latest FullQuery data structure
     given proper scoping rules for a complete/global query name.
     This may or may not be cached, the caller need not know.
-} { 
+} {
     # For now we consider that everything is cached
     # from startup time
     return [db_qd_internal_get_cache $fullquery_name]
 }
 
 ad_proc -public db_qd_replace_sql {statement_name sql} {
     @return sql for statement_name (defaulting to sql if not found)
-} { 
+} {
     set fullquery [db_qd_fetch $statement_name]
 
     if {$fullquery ne ""} {
@@ -451,9 +451,9 @@
 }
 
 ad_proc -public db_map {snippet_name} {
-    fetch a query snippet.  used to provide db-specific query snippets when 
+    fetch a query snippet.  used to provide db-specific query snippets when
     porting highly dynamic queries.  (OpenACS - DanW)
-} { 
+} {
     set fullname [db_qd_get_fullname $snippet_name]
     set fullquery [db_qd_fetch $fullname]
     set sql [db_fullquery_get_querytext $fullquery]
@@ -470,7 +470,7 @@
     is the one against which compatibility will be checked.
 
     NOTE: not complete -- should return something depending on compatibility of RDBMSs
-} { 
+} {
     set query_rdbms [db_fullquery_get_rdbms $fullquery]
 
     # NOTE: not complete
@@ -481,7 +481,7 @@
 
 ######################################################
 #
-# Utility Procedures 
+# Utility Procedures
 # (these are *not* to be called by code other than
 # the above)
 #
@@ -498,7 +498,7 @@
     used by the APM to determine when a package should be reloaded.  This
     code depends on the file tag parameter being set to the actual file path
     to the query file.
-} { 
+} {
     # While there are surely efficient ways of loading large files,
     # we're going to assume smaller files for now. Plus, this doesn't happen
     # often.
@@ -513,7 +513,7 @@
 
     # Iterate and parse out each query
     set parsing_state [db_qd_internal_parse_init $whole_file $file_tag]
-    
+
     # We need this for queries with relative paths
     set acs_file_path [ad_make_relative_path $file_tag]
     set queryname_root [db_qd_internal_get_queryname_root $acs_file_path]
@@ -522,7 +522,7 @@
 
     while {1} {
 	set result [db_qd_internal_parse_one_query $parsing_state]
-	
+
 	# db_qd_log QDDebug "one parse result -$result-"
 
 	# If we get the empty string, we are done parsing
@@ -564,7 +564,7 @@
 
 ad_proc -private db_qd_internal_get_cache {fullquery_name} {
     Load from Cache
-} { 
+} {
     # If we have no record
     if {![nsv_exists OACS_FULLQUERIES $fullquery_name]} {
 	return ""
@@ -590,14 +590,14 @@
 
 ad_proc -private db_qd_internal_store_cache {fullquery} {
     Store in Cache.  The load_location is the file where this query was found.
-} { 
+} {
 
     # Check if it is compatible at all!
     set rdbms [db_fullquery_get_rdbms $fullquery]
     if {![db_rdbms_compatible_p $rdbms [db_current_rdbms]]} {
         # The query isn't compatible, probably because of a too high version
         ns_log Warning "Query [db_fullquery_get_name $fullquery] has rdbms info $rdbms which is not compatible with system rdbms [db_current_rdbms]"
-        return 
+        return
     }
 
     set name [db_fullquery_get_name $fullquery]
@@ -623,7 +623,7 @@
     # in case they are not all replaced by reloading that file. That is nasty! Oh well.
 
     # We'll do this later
-    
+
     # we just reparse the file
     set stream [open $file_path "r"]
     db_qd_internal_load_queries $stream $file_path
@@ -637,7 +637,7 @@
 
 ad_proc -private db_qd_internal_get_queryname_root {relative_path} {
     @return relative path with trailing .
-} { 
+} {
     # remove the prepended "/packages/" string
     regsub {^\/?packages\/} $relative_path {} relative_path
 
@@ -648,7 +648,7 @@
     regsub -- "\-[db_type]$" $relative_path {} relative_path
 
     # Change all . to :
-    regsub -all {\.} $relative_path {:} relative_path    
+    regsub -all {\.} $relative_path {:} relative_path
 
     # Change all / to . (hah, no reference to News for Nerds)
     regsub -all {/} $relative_path {.} relative_path
@@ -667,8 +667,8 @@
 
 ad_proc -private db_qd_internal_parse_init {stuff_to_parse file_path} {
     Initialize the parsing state
-} { 
-    
+} {
+
     # Do initial parse
     set parsed_doc [xml_parse -persist $stuff_to_parse]
 
@@ -701,11 +701,11 @@
 
 ad_proc -private db_qd_internal_parse_one_query {parsing_state} {
     Parse one query using the query state
-} { 
-    
+} {
+
     # Find the index that we're looking at
     lassign $parsing_state index node_list parsed_doc default_rdbms file_path
-    
+
     # BASE CASE
     if {[llength $node_list] <= $index} {
 	# Clean up
@@ -719,12 +719,12 @@
 
     # Get one query
     set one_query_xml [lindex $node_list $index]
-    
+
     # increase index
     incr index
 
     # Update the parsing state so we know
-    # what to parse next 
+    # what to parse next
     set parsing_state [list $index $node_list $parsed_doc $default_rdbms $file_path]
 
     # Parse the actual query from XML
@@ -738,22 +738,22 @@
 
 ad_proc -private db_qd_internal_parse_one_query_from_xml_node {one_query_node {default_rdbms {}} {file_path {}}} {
     Parse one query from an XML node
-} { 
+} {
     # db_qd_log QDDebug "parsing one query node in XML with name -[xml_node_get_name $one_query_node]-"
 
     # Check that this is a fullquery
     if {[xml_node_get_name $one_query_node] ne "fullquery"} {
 	return ""
     }
-    
+
     set queryname [xml_node_get_attribute $one_query_node name]
 
     # Get the text of the query
     set querytext [xml_node_get_content [xml_node_get_first_child_by_name $one_query_node querytext]]
 
     # Get the RDBMS
     set rdbms_nodes [xml_node_get_children_by_name $one_query_node rdbms]
-    
+
     # If we have no RDBMS specified, use the default
     if {[llength $rdbms_nodes] == 0} {
 	# db_qd_log QDDebug "Wow, Nelly, no RDBMS for this query, using default rdbms $default_rdbms"
@@ -793,19 +793,19 @@
 
 ad_proc -private db_qd_root_path {} {
     The token that indicates the root of all queries
-} { 
+} {
     return "dbqd."
 }
 
 ad_proc -private db_qd_null_path {} {
-    The null path 
-} { 
+    The null path
+} {
     return "[db_qd_root_path].NULL"
 }
 
 ad_proc -private db_qd_relative_path_p {path} {
     Check if the path is relative
-} { 
+} {
     set root_path [db_qd_root_path]
     set root_path_length [string length $root_path]
 
@@ -820,7 +820,7 @@
 
 ad_proc -private db_qd_make_absolute_path {relative_root suffix} {
     Make a path absolute
-} { 
+} {
     return "[db_qd_root_path]${relative_root}$suffix"
 }
 
@@ -831,12 +831,12 @@
 ad_proc -private db_qd_internal_prepare_queryfile_content {file_content} {
     Prepare raw .xql-file content form xml-parsing via quoting
 } {
-    
+
     set new_file_content ""
 
-    # The lazy way to do it.  partialquery was added for clarification of 
-    # the query files, but in fact a partialquery and a fullquery are parsed 
-    # exactly the same.  Doing this saves the bother of having to tweak the 
+    # The lazy way to do it.  partialquery was added for clarification of
+    # the query files, but in fact a partialquery and a fullquery are parsed
+    # exactly the same.  Doing this saves the bother of having to tweak the
     # rest of the parsing code to handle partialquery.  (OpenACS - DanW)
 
     regsub -all {(</?)partialquery([ >])} $file_content {\1fullquery\2} rest_of_file_content
@@ -892,7 +892,7 @@
 }
 
 # clean up after ourselves here.
-if { $remove_ad_proc_p } { 
+if { $remove_ad_proc_p } {
     rename ad_proc {}
 }