postgresforest500beutil/0000775000077200007720000000000011124632220017230 5ustar forestdevelforestdevelpostgresforest500beutil/init/0000775000077200007720000000000011124632220020173 5ustar forestdevelforestdevelpostgresforest500beutil/init/createmngdb.sh0000775000077200007720000000360111124632220023005 0ustar forestdevelforestdevel#!/bin/sh if [ $# -ne 7 ] ; then echo "Usage : ${0} [PSQL-COMMAND] [IP] [PORT] [USERNAME] [IP0:PORT0] [IP1:PORT1] [USERDB]" exit 1 fi PSQL=${1} IP=${2} PORT=${3} USERNAME=${4} URL0=${5} URL1=${6} USRDB=${7} MNGDB="${USRDB}_pghainfo" ${PSQL} -h ${IP} -p ${PORT} -U ${USERNAME} -d template1 < # This script is designed for PostgreSQL HA to recover database instance faulted. # # # PGHARecovery.sh -all | -base | -closevm | -sync | -recovery | -openvm | -cleanup | -cancel configfile # # # 0 = OK, 1 = FATAL # # # ~/.pgpass PG_HOME/share/recovery.conf.sample # # $Id: PGHARecovery.sh 2818 2008-12-25 06:29:25Z nagatsumas $ PROG=`basename $0` DIR=`dirname $0` USER=`/usr/bin/whoami` HOST=`hostname` ######################################## # Definition ######################################## PGCONFIG_ONLINE="postgresql.conf.online" MAX_DURATION_ADD=10 # # messages # MSG_I001="online recovery (base) started" MSG_I002="- reloading postgresql.conf for recovery..." MSG_I003="- executing checkpoint..." MSG_I004="- executing pg_start_backup()..." MSG_I005="- executing base_recovery_command..." MSG_I006="online recovery (base) successful" MSG_I007="online recovery (sync) started" MSG_I008="- changing server_info..." MSG_I009="- waiting for pghainfo cache to be refreshed..." MSG_I010="- waiting for busy transaction(s) to idle..." MSG_I011="pid(s) remaining" MSG_I012="- executing pg_stop_backup()..." MSG_I013="start WAL location" MSG_I014="stop WAL location" MSG_I015="- waiting for stop WAL location to be archived..." MSG_I016="- executing sync_recovery_command..." MSG_I017="- executing instance_startup_command..." MSG_I018="- setting recovery.conf..." MSG_I019="- removing recovery.conf..." MSG_I020="online recovery (sync) successful" MSG_I021="- resetting postgresql.conf..." MSG_I022="updated server_info.udb_validity" MSG_I023="online recovery (cleanup) started" MSG_I024="online recovery (cleanup) successful" MSG_I025="- reloading postgresql.conf for online..." MSG_I026="- removing archived WAL file(s)..." MSG_I027="current configuration" MSG_I028="reloaded configuration" MSG_I029="kill SIGHUP process" MSG_I030="- getting max serverinfo_read_duration..." MSG_I031="max serverinfo_read_duration" MSG_I032="loading serverinfo_read_duration" MSG_I033="online recovery (closevm) started" MSG_I034="online recovery (closevm) successful" MSG_I035="online recovery (openvm) started" MSG_I036="online recovery (openvm) successful" MSG_I037="online recovery (recovery) started" MSG_I038="online recovery (recovery) successful" MSG_I039="loading udb_url" MSG_I040="execute -cleanup for recovery node" MSG_I041="- removing ${PGCONFIG_ONLINE}..." MSG_I042="online recovery (cancel) started" MSG_I043="online recovery (cancel) successful" MSG_E001="usage : ${PROG} -all | -base | -closevm | -sync | -recovery | -openvm | -cleanup | -cancel configfile" MSG_E002="failed to copy file(s)" MSG_E003="failed to kill SIGHUP process" MSG_E004="file not found" MSG_E005="failed to execute checkpoint" MSG_E006="failed to configure file(s)" MSG_E007="failed to execute pg_start_backup()" MSG_E008="failed to execute base_recovery_command" MSG_E009="online recovery (base) failed" MSG_E010="failed to get database name like %_pghainfo" MSG_E011="failed to change server_info.udb_validity" MSG_E012="timeout. there is busy transaction(s)" MSG_E013="failed to execute pg_stop_backup()" MSG_E014="timeout. WAL file is not archived." MSG_E015="failed to execute sync_recovery_command" MSG_E016="failed to execute instance_startup_command" MSG_E017="failed to remove file(s)" MSG_E018="online recovery (sync) failed" MSG_E019="online recovery (cleanup) failed" MSG_E020="failed to load serverinfo_read_duration" MSG_E021="online recovery (closevm) failed" MSG_E022="online recovery (openvm) failed" MSG_E023="online recovery (recovery) failed" MSG_E024="online recovery (cancel) failed" ######################################## # Function ######################################## # base recovery function BaseRecovery() { # if pg_start_backup() already is already executed if [ ! -e ${dbcluster_dir}/backup_label ] then # # reload postgresql.conf for base recovery # Logging "${MSG_I002}" # backup postgresql.conf & edit postgresql.conf (replace archive_command) if [ ! -e ${dbcluster_dir}/${PGCONFIG_ONLINE} ] then cp ${dbcluster_dir}/postgresql.conf ${dbcluster_dir}/${PGCONFIG_ONLINE} && \ sed -e "s/^archive_command/#archive_command/" ${dbcluster_dir}/${PGCONFIG_ONLINE} > ${dbcluster_dir}/postgresql.conf && \ echo "archive_command = '${archive_command}'" >> ${dbcluster_dir}/postgresql.conf if [ $? -ne 0 ] then EchoNG Logging "${MSG_E006} : ${dbcluster_dir}/postgresql.conf" return 1 fi fi ReloadConfiguration || return 1 # # execute CHECKPOINT # Logging "${MSG_I003}" ${pg_dir}/bin/psql -U ${pg_user} -d ${pg_db} -p ${pg_port} -q -c "CHECKPOINT" > /dev/null if [ $? -ne 0 ] then EchoNG Logging "${MSG_E005}" return 1 fi EchoOK # # execute pg_start_backup # Logging "${MSG_I004}" XLOG_START=`${pg_dir}/bin/psql -U ${pg_user} -d ${pg_db} -p ${pg_port} -q -A -t -c "SELECT pg_xlogfile_name(pg_start_backup('pgha_recovery'))" | awk '{print $1}' | head -n 1` if [ $? -ne 0 ] || [ "x${XLOG_START}" == "x" ] then EchoNG Logging "${MSG_E007}" return 1 fi Logging "${MSG_I013} : ${XLOG_START}" EchoOK fi # # set recovery.conf # Logging "${MSG_I018}" RECOVERYFILE=`find ${pg_dir}/share -name "recovery.conf.sample" | head -n1` sed -e "s|^#restore_command.\+$|restore_command = '${restore_command}'|" ${RECOVERYFILE} >> ${dbcluster_dir}/recovery.conf if [ $? -ne 0 ] then EchoNG Logging "${MSG_E006} : recovery.conf append restore_command" return 1 fi EchoOK # # execute base recovery # Logging "${MSG_I005}" ${base_recovery_command} > /dev/null if [ $? -ne 0 ] then EchoNG Logging "${MSG_E008}" return 1 fi EchoOK # # move recovery.conf # Logging "${MSG_I019}" rm ${dbcluster_dir}/recovery.conf if [ $? -ne 0 ] then EchoNG Logging "${MSG_E017} : ${dbcluster_dir}/recovery.conf" return 1 fi EchoOK return 0 } # suppress JDBC access function CloseVM() { # # change server_info.udb_validity (suppress query from JDBC) # ChangeUDBValidity wait online online if [ $? -ne 0 ] then return 1 fi # # wait for busy transaction to idle # GetMaxDuration && WaitTransactionToIdle if [ $? -ne 0 ] then return 1 fi return 0 } # sync recovery (redo xlog) function SyncRecovery() { if [ -e ${dbcluster_dir}/backup_label ] then # # execute pg_stop_backup # Logging "${MSG_I012}" XLOG_STOP=`${pg_dir}/bin/psql -U ${pg_user} -d ${pg_db} -p ${pg_port} -q -A -t -c "SELECT pg_xlogfile_name(pg_stop_backup())" | awk '{print $1}' | head -n 1` if [ $? -ne 0 ] || [ "x${XLOG_STOP}" == "x" ] then EchoNG Logging "${MSG_E013}" return 1 fi Logging "${MSG_I014} : ${XLOG_STOP}" EchoOK # # wait for stop WAL location to be archived # Logging "${MSG_I015}" TMP=1 for CNT in `seq 1 ${archive_wait_timeout}` do sleep 1 echo -n "." if [ -e ${archivexlog_dir}/${XLOG_STOP} ] && [ `du -b ${archivexlog_dir}/${XLOG_STOP} | awk '{print $1}' | head -n 1` -eq 16777216 ] then TMP=0 break fi done echo if [ ${TMP} -ne 0 ] then EchoNG Logging "${MSG_E014}" fi EchoOK fi # # execute sync recovery # Logging "${MSG_I016}" ${sync_recovery_command} > /dev/null if [ $? -ne 0 ] then EchoNG Logging "${MSG_E015}" return 1 fi EchoOK return 0 } # recovery instance function RecoverInstance() { # # execute instance startup # Logging "${MSG_I017}" ${instance_startup_command} > /dev/null if [ $? -ne 0 ] then EchoNG Logging "${MSG_E016}" return 1 fi EchoOK return 0 } # unsuppress JDBC access function OpenVM() { # # change server_info.udb_validity (suppress query from JDBC) # ChangeUDBValidity online all all if [ $? -ne 0 ] then return 1 fi return 0 } # cleanup recovery function CleanupRecovery() { # # reset postgresql.conf # Logging "${MSG_I021}" cp ${dbcluster_dir}/${PGCONFIG_ONLINE} ${dbcluster_dir}/postgresql.conf if [ $? -ne 0 ] then EchoNG Logging "${MSG_E002} : ${dbcluster_dir}/${PGCONFIG_ONLINE} ${dbcluster_dir}/postgresql.conf" return 1 fi EchoOK # # reload postgresql.conf # ReloadConfiguration || return 1 # # remove postgresql.conf for recovery # if [ -e ${dbcluster_dir}/${PGCONFIG_ONLINE} ] then Logging "${MSG_I041}" rm ${dbcluster_dir}/${PGCONFIG_ONLINE} if [ $? -ne 0 ] then EchoNG Logging "${MSG_E017} : ${dbcluster_dir}/${PGCONFIG_ONLINE}" return 1 fi EchoOK fi # # remove archived WAL # Logging "${MSG_I026}" rm -f ${archivexlog_dir}/* if [ $? -ne 0 ] then EchoNG Logging "${MSG_E017} : ${archivexlog_dir}/*" return 1 fi EchoOK return 0 } # cancel recovery function CancelRecovery() { if [ -e ${dbcluster_dir}/backup_label ] then # # execute pg_stop_backup # Logging "${MSG_I012}" XLOG_STOP=`${pg_dir}/bin/psql -U ${pg_user} -d ${pg_db} -p ${pg_port} -q -A -t -c "SELECT pg_xlogfile_name(pg_stop_backup())" | awk '{print $1}' | head -n 1` if [ $? -ne 0 ] || [ "x${XLOG_STOP}" == "x" ] then EchoNG Logging "${MSG_E013}" return 1 fi Logging "${MSG_I014} : ${XLOG_STOP}" EchoOK fi # # change server_info.udb_validity (suppress query from JDBC) # ChangeUDBValidity online wait wait if [ $? -ne 0 ] then return 1 fi # # reset postgresql.conf # if [ -e ${dbcluster_dir}/${PGCONFIG_ONLINE} ] then Logging "${MSG_I021}" cp ${dbcluster_dir}/${PGCONFIG_ONLINE} ${dbcluster_dir}/postgresql.conf if [ $? -ne 0 ] then EchoNG Logging "${MSG_E002} : ${dbcluster_dir}/${PGCONFIG_ONLINE} ${dbcluster_dir}/postgresql.conf" return 1 fi EchoOK fi # # reload postgresql.conf # ReloadConfiguration || return 1 # # remove postgresql.conf for recovery # if [ -e ${dbcluster_dir}/${PGCONFIG_ONLINE} ] then Logging "${MSG_I041}" rm ${dbcluster_dir}/${PGCONFIG_ONLINE} if [ $? -ne 0 ] then EchoNG Logging "${MSG_E017} : ${dbcluster_dir}/${PGCONFIG_ONLINE}" return 1 fi EchoOK fi # # remove archived WAL # Logging "${MSG_I026}" rm -f ${archivexlog_dir}/* if [ $? -ne 0 ] then EchoNG Logging "${MSG_E017} : ${archivexlog_dir}/*" return 1 fi EchoOK return 0 } # reload postgresql.conf function ReloadConfiguration() { # # reload postgresql.conf # Logging "${MSG_I025}" Logging "${MSG_I027} : archive_mode = `${pg_dir}/bin/psql -U ${pg_user} -d ${pg_db} -p ${pg_port} -q -A -t -c 'SHOW archive_mode' | head -n 1`" Logging "${MSG_I027} : archive_command = `${pg_dir}/bin/psql -U ${pg_user} -d ${pg_db} -p ${pg_port} -q -A -t -c 'SHOW archive_command' | head -n 1`" PID=`cat ${dbcluster_dir}/postmaster.pid | head -n 1` && Logging "${MSG_I029} : `ps -f --no-header -p ${PID}`" && kill -s SIGHUP `cat ${dbcluster_dir}/postmaster.pid | head -n 1` if [ $? -ne 0 ] then EchoNG Logging "${MSG_E003}" return 1 fi Logging "${MSG_I028} : archive_mode = `${pg_dir}/bin/psql -U ${pg_user} -d ${pg_db} -p ${pg_port} -q -A -t -c 'SHOW archive_mode' | head -n 1`" Logging "${MSG_I028} : archive_command = `${pg_dir}/bin/psql -U ${pg_user} -d ${pg_db} -p ${pg_port} -q -A -t -c 'SHOW archive_command' | head -n 1`" EchoOK return 0 } # change server_info.udb_validity (suppress query from JDBC) # arg1 : updated udb_validity, arg2 : current udb_validity, arg3 : target server's current udb_validity function ChangeUDBValidity() { UPDATED_VALIDITY=$1 CURRENT_VALIDITY=$2 TARGET_SERVER=$3 case ${UPDATED_VALIDITY} in online) UPDATED_VALIDITY_VAL=1 ;; wait) UPDATED_VALIDITY_VAL=0 ;; *) UPDATED_VALIDITY_VAL=0 ;; esac Logging "${MSG_I008}" DBLIST=`${pg_dir}/bin/psql -U ${pg_user} -d ${pg_db} -p ${pg_port} -q -A -t -c "SELECT datname FROM pg_database WHERE datname LIKE '%_pghainfo'" | awk '{print $1}'` if [ $? -ne 0 ] || [ "x${DBLIST}" == "x" ] then EchoNG Logging "${MSG_E010}" return 1 fi for DB in ${DBLIST} do Logging "${MSG_I039} : ${DB}" case ${TARGET_SERVER} in online) URLLIST=`${pg_dir}/bin/psql -U ${pg_user} -d ${DB} -p ${pg_port} -q -A -t -c "SELECT udb_url FROM server_info WHERE udb_validity = 1" | awk '{print $1}'` ;; wait) URLLIST=`${pg_dir}/bin/psql -U ${pg_user} -d ${DB} -p ${pg_port} -q -A -t -c "SELECT udb_url FROM server_info WHERE udb_validity = 0" | awk '{print $1}'` ;; *) URLLIST=`${pg_dir}/bin/psql -U ${pg_user} -d ${DB} -p ${pg_port} -q -A -t -c "SELECT udb_url FROM server_info"| awk '{print $1}'` ;; esac for URL in ${URLLIST} do HOST=`echo ${URL} | cut -d "/" -f 1 | cut -d ":" -f 1` PORT=`echo ${URL} | cut -d "/" -f 1 | cut -d ":" -f 2` UDB=`echo ${URL} | cut -d "/" -f 2` case ${CURRENT_VALIDITY} in online) ${pg_dir}/bin/psql -U ${pg_user} -d ${DB} -h ${HOST} -p ${PORT} -q -c "UPDATE server_info SET udb_validity = ${UPDATED_VALIDITY_VAL} WHERE udb_validity = 1" ;; wait) ${pg_dir}/bin/psql -U ${pg_user} -d ${DB} -h ${HOST} -p ${PORT} -q -c "UPDATE server_info SET udb_validity = ${UPDATED_VALIDITY_VAL} WHERE udb_validity = 0" ;; *) ${pg_dir}/bin/psql -U ${pg_user} -d ${DB} -h ${HOST} -p ${PORT} -q -c "UPDATE server_info SET udb_validity = ${UPDATED_VALIDITY_VAL}" ;; esac if [ $? -eq 0 ] then Logging "${MSG_I022} : ${DB} at ${HOST} (${URL} from ${CURRENT_VALIDITY} to ${UPDATED_VALIDITY})" else EchoNG Logging "${MSG_E011}" return 1 fi done done EchoOK return 0 } # get max serverinfo_read_duration function GetMaxDuration() { DURATION=0 Logging "${MSG_I030}" DBLIST=`${pg_dir}/bin/psql -U ${pg_user} -d ${pg_db} -p ${pg_port} -q -A -t -c "SELECT datname FROM pg_database WHERE datname LIKE '%_pghainfo'" | awk '{print $1}'` for DB in ${DBLIST} do Logging "${MSG_I032} : ${DB}" TMP=`${pg_dir}/bin/psql -U ${pg_user} -d ${DB} -p ${pg_port} -q -A -t -c "SELECT mngdb_read_duration FROM global_config LIMIT 1" | awk '{print $1}' | head -n 1` if [ "x${TMP}" == "x" ] then Logging "${MSG_E020}" fi if [ ${TMP} -gt ${DURATION} ] then DURATION=${TMP} fi done Logging "${MSG_I031} : ${DURATION}" EchoOK DURATION=`expr ${DURATION} + ${MAX_DURATION_ADD}` return 0 } # wait for busy transaction to idle function WaitTransactionToIdle() { Logging "${MSG_I009}" for CNT in `seq 1 ${DURATION}` do sleep 1 echo -n "." done echo EchoOK Logging "${MSG_I010}" TMP=1 for CNT in `seq 1 ${idle_wait_timeout}` do sleep 1 PIDS=`${pg_dir}/bin/psql -U ${pg_user} -d ${DB} -p ${pg_port} -q -A -t -c "SELECT procpid FROM pg_stat_activity WHERE procpid <> pg_backend_pid() AND current_query <> ''" | awk '{print $1}' | tr "\n" " "` if [ "x${PIDS}" == "x" ] then TMP=0 break fi Logging "${MSG_I011} : ${PIDS}" done if [ ${TMP} -ne 0 ] then EchoNG Logging ${MSG_E012} return 1 fi EchoOK return 0 } function Logging() { MODE=$2 OPTS="" case ${MODE} in withline) EchoLine Logging "$1" EchoLine return 0 ;; noreturn) OPTS="-n" ;; *) ;; esac echo ${OPTS} "$1" /usr/bin/logger "${PROG} $1" } function EchoOK() { Logging "[ OK ]" } function EchoNG() { Logging "[ NG ]" } function EchoLine() { Logging "----------------------------------------" } ######################################## # SHELL ######################################## # # init # # check argument count if [ $# -ne 2 ] then Logging "${MSG_E001}" exit 1 fi # set argument PHASE=$1 CONFIG=$2 # check configuration file if [ ! -e ${CONFIG} ] then Logging "${MSG_E004} : ${CONFIG}" exit 1 fi # set configuration . ${CONFIG} # # main # RET=9 case ${PHASE} in -all) $0 -base ${CONFIG} || exit 1 Logging "" $0 -closevm ${CONFIG} || exit 1 Logging "" $0 -sync ${CONFIG} || exit 1 Logging "" $0 -recovery ${CONFIG} || exit 1 Logging "" $0 -openvm ${CONFIG} || exit 1 Logging "" $0 -cleanup ${CONFIG} || exit 1 Logging "" Logging "${MSG_I040}" withline RET=0 ;; -base) Logging "${MSG_I001}" withline BaseRecovery RET=$? if [ ${RET} -eq 0 ] then Logging "${MSG_I006}" withline else Logging "${MSG_E009}" withline fi ;; -closevm) Logging "${MSG_I033}" withline CloseVM RET=$? if [ ${RET} -eq 0 ] then Logging "${MSG_I034}" withline else Logging "${MSG_E021}" withline fi ;; -sync) Logging "${MSG_I007}" withline SyncRecovery RET=$? if [ ${RET} -eq 0 ] then Logging "${MSG_I020}" withline else Logging "${MSG_E018}" withline fi ;; -recovery) Logging "${MSG_I037}" withline RecoverInstance RET=$? if [ ${RET} -eq 0 ] then Logging "${MSG_I038}" withline else Logging "${MSG_E023}" withline fi ;; -openvm) Logging "${MSG_I035}" withline OpenVM RET=$? if [ ${RET} -eq 0 ] then Logging "${MSG_I036}" withline else Logging "${MSG_E022}" withline fi ;; -cleanup) Logging "${MSG_I023}" withline CleanupRecovery RET=$? if [ ${RET} -eq 0 ] then Logging "${MSG_I024}" withline else Logging "${MSG_E019}" withline fi ;; -cancel) Logging "${MSG_I042}" withline CancelRecovery RET=$? if [ ${RET} -eq 0 ] then Logging "${MSG_I043}" withline else Logging "${MSG_E024}" withline fi ;; *) Logging "${MSG_E001}" exit 1 ;; esac # # final # exit ${RET} postgresforest500beutil/patch/0000775000077200007720000000000011124632220020327 5ustar forestdevelforestdevelpostgresforest500beutil/patch/pg831-locktimeout.patch0000664000077200007720000001601011124632220024545 0ustar forestdevelforestdeveldiff -cr postgresql-8.3.1/src/backend/storage/lmgr/proc.c postgresql-8.3.1-lt/src/backend/storage/lmgr/proc.c *** postgresql-8.3.1/src/backend/storage/lmgr/proc.c 2008-01-27 04:55:08.000000000 +0900 --- postgresql-8.3.1-lt/src/backend/storage/lmgr/proc.c 2008-10-09 11:34:12.000000000 +0900 *************** *** 49,54 **** --- 49,55 ---- /* GUC variables */ int DeadlockTimeout = 1000; int StatementTimeout = 0; + int LockTimeout = 0; bool log_lock_waits = false; /* Pointer to this process's PGPROC struct, if any */ *************** *** 75,80 **** --- 76,82 ---- static volatile bool deadlock_timeout_active = false; static volatile DeadLockState deadlock_state = DS_NOT_YET_CHECKED; volatile bool cancel_from_timeout = false; + volatile bool is_lock_timeout = false; /* timeout_start_time is set when log_lock_waits is true */ static TimestampTz timeout_start_time; *************** *** 730,735 **** --- 732,738 ---- int myWaitStatus; PGPROC *proc; int i; + TimestampTz lock_fin_time; /* * Determine where to add myself in the wait queue. *************** *** 855,860 **** --- 858,881 ---- * By delaying the check until we've waited for a bit, we can avoid * running the rather expensive deadlock-check code in most cases. */ + + if (LockTimeout > 0) + { + if (statement_timeout_active) + { + lock_fin_time = GetCurrentStatementStartTimestamp(); + lock_fin_time = TimestampTzPlusMilliseconds(lock_fin_time, LockTimeout); + if (statement_fin_time >= lock_fin_time) + is_lock_timeout = true; + } + else + { + is_lock_timeout = true; + } + if (is_lock_timeout && !enable_sig_alarm(LockTimeout, true)) + elog(FATAL, "could not set timer for process wakeup"); + } + if (!enable_sig_alarm(DeadlockTimeout, false)) elog(FATAL, "could not set timer for process wakeup"); *************** *** 1009,1014 **** --- 1030,1040 ---- if (!disable_sig_alarm(false)) elog(FATAL, "could not disable timer for process wakeup"); + if (LockTimeout > 0 && !disable_sig_alarm(true)) + elog(FATAL, "could not disable timer for process wakeup"); + + is_lock_timeout = false; + /* * Re-acquire the lock table's partition lock. We have to do this to hold * off cancel/die interrupts before we can mess with lockAwaited (else we diff -cr postgresql-8.3.1/src/backend/tcop/postgres.c postgresql-8.3.1-lt/src/backend/tcop/postgres.c *** postgresql-8.3.1/src/backend/tcop/postgres.c 2008-03-13 08:58:35.000000000 +0900 --- postgresql-8.3.1-lt/src/backend/tcop/postgres.c 2008-10-09 12:36:25.000000000 +0900 *************** *** 2588,2596 **** DisableNotifyInterrupt(); DisableCatchupInterrupt(); if (cancel_from_timeout) ! ereport(ERROR, ! (errcode(ERRCODE_QUERY_CANCELED), ! errmsg("canceling statement due to statement timeout"))); else if (IsAutoVacuumWorkerProcess()) ereport(ERROR, (errcode(ERRCODE_QUERY_CANCELED), --- 2588,2607 ---- DisableNotifyInterrupt(); DisableCatchupInterrupt(); if (cancel_from_timeout) ! { ! if (is_lock_timeout) { ! is_lock_timeout = false; ! ereport(ERROR, ! (errcode(ERRCODE_T_R_LOCKTIMEOUT_DETECTED), ! errmsg("canceling statement due to lock timeout"))); ! } ! else ! { ! ereport(ERROR, ! (errcode(ERRCODE_QUERY_CANCELED), ! errmsg("canceling statement due to statement timeout"))); ! } ! } else if (IsAutoVacuumWorkerProcess()) ereport(ERROR, (errcode(ERRCODE_QUERY_CANCELED), diff -cr postgresql-8.3.1/src/backend/utils/misc/guc.c postgresql-8.3.1-lt/src/backend/utils/misc/guc.c *** postgresql-8.3.1/src/backend/utils/misc/guc.c 2008-01-31 03:35:55.000000000 +0900 --- postgresql-8.3.1-lt/src/backend/utils/misc/guc.c 2008-10-08 17:33:46.000000000 +0900 *************** *** 1194,1199 **** --- 1194,1210 ---- 1000, 1, INT_MAX / 1000, NULL, NULL }, + { + {"lock_timeout", PGC_SIGHUP, LOCK_MANAGEMENT, + gettext_noop("Sets the time to wait on a lock before checking for lock timeout."), + NULL, + GUC_UNIT_MS + }, + &LockTimeout, + 0, 0, INT_MAX / 1000, NULL, NULL + }, + + /* * Note: There is some postprocessing done in PostmasterMain() to make * sure the buffers are at least twice the number of backends, so the diff -cr postgresql-8.3.1/src/backend/utils/misc/postgresql.conf.sample postgresql-8.3.1-lt/src/backend/utils/misc/postgresql.conf.sample *** postgresql-8.3.1/src/backend/utils/misc/postgresql.conf.sample 2008-01-31 03:35:55.000000000 +0900 --- postgresql-8.3.1-lt/src/backend/utils/misc/postgresql.conf.sample 2008-10-08 17:20:47.000000000 +0900 *************** *** 464,469 **** --- 464,470 ---- # max_locks_per_transaction * (max_connections + max_prepared_transactions) # lock table slots. + #lock_timeout = 0s #------------------------------------------------------------------------------ # VERSION/PLATFORM COMPATIBILITY diff -cr postgresql-8.3.1/src/include/pg_config_manual.h postgresql-8.3.1-lt/src/include/pg_config_manual.h *** postgresql-8.3.1/src/include/pg_config_manual.h 2007-06-09 03:23:53.000000000 +0900 --- postgresql-8.3.1-lt/src/include/pg_config_manual.h 2008-10-08 17:20:21.000000000 +0900 *************** *** 255,260 **** --- 255,266 ---- /* #define TRACE_SYNCSCAN */ /* + * Enable lock timeout feature; + * This value can be set in the lock_timeout GUC variable. + */ + #define ENABLE_LOCKTIMEOUT 1 + + /* * Other debug #defines (documentation, anyone?) */ /* #define HEAPDEBUGALL */ diff -cr postgresql-8.3.1/src/include/storage/proc.h postgresql-8.3.1-lt/src/include/storage/proc.h *** postgresql-8.3.1/src/include/storage/proc.h 2008-01-27 04:55:08.000000000 +0900 --- postgresql-8.3.1-lt/src/include/storage/proc.h 2008-10-08 17:18:52.000000000 +0900 *************** *** 145,154 **** /* configurable options */ extern int DeadlockTimeout; extern int StatementTimeout; extern bool log_lock_waits; extern volatile bool cancel_from_timeout; ! /* * Function Prototypes --- 145,155 ---- /* configurable options */ extern int DeadlockTimeout; extern int StatementTimeout; + extern int LockTimeout; extern bool log_lock_waits; extern volatile bool cancel_from_timeout; ! extern volatile bool is_lock_timeout; /* * Function Prototypes diff -cr postgresql-8.3.1/src/include/utils/errcodes.h postgresql-8.3.1-lt/src/include/utils/errcodes.h *** postgresql-8.3.1/src/include/utils/errcodes.h 2008-01-02 04:45:59.000000000 +0900 --- postgresql-8.3.1-lt/src/include/utils/errcodes.h 2008-10-08 17:17:35.000000000 +0900 *************** *** 235,240 **** --- 235,241 ---- #define ERRCODE_T_R_SERIALIZATION_FAILURE MAKE_SQLSTATE('4','0', '0','0','1') #define ERRCODE_T_R_STATEMENT_COMPLETION_UNKNOWN MAKE_SQLSTATE('4','0', '0','0','3') #define ERRCODE_T_R_DEADLOCK_DETECTED MAKE_SQLSTATE('4','0', 'P','0','1') + #define ERRCODE_T_R_LOCKTIMEOUT_DETECTED MAKE_SQLSTATE('4','0', 'Q','0','1') /* Class 42 - Syntax Error or Access Rule Violation */ #define ERRCODE_SYNTAX_ERROR_OR_ACCESS_RULE_VIOLATION MAKE_SQLSTATE('4','2', '0','0','0')