.rel sync.sh

alias ssh2local='declare prefix=ssh_; import_vars; unset prefix

alias use_local='declare prefix=local_; import_vars; unset prefix'

alias use_local_remote='{ use_remote; use_local; }'

	# *must* be run inside a function

alias use_root='declare prefix=root_; import_vars; unset prefix'

esc_name() { echo "$quote${1//$quote/$quote$quote}$quote"; }

mk_esc_name_alias() # usage: mk_esc_name_alias schema_esc

{ alias mk_"$1"='declare '"$1"'="${'"$1"':-$(esc_name "$'"${1%_esc}"'")}"; '\

mk_esc_name_alias schema_esc

fi # load new aliases

skip_table() # usage: create_table || table=... skip_table || return 0

: "${test=$(isset limit; exit2bool)}" # test mode when using limited # rows

# usage: (set_large_table; to_file db_cmd...) || return

limit() # usage: "query... $([prefix=$'| |\n'] [limit|n=#] limit)"

{

	if isset n; then local limit="${limit-$n}"; fi

	echo -n "${limit:+${prefix}LIMIT $limit}"

cols2list() # usage: cols2list col...

mk_select() # usage: {query=... | table=... [cols=...] [filter=...] \

# [order_by=...]} [limit|n=#] mk_select

{

	if is_array cols    ; then cols="$(    cols2list "${cols[@]}"    )"; fi

	echo "$(rtrim "${query:-SELECT ${cols:-*} ${cols:+

}FROM $table_esc

}${order_by:+ORDER BY $order_by

}}")\

}

# export func usage: export_func() { ...; mk_select_var; ... }

fi # load new aliases

mk_drop() # usage: table=... mk_drop|*sql_ANSI

	log_local; log++; echo_func; kw_params table; : "${table?}"; mk_table_esc

	echo "DROP TABLE IF EXISTS $table_esc"

mk_truncate() # usage: table=... mk_truncate|*sql_ANSI

{

	log_local; log++; echo_func; kw_params table; : "${table?}"; mk_table_esc

	echo "TRUNCATE $table_esc"

### MySQL

alias set_database=\

# usage: mysql*() { ...; mysql_cmd "$@"; } (with alias)

# caller usage: [ssh_server=...] [server=...] [user=...] [password=...] mysql*()

function mysql_cmd() # usage: mysql*() { ...; mysql_cmd cmd "$@"; }

# auto-adds connection/login opts when specified

{

	local cmd="$1"; shift

	local ssh_server="$(localize_url "$ssh_server")"

	if test "$ssh_server"; then

		local ssh_dest="${ssh_dest-${ssh_user:+$ssh_user@}$ssh_server}"

	command "time" ${ssh_dest:+ssh "$ssh_dest" }"$cmd" \

${server:+ --host="$server" }${user:+--user="$user" } --password\

${password+="$password"} --quick "$@" # --quick: don't buffer entire result

}

alias mysql_cmd='mysql_cmd "$FUNCNAME"'

fi # load new aliases

function mysql() # usage: [database=...] [data_only=1] [log_queries=] mysql ...

{

	echo_func; kw_params output_data data_only query_verbosity

	if test "$data_only"; then local output_data="${output_data-1}"; fi

	local log_queries="${log_queries-1}"

	set_database

	set -- ${database:+--database="$database" }--local-infile=1 \

	if test "$output_data"; then echo_stdin|mysql_cmd --batch "$@"

	else cmd_log_fd=1 mysql_cmd ${log_queries:+--verbose --verbose --verbose }\

	fi

}

mysql_ANSI()

{

# always use ANSI mode, to support "" identifiers. `` *are* still supported in

# this mode, so it also works with SHOW CREATE TABLE output and dumpfiles.

fi # load new aliases

mysql_truncate() { echo_func; mk_truncate|mysql; }

mysql_import() # usage: table=... [cols=...] [append=1] mysql_import <file

{

	if test ! "$append"; then mysql_truncate; fi

	mysql_load_data_format="${mysql_load_data_format%

	ssh2local # ssh does not tunnel nonstandard fds

	mysql "$@" 40<&0 <<EOF

LOAD DATA LOCAL INFILE '/dev/fd/40'

${append:+IGNORE }INTO TABLE $table_esc

$mysql_load_data_format

mysql_export() # does not support CSV

# caller usage: [database=...] {query=... | table=... [cols=...] [filter=...]} \

# cmd line usage: [limit=...] caller

{

	mk_select_var

	output_data=1 mysql "$@" <<<"$query"

}

	: "${file:?}"

	mk_select_var

	local mysql_load_data_format="${mysql_load_data_format-\

	head="${head%

	local tail="${query#$head}"

	mysql_load_data_format="${mysql_load_data_format%

	mysql "$@" <<EOF

$head

$mysql_load_data_format

EOF

## backups

mysqldump() # usage: [schema=1 | data=1] [create_db=1] mysqldump db [table...]

{

	echo_func

	local var=create_db; local_inv

--lock-tables=false --set-charset \

${postgres_compat:+${data:+--compatible=postgresql }--add-locks=false }\

${schema:+--no-data }${data:+--no-create-info }"$@"

mysqldump_diffable()

{

	mysqldump "$@"|{ pipe_delay; echo_run sed 's/^(-- Dump completed).*$/\1/'; }

}

mysql_rm_privileged_statements()

## permissions

mysql_seal_table() # usage: table=... user=... mysql_seal_table

	echo_func; kw_params table user; : "${table:?}" "${user:?}"; mk_table_esc

	benign_error=1 mysql_root <<<"REVOKE ALL PRIVILEGES ON $table FROM '$user'@'%'" || true

	benign_error=1 mysql_root <<<"REVOKE GRANT OPTION   ON $table FROM '$user'@'%'" || true

}

## server admin

mysql_ctl() # usage: mysql_ctl {start|stop|restart|...}

{

mysql_snapshot() # usage: live=1 [from=...] [to=...] mysql_snapshot

{

	echo_func; kw_params from to

	sudo mkdir "$to"

	prep_try; local_dir="$from" remote_url="$to" "try" sudo upload

	mysql_ctl start

	rethrow

}

### PostgreSQL

alias use_pg='declare prefix=pg_; import_vars; unset prefix'

fi # load new aliases

# usage: pg_*() { ...; pg_cmd "$@"; } (uses alias)

{

	echo_func; kw_params as_root

	use_pg

	log_local

	log- 2

	if test "$server";   then local PGHOST="$server";       export PGHOST; fi

	if test "$password"; then local PGPASSWORD="$password"; log++ export PGPASSWORD;fi

	if test "$database"; then local PGDATABASE="$database"; export PGDATABASE;fi

	log+ 2

	time if test "$as_root"; then sudo -u postgres "$@"; else command "$@"; fi

}

psql() # usage: [stdin=copy_pstdin_file] [output_data=1] psql \

# SUDO_USER: when set, avoids outputting to /dev/fd/#, because this causes a

{

	echo_func; kw_params stdin output_data

	local bypass_ok="$(! isset SUDO_USER; exit2bool)"; echo_vars bypass_ok

		echo_vars verbose_

	local data_bypasses_filter="$(test "$output_data" -a "$bypass_ok";

		exit2bool)"; echo_vars data_bypasses_filter

	if test "$verbose_"; then set -- --echo-all --echo-hidden "$@"; fi

	local redirs=("${redirs[@]}" '40<&0' "0<${stdin:-&20}" '41>&1')

	(

		# hide stack traces/DETAIL sections of error messages at verbosity <2

		if ! log++ can_log; then echo '\set VERBOSITY terse'; fi

		if test "$verbose_"; then echo '\timing on'; fi

		cat

	)|cmd_log_fd=${bypass_ok:+1} pg_cmd --file /dev/fd/40 \

${data_bypasses_filter:+--output /dev/fd/41 }--set ON_ERROR_STOP=1 --quiet "$@"\

|| verbosity_min=2 die_error_hidden

		# --output is for query *results*, not echoed statements

pg_export() # usage: mk_select_opts... [pg_copy_format=CSV...] pg_export >out

{

	mk_select_var

	local pg_copy_format="${pg_copy_format-CSV HEADER}"

	output_data=1 psql "$@" <<<"COPY ($query) TO STDOUT $pg_copy_format;"

}

pg_header()

{

	pg_export "$@"|echo_stdout

}

pg_export_table_no_header()

{

	pg_export "$@"

}

pg_export_table_to_dir()

pg_export_table_to_dir_no_header()

{

	stdout="$exports_dir/$table.no_header.cols=$(pg_header).csv" to_file \

pg_export_table_no_header "$@"

}

pg_dump() # usage: database={...|} [schema=...] [struct=1 | data=1] [owners=1] \

{

	echo_func;kw_params database struct data owners compress create_schema users

	local create_schema="${create_schema-1}"

	if test "$struct"; then set -- "$@" --schema-only; fi

	if test "$database"; then # just one DB

		fi

		(

pg_cmd "$@"

		)

}

pg_schema_exists() # usage: schema=... pg_schema_exists

{

	pattern='cannot create temporary relation in non-temporary schema' \

ignore_e=3 log++ stderr_matches psql <<<"CREATE TEMP TABLE $schema_esc.t ()"

}

pg_require_schema() # usage: schema=... pg_require_schema

	pg_schema_exists || die "schema $schema does not exist"

}

pg_table_exists() # usage: [schema=...] table=... pg_table_exists

{

	! pattern='relation .* does not exist' \

ignore_e=3 log++ stderr_matches psql <<<"SELECT NULL FROM $table_esc LIMIT 0"

}

fi