Trouble escaping quotes in a variable held string during a Sub-shell execution call [duplicate]

Question

I'm trying to write a database call from within a bash script and I'm having problems with a sub-shell stripping my quotes away.

This is the bones of what I am doing.

#---------------------------------------------    
#! /bin/bash    
export COMMAND='psql ${DB_NAME} -F , -t --no-align -c "${SQL}"  -o ${EXPORT_FILE} 2>&1'    
PSQL_RETURN=`${COMMAND}`    
#---------------------------------------------

If I use an 'echo' to print out the ${COMMAND} variable the output looks fine:

echo ${COMMAND}

screen output:-

#---------------    
psql drupal7 -F , -t --no-align -c "SELECT DISTINCT hostname FROM accesslog;" -o /DRUPAL/INTERFACES/EXPORTS/ip_list.dat 2>&1    
#---------------

Also if I cut and paste this screen output it executes just fine.

However, when I try to execute the command as a variable within a sub-shell call, it gives an error message. The error is from the psql client to the effect that the quotes have been removed from around the ${SQL} string. The error suggests psql is trying to interpret the terms in the sql string as parameters.

So it seems the string and quotes are composed correctly but the quotes around the ${SQL} variable/string are being interpreted by the sub-shell during the execution call from the main script.

I've tried to escape them using various methods: \", \\", \\\", "", \"" '"', \'"\', ... ... As you can see from my 'try it all' approach I am no expert and it's driving me mad.

Any help would be greatly appreciated.

Charlie101

Answer 1

Instead of storing command in a string var better to use BASH array here:

cmd=(psql ${DB_NAME} -F , -t --no-align -c "${SQL}" -o "${EXPORT_FILE}")
PSQL_RETURN=$( "${cmd[@]}" 2>&1 )

Answer 2

Rather than evaluating the contents of a string, why not use a function?

call_psql() {    
    # optional, if variables are already defined in global scope
    DB_NAME="$1"
    SQL="$2"
    EXPORT_FILE="$3"

    psql "$DB_NAME" -F , -t --no-align -c "$SQL"  -o "$EXPORT_FILE" 2>&1
}

then you can just call your function like:

PSQL_RETURN=$(call_psql "$DB_NAME" "$SQL" "$EXPORT_FILE")

It's entirely up to you how elaborate you make the function. You might like to check for the correct number of arguments (using something like (( $# == 3 ))) before calling the psql command.

Alternatively, perhaps you'd prefer just to make it as short as possible:

call_psql() { psql "$1" -F , -t --no-align -c "$2"  -o "$3" 2>&1; }

In order to capture the command that is being executed for debugging purposes, you can use set -x in your script. This will the contents of the function including the expanded variables when the function (or any other command) is called. You can switch this behaviour off using set +x, or if you want it on for the whole duration of the script you can change the shebang to #!/bin/bash -x. This saves you explicitly echoing throughout your script to find out what commands are being run; you can just turn on set -x for a section.

A very simple example script using the shebang method:

#!/bin/bash -x

ec() {
  echo "$1"
}
var=$(ec 2)

Running this script, either directly after making it executable or calling it with bash -x, gives:

++ ec 2
++ echo 2
+ var=2

Removing the -x from the shebang or the invocation results in the script running silently.