set prepare [expr {[info exists prepare] ? [list -prepare $prepare] : ""}]
set rows [uplevel 1 [list ::xo::dc list_of_lists -with_headers true -dbn $dbn -bind $bind {*}$prepare$qn$sql]]
set headers [lindex$rows 0]
if { $local } {
set level_up [expr {$upvar_level + 1}]
} else {
set level_up \#[::template::adp_level]
}
set cols [concat$headers$extend]
if {[::template::multirow -local -ulevel $level_up exists $var_name]} {
## We enforce here, that appending to an existing multirow# can only happen when we are extracting the same columns.#set existing_cols [::template::multirow -local -ulevel $level_up columns $var_name]
if {$cols ne $existing_cols} {
error"Cannot append to a multirow with different columns"
}
} else {
::template::multirow -local -ulevel $level_up create $var_name {*}$cols
}
foreach values [lrange$rows 1 end] {
if {[string length $body] > 0} {
## We have a code to execute. Bring all of the multirow# variables in scope.### Vars from the query#foreach att $headers value $values {
uplevel 1 [list set $att$value]
}
## Extended variables, initialized to empty.#foreach att $extend {
uplevel 1 [list set $att""]
}
## Run the code and trap any exception.#try {
uplevel 1 $body
} on error {errMsg} {
error$errMsg$::errorInfo$::errorCode
} on return {} {
error"Cannot return from inside a ::xo::dc multirow loop"
} on break {} {
break
} on continue {} {
continue
}
## Collect the values after the code has been executed.#set values [lmap att $cols {
if {[uplevel 1 [list info exists $att]]} {
uplevel 1 [list set $att]
}
}]
} else {
## No code to execute. We can just bulk append the values# from the row.#
}
::template::multirow -local -ulevel $level_up append $var_name {*}$values
}
prepare (scripted)
## Define a md5 key for the prepared statement in nsv based on the# SQL statement.#set key [ns_md5$sql]
## Get local variables "prepare", "execute", "prepName", and "sql"# keeping the relevant prepared statement context.#set per_interp_cache ::xo::prepared($key)
if {[info exists $per_interp_cache]} {
## The prepared statement exists in the per-interp cache, get the# values from there.#lassign [set$per_interp_cache] prepare execute prepName sql
} elseif {[nsv_exists prepared_statement $key]} {
## The prepared statement exists already in the nsv-cache.set nsv_cached_value [nsv_get prepared_statement $key]
## Save the nsv-cached value as well in the per-interpreter cache# and set the output variables.#set$per_interp_cache$nsv_cached_valuelassign$nsv_cached_value prepare execute prepName sql
} else {
## Compute a PREPARE statement and an EXECUTE statement on the# fly. Notice, that the incoming SQL statement must not have Tcl# vars, but has to use bind vars.#set d [ns_pg_prepare$sql]
set execArgs [dict get $d args]
set prepArgs [lrepeat [llength$execArgs] unknown]
set preparedSQL [dict get $d sql]
set argtypes [split$argtypes ,]
if {[llength$argtypes] == [llength$prepArgs]} {
set prepArgs $argtypes
}
if {[llength$prepArgs] > 0} {
set prepArgs ([join$prepArgs ,])
}
if {[llength$execArgs] > 0} {
set execArgs ([join$execArgs ,])
}
set c [nsv_incr prepared_statement count]
set prepName __p$cset prepare [ns_trim -delimiter | [subst {
|DO \$\$ DECLARE found boolean;
|BEGIN
|SELECT exists(select 1 from pg_prepared_statements where name = '$prepName') into found;
|if found IS FALSE then
| PREPARE $prepName$prepArgs AS $preparedSQL;
|end if;
|END\$\$;
}]]
set execute "EXECUTE $prepName$execArgs"## Save the values for this statement in the nsv-cache. This does# not mean that the prepared statement exists for the SQL# session already.#nsv_set prepared_statement $key [list$prepare$execute$prepName$sql]
}
## Now determine, whether the prepared statement was already# defined for the current SQL session. Depending on the version# of the driver, we can obtain a session_id from the db driver on# different preciseness levels. If we can't get the SQL session_id# from the driver, fall back to a per-request cache (via top-level# variable).#try {
if {[::acs::icanuse"ns_pg pid"]} {
set session_id [ns_pg pid $handle]
#ns_log notice "=== ns_pg pid -> '$session_id'"
} else {
set session_id [ns_db session_id $handle]
}
} on ok {_} {
#ns_log notice "=== $handle $session_id"set varName ::xo::prepared($session_id,$key)
} on error {errorMsg} {
## Could not determine SQL session_id, fall back to per-request# cache.#set session_id "-"set varName __prepared($key)
}
if {![info exists $varName]} {
## We have to check for the prepared statement in the current# session and we have to create it if necessary there.#ns_log notice "=== new prepared statement $prepName for SQL session $session_id:$sql"::db_exec dml $handle dbqd..create_preapared $prepare## Save the fact that we have a new preparted statement for this# SQL session_id in the current interpreter.#set$varName 1
} else {
#ns_log notice "=== prepare reuses handle $handle execute $execute session_id $session_id"
}
#ns_log notice "=== prepare done, handle $handle execute $execute session_id $session_id"return$execute
create ...
