diff -cprN head/src/backend/utils/error/elog.c work/src/backend/utils/error/elog.c
*** head/src/backend/utils/error/elog.c	2009-07-04 04:14:25.000000000 +0900
--- work/src/backend/utils/error/elog.c	2009-10-07 11:15:16.251326894 +0900
*************** static int	syslog_facility = LOG_LOCAL0;
*** 111,118 ****
  static void write_syslog(int level, const char *line);
  #endif
  
  #ifdef WIN32
! static void write_eventlog(int level, const char *line);
  #endif
  
  /* We provide a small stack of ErrorData records for re-entrant cases */
--- 111,120 ----
  static void write_syslog(int level, const char *line);
  #endif
  
+ static void write_console(const char *line, int len);
+ 
  #ifdef WIN32
! static void write_eventlog(int level, const char *line, int len);
  #endif
  
  /* We provide a small stack of ErrorData records for re-entrant cases */
*************** write_syslog(int level, const char *line
*** 1567,1576 ****
   * Write a message line to the windows event log
   */
  static void
! write_eventlog(int level, const char *line)
  {
! 	int			eventlevel = EVENTLOG_ERROR_TYPE;
! 	static HANDLE evtHandle = INVALID_HANDLE_VALUE;
  
  	if (evtHandle == INVALID_HANDLE_VALUE)
  	{
--- 1569,1579 ----
   * Write a message line to the windows event log
   */
  static void
! write_eventlog(int level, const char *line, int len)
  {
! 	WCHAR		   *utf16;
! 	int				eventlevel = EVENTLOG_ERROR_TYPE;
! 	static HANDLE	evtHandle = INVALID_HANDLE_VALUE;
  
  	if (evtHandle == INVALID_HANDLE_VALUE)
  	{
*************** write_eventlog(int level, const char *li
*** 1606,1613 ****
  			break;
  	}
  
  
! 	ReportEvent(evtHandle,
  				eventlevel,
  				0,
  				0,				/* All events are Id 0 */
--- 1609,1637 ----
  			break;
  	}
  
+ 	/*
+ 	 * Convert message to UTF16 text and write it with ReportEventW,
+ 	 * but fall-back into ReportEventA if conversion failed.
+ 	 */
+ 	if (errordata_stack_depth < ERRORDATA_STACK_SIZE - 1 &&
+ 		GetDatabaseEncoding() != GetPlatformEncoding() &&
+ 		(utf16 = pgwin32_toUTF16(line, len, NULL)) != NULL)
+ 	{
+ 		ReportEventW(evtHandle,
+ 				eventlevel,
+ 				0,
+ 				0,				/* All events are Id 0 */
+ 				NULL,
+ 				1,
+ 				0,
+ 				(LPCWSTR *) &utf16,
+ 				NULL);
  
! 		pfree(utf16);
! 	}
! 	else
! 	{
! 		ReportEventA(evtHandle,
  				eventlevel,
  				0,
  				0,				/* All events are Id 0 */
*************** write_eventlog(int level, const char *li
*** 1616,1624 ****
--- 1640,1690 ----
  				0,
  				&line,
  				NULL);
+ 	}
  }
+ 
  #endif   /* WIN32 */
  
+ static void
+ write_console(const char *line, int len)
+ {
+ #ifdef WIN32
+ 	if (errordata_stack_depth < ERRORDATA_STACK_SIZE - 1 &&
+ 		GetDatabaseEncoding() != GetPlatformEncoding())
+ 	{
+ 		static bool	redirected = false;
+ 		WCHAR	   *utf16;
+ 		int			utf16len;
+ 
+ 		if (!redirected &&
+ 			(utf16 = pgwin32_toUTF16(line, len, &utf16len)) != NULL)
+ 		{
+ 			HANDLE		stdHandle;
+ 			DWORD		written;
+ 
+ 			stdHandle = GetStdHandle(STD_ERROR_HANDLE);
+ 			if (WriteConsoleW(stdHandle, utf16, utf16len, &written, NULL))
+ 			{
+ 				pfree(utf16);
+ 				return;
+ 			}
+ 
+ 			/* WriteConsoleW could fail if stderr is redirected. */
+ 			pfree(utf16);
+ 			redirected = true;
+ 		}
+ 	}
+ #else
+ 	/*
+ 	 * Conversion on non-win32 platform is not implemented yet.
+ 	 * It requires non-throw version of pg_do_encoding_conversion(),
+ 	 * that converts unconvertable characters to '?' without errors.
+ 	 */
+ #endif
+ 
+ 	write(fileno(stderr), line, len);
+ }
+ 
  /*
   * setup formatted_log_time, for consistent times between CSV and regular logs
   */
*************** send_message_to_server_log(ErrorData *ed
*** 2206,2212 ****
  	/* Write to eventlog, if enabled */
  	if (Log_destination & LOG_DESTINATION_EVENTLOG)
  	{
! 		write_eventlog(edata->elevel, buf.data);
  	}
  #endif   /* WIN32 */
  
--- 2272,2278 ----
  	/* Write to eventlog, if enabled */
  	if (Log_destination & LOG_DESTINATION_EVENTLOG)
  	{
! 		write_eventlog(edata->elevel, buf.data, buf.len);
  	}
  #endif   /* WIN32 */
  
*************** send_message_to_server_log(ErrorData *ed
*** 2230,2239 ****
  		 * because that's really a pipe to the syslogger process.
  		 */
  		else if (pgwin32_is_service())
! 			write_eventlog(edata->elevel, buf.data);
  #endif
  		else
! 			write(fileno(stderr), buf.data, buf.len);
  	}
  
  	/* If in the syslogger process, try to write messages direct to file */
--- 2296,2305 ----
  		 * because that's really a pipe to the syslogger process.
  		 */
  		else if (pgwin32_is_service())
! 			write_eventlog(edata->elevel, buf.data, buf.len);
  #endif
  		else
! 			write_console(buf.data, buf.len);
  	}
  
  	/* If in the syslogger process, try to write messages direct to file */
*************** send_message_to_server_log(ErrorData *ed
*** 2256,2267 ****
  		{
  			const char *msg = _("Not safe to send CSV data\n");
  
! 			write(fileno(stderr), msg, strlen(msg));
  			if (!(Log_destination & LOG_DESTINATION_STDERR) &&
  				whereToSendOutput != DestDebug)
  			{
  				/* write message to stderr unless we just sent it above */
! 				write(fileno(stderr), buf.data, buf.len);
  			}
  			pfree(buf.data);
  		}
--- 2322,2333 ----
  		{
  			const char *msg = _("Not safe to send CSV data\n");
  
! 			write_console(msg, strlen(msg));
  			if (!(Log_destination & LOG_DESTINATION_STDERR) &&
  				whereToSendOutput != DestDebug)
  			{
  				/* write message to stderr unless we just sent it above */
! 				write_console(buf.data, buf.len);
  			}
  			pfree(buf.data);
  		}
*************** void
*** 2642,2647 ****
--- 2708,2716 ----
  write_stderr(const char *fmt,...)
  {
  	va_list		ap;
+ #ifdef WIN32
+ 	char		errbuf[2048];		/* Arbitrary size? */
+ #endif
  
  	fmt = _(fmt);
  
*************** write_stderr(const char *fmt,...)
*** 2651,2656 ****
--- 2720,2726 ----
  	vfprintf(stderr, fmt, ap);
  	fflush(stderr);
  #else
+ 	vsnprintf(errbuf, sizeof(errbuf), fmt, ap);
  
  	/*
  	 * On Win32, we print to stderr if running on a console, or write to
*************** write_stderr(const char *fmt,...)
*** 2658,2673 ****
  	 */
  	if (pgwin32_is_service())	/* Running as a service */
  	{
! 		char		errbuf[2048];		/* Arbitrary size? */
! 
! 		vsnprintf(errbuf, sizeof(errbuf), fmt, ap);
! 
! 		write_eventlog(ERROR, errbuf);
  	}
  	else
  	{
  		/* Not running as service, write to stderr */
! 		vfprintf(stderr, fmt, ap);
  		fflush(stderr);
  	}
  #endif
--- 2728,2739 ----
  	 */
  	if (pgwin32_is_service())	/* Running as a service */
  	{
! 		write_eventlog(ERROR, errbuf, strlen(errbuf));
  	}
  	else
  	{
  		/* Not running as service, write to stderr */
! 		write_console(errbuf, strlen(errbuf));
  		fflush(stderr);
  	}
  #endif
diff -cprN head/src/backend/utils/mb/encnames.c work/src/backend/utils/mb/encnames.c
*** head/src/backend/utils/mb/encnames.c	2009-04-24 17:43:50.000000000 +0900
--- work/src/backend/utils/mb/encnames.c	2009-10-07 11:04:14.224280217 +0900
*************** sizeof(pg_encname_tbl) / sizeof(pg_encna
*** 303,432 ****
  pg_enc2name pg_enc2name_tbl[] =
  {
  	{
! 		"SQL_ASCII", PG_SQL_ASCII
  	},
  	{
! 		"EUC_JP", PG_EUC_JP
  	},
  	{
! 		"EUC_CN", PG_EUC_CN
  	},
  	{
! 		"EUC_KR", PG_EUC_KR
  	},
  	{
! 		"EUC_TW", PG_EUC_TW
  	},
  	{
! 		"EUC_JIS_2004", PG_EUC_JIS_2004
  	},
  	{
! 		"UTF8", PG_UTF8
  	},
  	{
! 		"MULE_INTERNAL", PG_MULE_INTERNAL
  	},
  	{
! 		"LATIN1", PG_LATIN1
  	},
  	{
! 		"LATIN2", PG_LATIN2
  	},
  	{
! 		"LATIN3", PG_LATIN3
  	},
  	{
! 		"LATIN4", PG_LATIN4
  	},
  	{
! 		"LATIN5", PG_LATIN5
  	},
  	{
! 		"LATIN6", PG_LATIN6
  	},
  	{
! 		"LATIN7", PG_LATIN7
  	},
  	{
! 		"LATIN8", PG_LATIN8
  	},
  	{
! 		"LATIN9", PG_LATIN9
  	},
  	{
! 		"LATIN10", PG_LATIN10
  	},
  	{
! 		"WIN1256", PG_WIN1256
  	},
  	{
! 		"WIN1258", PG_WIN1258
  	},
  	{
! 		"WIN866", PG_WIN866
  	},
  	{
! 		"WIN874", PG_WIN874
  	},
  	{
! 		"KOI8R", PG_KOI8R
  	},
  	{
! 		"WIN1251", PG_WIN1251
  	},
  	{
! 		"WIN1252", PG_WIN1252
  	},
  	{
! 		"ISO_8859_5", PG_ISO_8859_5
  	},
  	{
! 		"ISO_8859_6", PG_ISO_8859_6
  	},
  	{
! 		"ISO_8859_7", PG_ISO_8859_7
  	},
  	{
! 		"ISO_8859_8", PG_ISO_8859_8
  	},
  	{
! 		"WIN1250", PG_WIN1250
  	},
  	{
! 		"WIN1253", PG_WIN1253
  	},
  	{
! 		"WIN1254", PG_WIN1254
  	},
  	{
! 		"WIN1255", PG_WIN1255
  	},
  	{
! 		"WIN1257", PG_WIN1257
  	},
  	{
! 		"KOI8U", PG_KOI8U
  	},
  	{
! 		"SJIS", PG_SJIS
  	},
  	{
! 		"BIG5", PG_BIG5
  	},
  	{
! 		"GBK", PG_GBK
  	},
  	{
! 		"UHC", PG_UHC
  	},
  	{
! 		"GB18030", PG_GB18030
  	},
  	{
! 		"JOHAB", PG_JOHAB
  	},
  	{
! 		"SHIFT_JIS_2004", PG_SHIFT_JIS_2004
  	}
  };
  
--- 303,432 ----
  pg_enc2name pg_enc2name_tbl[] =
  {
  	{
! 		"SQL_ASCII", PG_SQL_ASCII, 0
  	},
  	{
! 		"EUC_JP", PG_EUC_JP, 20932
  	},
  	{
! 		"EUC_CN", PG_EUC_CN, 20936
  	},
  	{
! 		"EUC_KR", PG_EUC_KR, 51949
  	},
  	{
! 		"EUC_TW", PG_EUC_TW, 0
  	},
  	{
! 		"EUC_JIS_2004", PG_EUC_JIS_2004, 20932
  	},
  	{
! 		"UTF8", PG_UTF8, 65001
  	},
  	{
! 		"MULE_INTERNAL", PG_MULE_INTERNAL, 0
  	},
  	{
! 		"LATIN1", PG_LATIN1, 28591
  	},
  	{
! 		"LATIN2", PG_LATIN2, 28592
  	},
  	{
! 		"LATIN3", PG_LATIN3, 28593
  	},
  	{
! 		"LATIN4", PG_LATIN4, 28594
  	},
  	{
! 		"LATIN5", PG_LATIN5, 28599
  	},
  	{
! 		"LATIN6", PG_LATIN6, 0
  	},
  	{
! 		"LATIN7", PG_LATIN7, 0
  	},
  	{
! 		"LATIN8", PG_LATIN8, 0
  	},
  	{
! 		"LATIN9", PG_LATIN9, 28605
  	},
  	{
! 		"LATIN10", PG_LATIN10, 0
  	},
  	{
! 		"WIN1256", PG_WIN1256, 1256
  	},
  	{
! 		"WIN1258", PG_WIN1258, 1258
  	},
  	{
! 		"WIN866", PG_WIN866, 866
  	},
  	{
! 		"WIN874", PG_WIN874, 874
  	},
  	{
! 		"KOI8R", PG_KOI8R, 20866
  	},
  	{
! 		"WIN1251", PG_WIN1251, 1251
  	},
  	{
! 		"WIN1252", PG_WIN1252, 1252
  	},
  	{
! 		"ISO_8859_5", PG_ISO_8859_5, 28595
  	},
  	{
! 		"ISO_8859_6", PG_ISO_8859_6, 28596
  	},
  	{
! 		"ISO_8859_7", PG_ISO_8859_7, 28597
  	},
  	{
! 		"ISO_8859_8", PG_ISO_8859_8, 28598
  	},
  	{
! 		"WIN1250", PG_WIN1250, 1250
  	},
  	{
! 		"WIN1253", PG_WIN1253, 1253
  	},
  	{
! 		"WIN1254", PG_WIN1254, 1254
  	},
  	{
! 		"WIN1255", PG_WIN1255, 1255
  	},
  	{
! 		"WIN1257", PG_WIN1257, 1257
  	},
  	{
! 		"KOI8U", PG_KOI8U, 21866
  	},
  	{
! 		"SJIS", PG_SJIS, 932
  	},
  	{
! 		"BIG5", PG_BIG5, 950
  	},
  	{
! 		"GBK", PG_GBK, 936
  	},
  	{
! 		"UHC", PG_UHC, 0
  	},
  	{
! 		"GB18030", PG_GB18030, 54936
  	},
  	{
! 		"JOHAB", PG_JOHAB, 0
  	},
  	{
! 		"SHIFT_JIS_2004", PG_SHIFT_JIS_2004, 932
  	}
  };
  
diff -cprN head/src/backend/utils/mb/mbutils.c work/src/backend/utils/mb/mbutils.c
*** head/src/backend/utils/mb/mbutils.c	2009-07-08 04:28:56.000000000 +0900
--- work/src/backend/utils/mb/mbutils.c	2009-10-07 11:04:14.224280217 +0900
*************** static FmgrInfo *ToClientConvProc = NULL
*** 58,63 ****
--- 58,64 ----
   */
  static pg_enc2name *ClientEncoding = &pg_enc2name_tbl[PG_SQL_ASCII];
  static pg_enc2name *DatabaseEncoding = &pg_enc2name_tbl[PG_SQL_ASCII];
+ static pg_enc2name *PlatformEncoding = NULL;
  
  /*
   * During backend startup we can't set client encoding because we (a)
*************** pg_client_encoding(PG_FUNCTION_ARGS)
*** 978,980 ****
--- 979,1041 ----
  	Assert(ClientEncoding);
  	return DirectFunctionCall1(namein, CStringGetDatum(ClientEncoding->name));
  }
+ 
+ int
+ GetPlatformEncoding(void)
+ {
+ 	if (PlatformEncoding == NULL)
+ 		PlatformEncoding = &pg_enc2name_tbl[pg_get_encoding_from_locale("")];
+ 	return PlatformEncoding->encoding;
+ }
+ 
+ #ifdef WIN32
+ 
+ /*
+  * Result is palloc'ed null-terminated utf16 string. The character length
+  * is also passed to utf16len if not null. Returns NULL iff failed.
+  */
+ WCHAR *
+ pgwin32_toUTF16(const char *str, int len, int *utf16len)
+ {
+ 	WCHAR	   *utf16;
+ 	int			dstlen;
+ 	UINT		codepage;
+ 
+ 	codepage = pg_enc2name_tbl[GetDatabaseEncoding()].codepage;
+ 
+ 	/*
+ 	 * Use MultiByteToWideChar directly if there is a corresponding codepage,
+ 	 * or double conversion through UTF8.
+ 	 */
+ 	if (codepage != 0)
+ 	{
+ 		utf16 = (WCHAR *) palloc(sizeof(WCHAR) * (len + 1));
+ 		dstlen = MultiByteToWideChar(codepage, 0, str, len, utf16, len);
+ 		utf16[dstlen] = L'\0';
+ 	}
+ 	else
+ 	{
+ 		char	   *utf8;
+ 
+ 		utf8 = (char *) pg_do_encoding_conversion((unsigned char *) str,
+ 										len, GetDatabaseEncoding(), PG_UTF8);
+ 		if (utf8 != str)
+ 			len = strlen(utf8);
+ 
+ 		utf16 = (WCHAR *) palloc(sizeof(WCHAR) * (len + 1));
+ 		dstlen = MultiByteToWideChar(CP_UTF8, 0, utf8, len, utf16, len);
+ 		utf16[dstlen] = L'\0';
+ 
+ 		if (utf8 != str)
+ 			pfree(utf8);
+ 	}
+ 
+ 	if (dstlen == 0 && len > 0)
+ 		return NULL;	/* error */
+ 
+ 	if (utf16len)
+ 		*utf16len = len;
+ 	return utf16;
+ }
+ 
+ #endif
diff -cprN head/src/include/mb/pg_wchar.h work/src/include/mb/pg_wchar.h
*** head/src/include/mb/pg_wchar.h	2009-06-11 23:49:11.000000000 +0900
--- work/src/include/mb/pg_wchar.h	2009-10-07 11:04:14.225327260 +0900
*************** typedef struct pg_enc2name
*** 257,262 ****
--- 257,263 ----
  {
  	char	   *name;
  	pg_enc		encoding;
+ 	unsigned	codepage;	/* codepage for WIN32 */
  } pg_enc2name;
  
  extern pg_enc2name pg_enc2name_tbl[];
*************** extern const char *pg_get_client_encodin
*** 402,407 ****
--- 403,409 ----
  extern void SetDatabaseEncoding(int encoding);
  extern int	GetDatabaseEncoding(void);
  extern const char *GetDatabaseEncodingName(void);
+ extern int	GetPlatformEncoding(void);
  extern void pg_bind_textdomain_codeset(const char *domainname);
  
  extern int	pg_valid_client_encoding(const char *name);
*************** extern void mic2latin_with_table(const u
*** 458,461 ****
--- 460,467 ----
  
  extern bool pg_utf8_islegal(const unsigned char *source, int length);
  
+ #ifdef WIN32
+ extern WCHAR *pgwin32_toUTF16(const char *str, int len, int *utf16len);
+ #endif
+ 
  #endif   /* PG_WCHAR_H */