Necesitaba escribir un script para ingresar entradas de varias líneas a un programa ( psql).

Después de buscar un poco en Google, encontré que la siguiente sintaxis funciona:

cat << EOF | psql ---params
BEGIN;

`pg_dump ----something`

update table .... statement ...;

END;
EOF

Esto construye correctamente la cadena de varias líneas (desde BEGIN;hasta END;, inclusive) y la canaliza como entrada para psql.

Pero no tengo idea de cómo / por qué funciona, ¿alguien puede explicarlo?

Me refiero principalmente a cat << EOF, sé >salidas a un archivo, se >>agrega a un archivo, <lee la entrada del archivo.

¿Qué hace <<exactamente?

¿Y hay una página de manual para ello?

Esto se llama formato heredoc para proporcionar una cadena en stdin. Ver https://en.wikipedia.org/wiki/Here_document#Unix_shells para más detalles.

De man bash:

Aquí documentos

Este tipo de redirección le indica al shell que lea la entrada de la fuente actual hasta que se vea una línea que contiene solo una palabra (sin espacios en blanco).

Todas las líneas leídas hasta ese punto se utilizan como entrada estándar para un comando.

El formato de los documentos aquí es:

          <<[-]word
                  here-document
          delimiter

No se realiza expansión de parámetros, sustitución de comandos, expansión aritmética o expansión de nombre de ruta en Word . Si se citan caracteres en palabras , el delimitador es el resultado de la eliminación de comillas en palabras , y las líneas en el documento aquí no se expanden. Si la palabra no está entre comillas, todas las líneas del documento aquí están sujetas a expansión de parámetros, sustitución de comandos y expansión aritmética. En este último caso, la secuencia de caracteres \<newline>es ignorado, y \se debe utilizar para proteger los caracteres \, $y `.

Si el operador de redirección es <<-, entonces todos los caracteres de tabulación iniciales se eliminan de las líneas de entrada y la línea que contiene el delimitador . Esto permite que los documentos aquí dentro de los scripts de shell sean sangrados de forma natural.

La cat <<EOFsintaxis es muy útil cuando se trabaja con texto de varias líneas en Bash, por ejemplo. al asignar cadenas de varias líneas a una variable de shell, archivo o tubería.

Ejemplos de cat <<EOFuso de sintaxis en Bash:

1. Asigne una cadena de varias líneas a una variable de shell

$ sql=$(cat <<EOF
SELECT foo, bar FROM db
WHERE foo='baz'
EOF
)

La $sqlvariable ahora también contiene los caracteres de nueva línea. Puedes verificar con echo -e "$sql".

2. Pase una cadena de varias líneas a un archivo en Bash

$ cat <<EOF > print.sh
#!/bin/bash
echo \$PWD
echo $PWD
EOF

El print.sharchivo ahora contiene:

#!/bin/bash
echo $PWD
echo /home/user

3. Pase una cadena de varias líneas a una tubería en Bash

$ cat <<EOF | grep 'b' | tee b.txt
foo
bar
baz
EOF

El b.txtarchivo contiene bary bazlíneas. Se imprime la misma salida stdout.

En su caso, "EOF" se conoce como "Etiqueta aquí". Básicamente <<Herele dice al shell que vas a ingresar una cadena multilínea hasta la "etiqueta" Here. Puede nombrar esta etiqueta como desee, a menudo EOFo STOP.

Algunas reglas sobre las etiquetas Aquí:

1. La etiqueta puede ser cualquier cadena, mayúscula o minúscula, aunque la mayoría de las personas usan mayúsculas por convención.
2. La etiqueta no se considerará una etiqueta Aquí si hay otras palabras en esa línea. En este caso, simplemente se considerará parte de la cadena. La etiqueta debe estar sola en una línea separada, para ser considerada una etiqueta.
3. La etiqueta no debe tener espacios iniciales o finales en esa línea para ser considerada una etiqueta. De lo contrario, se considerará como parte de la cadena.

ejemplo:

$ cat >> test <<HERE
> Hello world HERE <-- Not by itself on a separate line -> not considered end of string
> This is a test
>  HERE <-- Leading space, so not considered end of string
> and a new line
> HERE <-- Now we have the end of the string

POSIX 7

kennytm citado man bash, pero la mayor parte de eso también es POSIX 7: http://pubs.opengroup.org/onlinepubs/9699919799/utilities/V3_chap02.html#tag_18_07_04 :

Los operadores de redirección "<<" y "<< -" permiten la redirección de líneas contenidas en un archivo de entrada de shell, conocido como "documento aquí", a la entrada de un comando.

El documento aquí se tratará como una sola palabra que comienza después de la siguiente y continúa hasta que haya una línea que contenga solo el delimitador y a, sin caracteres intermedios. Entonces comienza el siguiente documento aquí, si hay uno. El formato es el siguiente:

[n]<<word
    here-document
delimiter

donde el n opcional representa el número de descriptor de archivo. Si se omite el número, el documento aquí se refiere a la entrada estándar (descriptor de archivo 0).

Si se cita cualquier carácter en la palabra, el delimitador se formará mediante la eliminación de la cita en la palabra, y las líneas del documento aquí no se expandirán. De lo contrario, el delimitador será la palabra misma.

Si no se citan caracteres en palabras, todas las líneas del documento aquí se expandirán para la expansión de parámetros, sustitución de comandos y expansión aritmética. En este caso, la entrada se comporta como comillas dobles internas (consulte Comillas dobles). Sin embargo, el carácter de comillas dobles ('"') no se tratará especialmente dentro de un documento aquí, excepto cuando la comilla doble aparezca dentro de" $ () "," `` "o" $ {} ".

Si el símbolo de redireccionamiento es "<< -", todos los <tab>caracteres iniciales se eliminarán de las líneas de entrada y de la línea que contiene el delimitador final. Si se especifica más de un operador "<<" o "<< -" en una línea, el documento adjunto asociado con el primer operador será proporcionado primero por la aplicación y el shell deberá leerlo primero.

Cuando un documento aquí se lee desde un dispositivo terminal y el shell es interactivo, debe escribir los contenidos de la variable PS2, procesados ​​como se describe en Variables de Shell, a error estándar antes de leer cada línea de entrada hasta que se haya reconocido el delimitador.

Ejemplos

Algunos ejemplos aún no se dan.

Las cotizaciones evitan la expansión de parámetros

Sin comillas:

a=0
cat <<EOF
$a
EOF

Salida:

0

Con comillas:

a=0
cat <<'EOF'
$a
EOF

o (feo pero válido):

a=0
cat <<E"O"F
$a
EOF

Salidas:

$a

El guión elimina las pestañas iniciales

Sin guión:

cat <<EOF
<tab>a
EOF

donde <tab>es una pestaña literal y se puede insertar conCtrl + V <tab>

Salida:

<tab>a

Con guión:

cat <<-EOF
<tab>a
<tab>EOF

Salida:

a

Esto existe, por supuesto, para que pueda sangrar catel código que lo rodea, que es más fácil de leer y mantener. P.ej:

if true; then
    cat <<-EOF
    a
    EOF
fi

Desafortunadamente, esto no funciona para los caracteres de espacio: POSIX favoreció la tabsangría aquí. Yikes

Usando tee en lugar de gato

No exactamente como respuesta a la pregunta original, pero quería compartir esto de todos modos: tuve la necesidad de crear un archivo de configuración en un directorio que requería derechos de root.

Lo siguiente no funciona para ese caso:

$ sudo cat <<EOF >/etc/somedir/foo.conf
# my config file
foo=bar
EOF

porque la redirección se maneja fuera del contexto sudo.

Terminé usando esto en su lugar:

$ sudo tee <<EOF /etc/somedir/foo.conf >/dev/null
# my config file
foo=bar
EOF

Una pequeña extensión a las respuestas anteriores. El seguimiento >dirige la entrada al archivo, sobrescribiendo el contenido existente. Sin embargo, un uso particularmente conveniente es la flecha doble >>que se agrega, agregando su nuevo contenido al final del archivo, como en:

cat <<EOF >> /etc/fstab
data_server:/var/sharedServer/authority/cert /var/sharedFolder/sometin/authority/cert nfs
data_server:/var/sharedServer/cert   /var/sharedFolder/sometin/vsdc/cert nfs
EOF

Esto extiende su fstabsin tener que preocuparse por modificar accidentalmente ninguno de sus contenidos.

Esto no es necesariamente una respuesta a la pregunta original, sino un intercambio de algunos resultados de mis propias pruebas. Esta:

<<test > print.sh
#!/bin/bash
echo \$PWD
echo $PWD
test

producirá el mismo archivo que:

cat <<test > print.sh
#!/bin/bash
echo \$PWD
echo $PWD
test

Entonces, no veo el punto de usar el comando cat.

Vale la pena señalar que aquí los documentos también funcionan en bash loops. Este ejemplo muestra cómo obtener la lista de columnas de la tabla:

export postgres_db_name='my_db'
export table_name='my_table_name'

# start copy 
while read -r c; do test -z "$c" || echo $table_name.$c , ; done < <(cat << EOF | psql -t -q -d $postgres_db_name -v table_name="${table_name:-}"
SELECT column_name
FROM information_schema.columns
WHERE 1=1
AND table_schema = 'public'
AND table_name   =:'table_name'  ;
EOF
)
# stop copy , now paste straight into the bash shell ...

output: 
my_table_name.guid ,
my_table_name.id ,
my_table_name.level ,
my_table_name.seq ,

o incluso sin la nueva línea

while read -r c; do test -z "$c" || echo $table_name.$c , | perl -ne 
's/\n//gm;print' ; done < <(cat << EOF | psql -t -q -d $postgres_db_name -v table_name="${table_name:-}"
 SELECT column_name
 FROM information_schema.columns
 WHERE 1=1
 AND table_schema = 'public'
 AND table_name   =:'table_name'  ;
 EOF
 )

 # output: daily_issues.guid ,daily_issues.id ,daily_issues.level ,daily_issues.seq ,daily_issues.prio ,daily_issues.weight ,daily_issues.status ,daily_issues.category ,daily_issues.name ,daily_issues.description ,daily_issues.type ,daily_issues.owner