trouble with to_char('L')

Index: pg_locale.c
===================================================================
RCS file: /projects/cvsroot/pgsql/src/backend/utils/adt/pg_locale.c,v
retrieving revision 1.49
diff -c -c -r1.49 pg_locale.c
*** pg_locale.c	1 Apr 2009 09:17:32 -0000	1.49
--- pg_locale.c	22 Apr 2009 21:08:33 -0000
***************
*** 386,391 ****
--- 386,449 ----
  		free(s->positive_sign);
  }
  
+ #ifdef	WIN32
+ #define	MAX_BYTES_PER_CHARACTER	4
+ static char *dbstr_win32(bool matchenc, const char *str)
+ {
+ 	int	encoding = GetDatabaseEncoding();
+ 	bool	is_ascii = true;
+ 	size_t	len, ilen, wclen, dstlen;
+ 	wchar_t	*wbuf;
+ 	char	*dst, *ibuf;
+ 
+ 	if (matchenc)
+ 		return strdup(str);
+ 	/* Is the str an ascii string ? */
+ 	for (ibuf = str; *ibuf; ibuf++)
+ 	{
+ 		if (!isascii(*ibuf))
+ 		{
+ 			is_ascii = false;
+ 			break;
+ 		}
+ 	}
+ 	/* Simply returns the strdup()ed ascii string */
+ 	if (is_ascii)
+ 		return strdup(str);
+ 
+ 	ilen = strlen(str) + 1;
+ 	wclen = ilen * sizeof(wchar_t);
+ 	wbuf = (wchar_t *) palloc(wclen);
+ 	len = mbstowcs(wbuf, str, ilen);
+ 	if (len == -1)
+ 		elog(ERROR,
+ 			"could not convert string to Wide characters:error %lu", GetLastError());
+ 
+ 	dstlen = len * MAX_BYTES_PER_CHARACTER + 1;
+ 	dst = malloc(dstlen);
+   
+ 	len = WideCharToMultiByte(CP_UTF8, 0, wbuf, len, dst, dstlen, NULL, NULL);
+ 	pfree(wbuf);
+ 	if (len == 0)
+ 		elog(ERROR,
+ 			"could not convert string to UTF-8:error %lu", GetLastError());
+ 
+ 	dst[len] = '\0';
+ 	if (encoding != PG_UTF8)
+ 	{
+ 		char *convstr = pg_do_encoding_conversion(dst, len, PG_UTF8, encoding);
+ 		if (dst != convstr)
+ 		{
+ 			strlcpy(dst, convstr, dstlen);
+ 			pfree(convstr);
+ 		}
+ 	}
+ 
+ 	return dst;
+ }
+ 
+ #define	strdup(str)	dbstr_win32(is_encoding_match, str)
+ #endif /* WIN32 */
  
  /*
   * Return the POSIX lconv struct (contains number/money formatting
***************
*** 398,403 ****
--- 456,466 ----
  	struct lconv *extlconv;
  	char	   *save_lc_monetary;
  	char	   *save_lc_numeric;
+ #ifdef	WIN32
+ 	char	   *save_lc_ctype = NULL;
+ 	bool	lc_ctype_change = false, is_encoding_match;
+ #endif /* WIN32 */
+ 
  
  	/* Did we do it already? */
  	if (CurrentLocaleConvValid)
***************
*** 413,418 ****
--- 476,492 ----
  	if (save_lc_numeric)
  		save_lc_numeric = pstrdup(save_lc_numeric);
  
+ #ifdef	WIN32
+ 	save_lc_ctype = setlocale(LC_CTYPE, NULL);
+ 	if (save_lc_ctype && stricmp(locale_monetary, save_lc_ctype) != 0)
+ 	{
+ 		lc_ctype_change = true;
+ 		save_lc_ctype = pstrdup(save_lc_ctype);
+ 		setlocale(LC_CTYPE, locale_monetary);
+ 	}
+ 	is_encoding_match = (pg_get_encoding_from_locale(locale_monetary) == GetDatabaseEncoding());
+ #endif
+ 
  	setlocale(LC_MONETARY, locale_monetary);
  	setlocale(LC_NUMERIC, locale_numeric);
  
***************
*** 437,442 ****
--- 511,524 ----
  	CurrentLocaleConv.n_sign_posn = extlconv->n_sign_posn;
  
  	/* Try to restore internal settings */
+ #ifdef	WIN32
+ #undef	strdup
+ 	if (lc_ctype_change)
+ 	{
+ 		setlocale(LC_CTYPE, save_lc_ctype);
+ 		pfree(save_lc_ctype);
+ 	}
+ #endif /* WIN32 */
  	if (save_lc_monetary)
  	{
  		setlocale(LC_MONETARY, save_lc_monetary);

? formatting.patch
? pg_locale.patch
? pg_locale_20081221.patch
? pg_locale_20090120.patch
? pg_locale_20090422.patch
? pg_locale_20090423.patch
? pg_locale_20090427.patch
? pg_locale_20090608.patch
? pg_locale_20090901.patch
? pg_locale_with_debug.c
Index: pg_locale.c
===================================================================
RCS file: /projects/cvsroot/pgsql/src/backend/utils/adt/pg_locale.c,v
retrieving revision 1.51
diff -c -c -r1.51 pg_locale.c
*** pg_locale.c	2 Jan 2010 16:57:54 -0000	1.51
--- pg_locale.c	26 Feb 2010 22:43:52 -0000
***************
*** 386,391 ****
--- 386,449 ----
  		free(s->positive_sign);
  }
  
+ #ifdef	WIN32
+ static char *db_strdup(const char *item, const char *str)
+ {
+ 	int	encoding = GetDatabaseEncoding();
+ 	size_t	wchars, ilen, wclen, dstlen;
+ 	int	utflen, bytes_per_char;
+ 	wchar_t	*wbuf;
+ 	char	*dst;
+ 
+ 	if (!str[0])
+ 		return strdup(str);
+ 	ilen = strlen(str) + 1;
+ 	wclen = ilen * sizeof(wchar_t);
+ 	wbuf = (wchar_t *) palloc(wclen);
+ 	wchars = mbstowcs(wbuf, str, ilen);
+ 	if (wchars == (size_t) -1)
+ 		elog(ERROR,
+ 			"could not convert string to Wide characters:error %lu", GetLastError());
+ 
+ 	bytes_per_char = pg_encoding_max_length(PG_UTF8);
+ 	if (pg_encoding_max_length(encoding) > bytes_per_char)
+ 		bytes_per_char = pg_encoding_max_length(encoding);
+ 	dstlen = wchars * bytes_per_char + 1;
+ 	dst = malloc(dstlen);
+ 	if (dst == NULL)
+ 		elog(ERROR, "could not allocate a destination buffer");
+   
+ 	utflen = WideCharToMultiByte(CP_UTF8, 0, wbuf, wchars, dst, dstlen, NULL, NULL);
+ 	if (utflen == 0)
+ 		elog(ERROR,
+ 			"could not convert string %04x to UTF-8:error %lu", wbuf[0], GetLastError());
+ 	pfree(wbuf);
+ 
+ 	dst[utflen] = '\0';
+ 	if (encoding != PG_UTF8)
+ 	{
+ 		PG_TRY();
+ 		{
+ 			char *convstr = pg_do_encoding_conversion(dst, utflen, PG_UTF8, encoding);
+ 			if (dst != convstr)
+ 			{
+ 				strlcpy(dst, convstr, dstlen);
+ 				pfree(convstr);
+ 			}
+ 		}
+ 		PG_CATCH();
+ 		{
+ 			FlushErrorState();
+ 			dst[0] = '\0';
+ 		}
+ 		PG_END_TRY();
+ 	}
+ 
+ 	return dst;
+ }
+ #else
+ static char *db_strdup(const char *item, const char *str)	{return strdup(str);}
+ #endif /* WIN32 */
  
  /*
   * Return the POSIX lconv struct (contains number/money formatting
***************
*** 398,403 ****
--- 456,463 ----
  	struct lconv *extlconv;
  	char	   *save_lc_monetary;
  	char	   *save_lc_numeric;
+ 	bool	change_lc_ctype = false, is_same_locale = true;
+ 	char	*save_lc_ctype = NULL;
  
  	/* Did we do it already? */
  	if (CurrentLocaleConvValid)
***************
*** 413,422 ****
  	if (save_lc_numeric)
  		save_lc_numeric = pstrdup(save_lc_numeric);
  
  	setlocale(LC_MONETARY, locale_monetary);
! 	setlocale(LC_NUMERIC, locale_numeric);
  
! 	/* Get formatting information */
  	extlconv = localeconv();
  
  	/*
--- 473,496 ----
  	if (save_lc_numeric)
  		save_lc_numeric = pstrdup(save_lc_numeric);
  
+ #ifdef	WIN32
+ 	is_same_locale = (stricmp(locale_monetary, locale_numeric) == 0);
+ 	save_lc_ctype = setlocale(LC_CTYPE, NULL);
+ 	if (!is_same_locale || save_lc_ctype == NULL || stricmp(locale_monetary, save_lc_ctype) != 0)
+ 		change_lc_ctype = true;
+ 	if (change_lc_ctype && save_lc_ctype)
+ 		save_lc_ctype = pstrdup(save_lc_ctype);
+ 	else
+ 		save_lc_ctype = NULL;
+ #endif
+ 
+ 	if (change_lc_ctype)
+ 		setlocale(LC_CTYPE, locale_monetary);
  	setlocale(LC_MONETARY, locale_monetary);
! 	if (is_same_locale)
! 		setlocale(LC_NUMERIC, locale_numeric);
  
! 	/* Get formatting information for LC_MONETARY( and LC_NUMERIC when they are the same) */
  	extlconv = localeconv();
  
  	/*
***************
*** 424,442 ****
  	 * localeconv()'s results.
  	 */
  	CurrentLocaleConv = *extlconv;
! 	CurrentLocaleConv.currency_symbol = strdup(extlconv->currency_symbol);
! 	CurrentLocaleConv.decimal_point = strdup(extlconv->decimal_point);
! 	CurrentLocaleConv.grouping = strdup(extlconv->grouping);
! 	CurrentLocaleConv.thousands_sep = strdup(extlconv->thousands_sep);
! 	CurrentLocaleConv.int_curr_symbol = strdup(extlconv->int_curr_symbol);
! 	CurrentLocaleConv.mon_decimal_point = strdup(extlconv->mon_decimal_point);
  	CurrentLocaleConv.mon_grouping = strdup(extlconv->mon_grouping);
! 	CurrentLocaleConv.mon_thousands_sep = strdup(extlconv->mon_thousands_sep);
! 	CurrentLocaleConv.negative_sign = strdup(extlconv->negative_sign);
! 	CurrentLocaleConv.positive_sign = strdup(extlconv->positive_sign);
  	CurrentLocaleConv.n_sign_posn = extlconv->n_sign_posn;
  
  	/* Try to restore internal settings */
  	if (save_lc_monetary)
  	{
  		setlocale(LC_MONETARY, save_lc_monetary);
--- 498,528 ----
  	 * localeconv()'s results.
  	 */
  	CurrentLocaleConv = *extlconv;
! 	CurrentLocaleConv.currency_symbol = db_strdup("currency_symbol", extlconv->currency_symbol);
! 	CurrentLocaleConv.int_curr_symbol = db_strdup("int_curr_symbol", extlconv->int_curr_symbol);
! 	CurrentLocaleConv.mon_decimal_point = db_strdup("mon_decimal_point", extlconv->mon_decimal_point);
  	CurrentLocaleConv.mon_grouping = strdup(extlconv->mon_grouping);
! 	CurrentLocaleConv.mon_thousands_sep = db_strdup("mon_thousands_sep", extlconv->mon_thousands_sep);
! 	CurrentLocaleConv.negative_sign = db_strdup("nagative_sign", extlconv->negative_sign);
! 	CurrentLocaleConv.positive_sign = db_strdup("positive_sign", extlconv->positive_sign);
  	CurrentLocaleConv.n_sign_posn = extlconv->n_sign_posn;
  
+ 	if (!is_same_locale)
+ 	{
+ 		setlocale(LC_CTYPE, locale_numeric);
+ 		setlocale(LC_NUMERIC, locale_numeric);
+ 		/* Get formatting information for LC_NUMERIC */
+ 		extlconv = localeconv();
+ 	}
+ 	CurrentLocaleConv.decimal_point = db_strdup("decimal_point", extlconv->decimal_point);
+ 	CurrentLocaleConv.grouping = strdup(extlconv->grouping);
+ 	CurrentLocaleConv.thousands_sep = db_strdup("thousands_sep", extlconv->thousands_sep);
  	/* Try to restore internal settings */
+ 	if (save_lc_ctype)
+ 	{
+ 		setlocale(LC_CTYPE, save_lc_ctype);
+ 		pfree(save_lc_ctype);
+ 	}
  	if (save_lc_monetary)
  	{
  		setlocale(LC_MONETARY, save_lc_monetary);

Index: src/backend/utils/adt/pg_locale.c
===================================================================
RCS file: /cvsroot/pgsql/src/backend/utils/adt/pg_locale.c,v
retrieving revision 1.53
diff -c -c -r1.53 pg_locale.c
*** src/backend/utils/adt/pg_locale.c	27 Feb 2010 20:20:44 -0000	1.53
--- src/backend/utils/adt/pg_locale.c	28 Feb 2010 03:59:14 -0000
***************
*** 4,10 ****
   *
   * Portions Copyright (c) 2002-2010, PostgreSQL Global Development Group
   *
!  * $PostgreSQL: pgsql/src/backend/utils/adt/pg_locale.c,v 1.53 2010/02/27 20:20:44 momjian Exp $
   *
   *-----------------------------------------------------------------------
   */
--- 4,10 ----
   *
   * Portions Copyright (c) 2002-2010, PostgreSQL Global Development Group
   *
!  * $PostgreSQL: pgsql/src/backend/utils/adt/pg_locale.c,v 1.51 2010/01/02 16:57:54 momjian Exp $
   *
   *-----------------------------------------------------------------------
   */
***************
*** 386,391 ****
--- 386,459 ----
  		free(s->positive_sign);
  }
  
+ #ifdef	WIN32
+ /*
+  *	This converts the LC_CTYPE-encoded string returned from the
+  *	locale routines to the database encoding.
+  */
+ static char *db_encoding_strdup(const char *item, const char *str)
+ {
+ 	int	db_encoding = GetDatabaseEncoding();
+ 	size_t	wchars, ilen, wclen, dstlen;
+ 	int	utflen, bytes_per_char;
+ 	wchar_t	*wbuf;
+ 	char	*dst;
+ 
+ 	if (!str[0])
+ 		return strdup(str);
+ 	ilen = strlen(str) + 1;
+ 	wclen = ilen * sizeof(wchar_t);
+ 	wbuf = (wchar_t *) palloc(wclen);
+ 
+ 	/* Convert multi-byte string using current LC_CTYPE to a wide-character string */
+ 	wchars = mbstowcs(wbuf, str, ilen);
+ 	if (wchars == (size_t) -1)
+ 		elog(ERROR,
+ 			"could not convert string to wide characters: error %lu", GetLastError());
+ 
+ 	/* allocate target string */
+ 	bytes_per_char = pg_encoding_max_length(PG_UTF8);
+ 	if (pg_encoding_max_length(db_encoding) > bytes_per_char)
+ 		bytes_per_char = pg_encoding_max_length(db_encoding);
+ 	dstlen = wchars * bytes_per_char + 1;
+ 	if ((dst = malloc(dstlen)) == NULL)
+ 		elog(ERROR, "could not allocate a destination buffer");
+ 
+ 	/* Convert wide string to UTF8 */  
+ 	utflen = WideCharToMultiByte(CP_UTF8, 0, wbuf, wchars, dst, dstlen, NULL, NULL);
+ 	if (utflen == 0)
+ 		elog(ERROR,
+ 			"could not convert string %04x to UTF-8: error %lu", wbuf[0], GetLastError());
+ 	pfree(wbuf);
+ 
+ 	dst[utflen] = '\0';
+ 	if (db_encoding != PG_UTF8)
+ 	{
+ 		PG_TRY();
+ 		{
+ 			char *convstr = pg_do_encoding_conversion(dst, utflen, PG_UTF8, db_encoding);
+ 			if (dst != convstr)
+ 			{
+ 				strlcpy(dst, convstr, dstlen);
+ 				pfree(convstr);
+ 			}
+ 		}
+ 		PG_CATCH();
+ 		{
+ 			FlushErrorState();
+ 			dst[0] = '\0';
+ 		}
+ 		PG_END_TRY();
+ 	}
+ 
+ 	return dst;
+ }
+ #else
+ static char *db_encoding_strdup(const char *item, const char *str)
+ {
+ 	return strdup(str);
+ }
+ #endif /* WIN32 */
  
  /*
   * Return the POSIX lconv struct (contains number/money formatting
***************
*** 398,403 ****
--- 466,475 ----
  	struct lconv *extlconv;
  	char	   *save_lc_monetary;
  	char	   *save_lc_numeric;
+ #ifdef	WIN32
+ 	char	   *save_lc_ctype = NULL;
+ 	bool		lc_ctype_was_null = false;
+ #endif
  
  	/* Did we do it already? */
  	if (CurrentLocaleConvValid)
***************
*** 413,442 ****
  	if (save_lc_numeric)
  		save_lc_numeric = pstrdup(save_lc_numeric);
  
  	setlocale(LC_MONETARY, locale_monetary);
  	setlocale(LC_NUMERIC, locale_numeric);
! 
! 	/* Get formatting information */
  	extlconv = localeconv();
  
  	/*
! 	 * Must copy all values since restoring internal settings may overwrite
  	 * localeconv()'s results.
  	 */
  	CurrentLocaleConv = *extlconv;
! 	CurrentLocaleConv.currency_symbol = strdup(extlconv->currency_symbol);
! 	CurrentLocaleConv.decimal_point = strdup(extlconv->decimal_point);
! 	CurrentLocaleConv.grouping = strdup(extlconv->grouping);
! 	CurrentLocaleConv.thousands_sep = strdup(extlconv->thousands_sep);
! 	CurrentLocaleConv.int_curr_symbol = strdup(extlconv->int_curr_symbol);
! 	CurrentLocaleConv.mon_decimal_point = strdup(extlconv->mon_decimal_point);
  	CurrentLocaleConv.mon_grouping = strdup(extlconv->mon_grouping);
! 	CurrentLocaleConv.mon_thousands_sep = strdup(extlconv->mon_thousands_sep);
! 	CurrentLocaleConv.negative_sign = strdup(extlconv->negative_sign);
! 	CurrentLocaleConv.positive_sign = strdup(extlconv->positive_sign);
  	CurrentLocaleConv.n_sign_posn = extlconv->n_sign_posn;
  
! 	/* Try to restore internal settings */
  	if (save_lc_monetary)
  	{
  		setlocale(LC_MONETARY, save_lc_monetary);
--- 485,564 ----
  	if (save_lc_numeric)
  		save_lc_numeric = pstrdup(save_lc_numeric);
  
+ #ifdef	WIN32
+ 	/*
+ 	 *	Ideally, the server encoding and locale settings would
+ 	 *	always match.  Unfortunately, WIN32 does not support UTF-8
+ 	 *	values for setlocale(), even though PostgreSQL runs fine with
+ 	 *	a UTF-8 encoding on Windows:
+ 	 *
+ 	 *		http://msdn.microsoft.com/en-us/library/x99tb11d.aspx
+ 	 *
+ 	 *	Therefore, we must set LC_CTYPE to match LC_NUMERIC and 
+ 	 *	LC_MONETARY, call localeconv(), and use mbstowcs() to
+ 	 *	convert the locale-aware string, e.g. Euro symbol, which
+ 	 *	is not in UTF-8 to the server encoding.
+ 	 */
+ 
+ 	/*
+ 	 *	We unconditionally restore LC_CTYPE because we are setting it
+ 	 *	to an unusual value.
+ 	 */
+ 	if ((save_lc_ctype = setlocale(LC_CTYPE, NULL)) != NULL)
+ 		save_lc_ctype = pstrdup(save_lc_ctype);
+ 	else
+ 		/* This is actually the C locale */
+ 		save_lc_ctype = pstrdup("");
+ 
+ 	/* Set LC_CTYPE to match LC_MONETARY? */
+ 	if (pg_strcasecmp(save_lc_ctype, locale_monetary) != 0)
+ 		setlocale(LC_CTYPE, locale_monetary);
+ #endif
+ 
  	setlocale(LC_MONETARY, locale_monetary);
  	setlocale(LC_NUMERIC, locale_numeric);
! 	/*
! 	 *	Get formatting information for LC_MONETARY, and LC_NUMERIC if they
! 	 *	are the same.
! 	 */
  	extlconv = localeconv();
  
  	/*
! 	 * Must copy all values since restoring internal settings might overwrite
  	 * localeconv()'s results.
  	 */
  	CurrentLocaleConv = *extlconv;
! 
! 	/* The first argument of db_encoding_strdup() is only used on WIN32 */
! 	CurrentLocaleConv.currency_symbol = db_encoding_strdup("currency_symbol", extlconv->currency_symbol);
! 	CurrentLocaleConv.int_curr_symbol = db_encoding_strdup("int_curr_symbol", extlconv->int_curr_symbol);
! 	CurrentLocaleConv.mon_decimal_point = db_encoding_strdup("mon_decimal_point", extlconv->mon_decimal_point);
  	CurrentLocaleConv.mon_grouping = strdup(extlconv->mon_grouping);
! 	CurrentLocaleConv.mon_thousands_sep = db_encoding_strdup("mon_thousands_sep", extlconv->mon_thousands_sep);
! 	CurrentLocaleConv.negative_sign = db_encoding_strdup("negative_sign", extlconv->negative_sign);
! 	CurrentLocaleConv.positive_sign = db_encoding_strdup("positive_sign", extlconv->positive_sign);
  	CurrentLocaleConv.n_sign_posn = extlconv->n_sign_posn;
  
! #ifdef	WIN32
! 	if (pg_strcasecmp(locale_numeric, locale_monetary) != 0)
! 	{
! 		setlocale(LC_CTYPE, locale_numeric);
! 		/* Get formatting information for LC_NUMERIC with matching LC_CTYPE */
! 		extlconv = localeconv();
! 	}
! #endif
! 
! 	CurrentLocaleConv.decimal_point = db_encoding_strdup("decimal_point", extlconv->decimal_point);
! 	CurrentLocaleConv.grouping = strdup(extlconv->grouping);
! 	CurrentLocaleConv.thousands_sep = db_encoding_strdup("thousands_sep", extlconv->thousands_sep);
! 
! 	/*
! 	 *	Restore internal settings
! 	 */
! #ifdef	WIN32
! 	setlocale(LC_CTYPE, save_lc_ctype);
! 	pfree(save_lc_ctype);
! #endif
  	if (save_lc_monetary)
  	{
  		setlocale(LC_MONETARY, save_lc_monetary);
***************
*** 533,542 ****
  	elog(DEBUG3, "cache_locale_time() executed; locale: \"%s\"", locale_time);
  
  #ifdef WIN32
! 	/* set user's value of ctype locale */
  	save_lc_ctype = setlocale(LC_CTYPE, NULL);
  	if (save_lc_ctype)
  		save_lc_ctype = pstrdup(save_lc_ctype);
  
  	setlocale(LC_CTYPE, locale_time);
  #endif
--- 655,666 ----
  	elog(DEBUG3, "cache_locale_time() executed; locale: \"%s\"", locale_time);
  
  #ifdef WIN32
! 	/* See the WIN32 comment near the top of PGLC_localeconv() */
  	save_lc_ctype = setlocale(LC_CTYPE, NULL);
  	if (save_lc_ctype)
  		save_lc_ctype = pstrdup(save_lc_ctype);
+ 	else
+ 		save_lc_ctype = pstrdup("");
  
  	setlocale(LC_CTYPE, locale_time);
  #endif

Index: src/backend/utils/adt/pg_locale.c
===================================================================
RCS file: /cvsroot/pgsql/src/backend/utils/adt/pg_locale.c,v
retrieving revision 1.53
diff -c -c -r1.53 pg_locale.c
*** src/backend/utils/adt/pg_locale.c	27 Feb 2010 20:20:44 -0000	1.53
--- src/backend/utils/adt/pg_locale.c	2 Mar 2010 18:11:41 -0000
***************
*** 4,10 ****
   *
   * Portions Copyright (c) 2002-2010, PostgreSQL Global Development Group
   *
!  * $PostgreSQL: pgsql/src/backend/utils/adt/pg_locale.c,v 1.53 2010/02/27 20:20:44 momjian Exp $
   *
   *-----------------------------------------------------------------------
   */
--- 4,10 ----
   *
   * Portions Copyright (c) 2002-2010, PostgreSQL Global Development Group
   *
!  * $PostgreSQL: pgsql/src/backend/utils/adt/pg_locale.c,v 1.51 2010/01/02 16:57:54 momjian Exp $
   *
   *-----------------------------------------------------------------------
   */
***************
*** 96,101 ****
--- 96,109 ----
  static char *IsoLocaleName(const char *);		/* MSVC specific */
  #endif
  
+ #ifdef WIN32
+ static size_t win32_wchar_to_db_encoding(const wchar_t *wbuf,
+ 								const size_t wchars, char *dst, size_t dstlen);
+ static char *db_encoding_strdup(const char *item, const char *str);
+ static size_t strftime_win32(char *dst, size_t dstlen, const wchar_t *format,
+ 							 const struct tm *tm);
+ #endif
+ 
  
  /*
   * pg_perm_setlocale
***************
*** 387,392 ****
--- 395,488 ----
  }
  
  
+ #ifdef	WIN32
+ /*
+  *	Convert wide character string (UTF16 on Win32) to UTF8, and then
+  *	optionally to the db encoding.
+  */
+ static size_t win32_wchar_to_db_encoding(const wchar_t *wbuf,
+ 								const size_t wchars, char *dst, size_t dstlen)
+ {
+ 	int	db_encoding = GetDatabaseEncoding();
+ 	int	utf8len;
+ 
+ 	/* Convert wide string (UTF16) to UTF8 */
+ 	utf8len = WideCharToMultiByte(CP_UTF8, 0, wbuf, wchars, dst, dstlen, NULL, NULL);
+ 	if (utf8len == 0)
+ 		/* Does this leave LC_CTYPE set incorrectly? */
+ 		elog(ERROR,
+ 			"could not convert string %04x to UTF-8: error %lu", wbuf[0], GetLastError());
+ 	pfree(wbuf);
+ 
+ 	dst[utf8len] = '\0';
+ 	if (db_encoding != PG_UTF8)
+ 	{
+ 		PG_TRY();
+ 		{
+ 			char *convstr = pg_do_encoding_conversion(dst, utf8len, PG_UTF8, db_encoding);
+ 			if (dst != convstr)
+ 			{
+ 				strlcpy(dst, convstr, dstlen);
+ 				pfree(convstr);
+ 			}
+ 		}
+ 		PG_CATCH();
+ 		{
+ 			FlushErrorState();
+ 			dst[0] = '\0';
+ 		}
+ 		PG_END_TRY();
+ 	}
+ 
+ 	return pg_mbstrlen(dst);
+ }
+ 
+ /*
+  *	This converts the LC_CTYPE-encoded string returned from the
+  *	locale routines to the database encoding.
+  */
+ static char *db_encoding_strdup(const char *item, const char *str)
+ {
+ 	int	db_encoding = GetDatabaseEncoding();
+ 	size_t	wchars, ilen, wclen, dstlen;
+ 	int	bytes_per_char;
+ 	wchar_t	*wbuf;
+ 	char	*dst;
+ 
+ 	if (!str[0])
+ 		return strdup(str);
+ 
+ 	/* allocate wide character string */
+ 	ilen = strlen(str) + 1;
+ 	wclen = ilen * sizeof(wchar_t);
+ 	wbuf = (wchar_t *) palloc(wclen);
+ 
+ 	/* Convert multi-byte string using current LC_CTYPE to a wide-character string */
+ 	wchars = mbstowcs(wbuf, str, ilen);
+ 	if (wchars == (size_t) -1)
+ 		elog(ERROR,
+ 			"could not convert string to wide characters: error %lu", GetLastError());
+ 
+ 	/* allocate target string */
+ 	bytes_per_char = pg_encoding_max_length(PG_UTF8);
+ 	if (pg_encoding_max_length(db_encoding) > bytes_per_char)
+ 		bytes_per_char = pg_encoding_max_length(db_encoding);
+ 	dstlen = wchars * bytes_per_char + 1;
+ 	if ((dst = malloc(dstlen)) == NULL)
+ 		elog(ERROR, "could not allocate a destination buffer");
+ 
+ 	/* Convert wide string (UTF16) to db encoding */
+ 	win32_wchar_to_db_encoding(wbuf, wchars, dst, dstlen);
+ 
+ 	return dst;
+ }
+ #else
+ static char *db_encoding_strdup(const char *item, const char *str)
+ {
+ 	return strdup(str);
+ }
+ #endif /* WIN32 */
+ 
  /*
   * Return the POSIX lconv struct (contains number/money formatting
   * information) with locale information for all categories.
***************
*** 398,403 ****
--- 494,502 ----
  	struct lconv *extlconv;
  	char	   *save_lc_monetary;
  	char	   *save_lc_numeric;
+ #ifdef	WIN32
+ 	char	   *save_lc_ctype = NULL;
+ #endif
  
  	/* Did we do it already? */
  	if (CurrentLocaleConvValid)
***************
*** 413,442 ****
  	if (save_lc_numeric)
  		save_lc_numeric = pstrdup(save_lc_numeric);
  
  	setlocale(LC_MONETARY, locale_monetary);
  	setlocale(LC_NUMERIC, locale_numeric);
! 
! 	/* Get formatting information */
  	extlconv = localeconv();
  
  	/*
! 	 * Must copy all values since restoring internal settings may overwrite
  	 * localeconv()'s results.
  	 */
  	CurrentLocaleConv = *extlconv;
! 	CurrentLocaleConv.currency_symbol = strdup(extlconv->currency_symbol);
! 	CurrentLocaleConv.decimal_point = strdup(extlconv->decimal_point);
! 	CurrentLocaleConv.grouping = strdup(extlconv->grouping);
! 	CurrentLocaleConv.thousands_sep = strdup(extlconv->thousands_sep);
! 	CurrentLocaleConv.int_curr_symbol = strdup(extlconv->int_curr_symbol);
! 	CurrentLocaleConv.mon_decimal_point = strdup(extlconv->mon_decimal_point);
  	CurrentLocaleConv.mon_grouping = strdup(extlconv->mon_grouping);
! 	CurrentLocaleConv.mon_thousands_sep = strdup(extlconv->mon_thousands_sep);
! 	CurrentLocaleConv.negative_sign = strdup(extlconv->negative_sign);
! 	CurrentLocaleConv.positive_sign = strdup(extlconv->positive_sign);
  	CurrentLocaleConv.n_sign_posn = extlconv->n_sign_posn;
  
! 	/* Try to restore internal settings */
  	if (save_lc_monetary)
  	{
  		setlocale(LC_MONETARY, save_lc_monetary);
--- 512,588 ----
  	if (save_lc_numeric)
  		save_lc_numeric = pstrdup(save_lc_numeric);
  
+ #ifdef	WIN32
+ 	/*
+ 	 *	Ideally, the db server encoding and locale settings would
+ 	 *	always match.  Unfortunately, WIN32 does not support UTF-8
+ 	 *	values for setlocale(), even though PostgreSQL runs fine with
+ 	 *	a UTF-8 encoding on Windows:
+ 	 *
+ 	 *		http://msdn.microsoft.com/en-us/library/x99tb11d.aspx
+ 	 *
+ 	 *	Therefore, we must set LC_CTYPE to match LC_NUMERIC and 
+ 	 *	LC_MONETARY, call localeconv(), and use mbstowcs() to
+ 	 *	convert the locale-aware string, e.g. Euro symbol, which
+ 	 *	is not in UTF-8 to the server encoding.
+ 	 */
+ 
+ 	if ((save_lc_ctype = setlocale(LC_CTYPE, NULL)) != NULL)
+ 	{
+ 		save_lc_ctype = pstrdup(save_lc_ctype);
+ 		/* Set LC_CTYPE to match LC_MONETARY? */
+ 		if (pg_strcasecmp(save_lc_ctype, locale_monetary) != 0)
+ 			setlocale(LC_CTYPE, locale_monetary);
+ 	}
+ #endif
+ 
  	setlocale(LC_MONETARY, locale_monetary);
  	setlocale(LC_NUMERIC, locale_numeric);
! 	/*
! 	 *	Get formatting information for LC_MONETARY, and LC_NUMERIC if they
! 	 *	are the same.
! 	 */
  	extlconv = localeconv();
  
  	/*
! 	 * Must copy all values since restoring internal settings might overwrite
  	 * localeconv()'s results.
  	 */
  	CurrentLocaleConv = *extlconv;
! 
! 	/* The first argument of db_encoding_strdup() is only used on WIN32 */
! 	CurrentLocaleConv.currency_symbol = db_encoding_strdup("currency_symbol", extlconv->currency_symbol);
! 	CurrentLocaleConv.int_curr_symbol = db_encoding_strdup("int_curr_symbol", extlconv->int_curr_symbol);
! 	CurrentLocaleConv.mon_decimal_point = db_encoding_strdup("mon_decimal_point", extlconv->mon_decimal_point);
  	CurrentLocaleConv.mon_grouping = strdup(extlconv->mon_grouping);
! 	CurrentLocaleConv.mon_thousands_sep = db_encoding_strdup("mon_thousands_sep", extlconv->mon_thousands_sep);
! 	CurrentLocaleConv.negative_sign = db_encoding_strdup("negative_sign", extlconv->negative_sign);
! 	CurrentLocaleConv.positive_sign = db_encoding_strdup("positive_sign", extlconv->positive_sign);
  	CurrentLocaleConv.n_sign_posn = extlconv->n_sign_posn;
  
! #ifdef	WIN32
! 	if (save_lc_ctype && pg_strcasecmp(locale_numeric, locale_monetary) != 0)
! 	{
! 		setlocale(LC_CTYPE, locale_numeric);
! 		/* Get formatting information for LC_NUMERIC with matching LC_CTYPE */
! 		extlconv = localeconv();
! 	}
! #endif
! 
! 	CurrentLocaleConv.decimal_point = db_encoding_strdup("decimal_point", extlconv->decimal_point);
! 	CurrentLocaleConv.grouping = strdup(extlconv->grouping);
! 	CurrentLocaleConv.thousands_sep = db_encoding_strdup("thousands_sep", extlconv->thousands_sep);
! 
! 	/*
! 	 *	Restore internal settings
! 	 */
! #ifdef	WIN32
! 	if (save_lc_ctype)
! 	{
! 		setlocale(LC_CTYPE, save_lc_ctype);
! 		pfree(save_lc_ctype);
! 	}
! #endif
  	if (save_lc_monetary)
  	{
  		setlocale(LC_MONETARY, save_lc_monetary);
***************
*** 455,483 ****
  
  #ifdef WIN32
  /*
!  * On win32, strftime() returns the encoding in CP_ACP, which is likely
!  * different from SERVER_ENCODING. This is especially important in Japanese
!  * versions of Windows which will use SJIS encoding, which we don't support
!  * as a server encoding.
!  *
!  * Replace strftime() with a version that gets the string in UTF16 and then
!  * converts it to the appropriate encoding as necessary.
   *
   * Note that this only affects the calls to strftime() in this file, which are
   * used to get the locale-aware strings. Other parts of the backend use
   * pg_strftime(), which isn't locale-aware and does not need to be replaced.
   */
  static size_t
! strftime_win32(char *dst, size_t dstlen, const wchar_t *format, const struct tm * tm)
  {
! 	size_t		len;
  	wchar_t		wbuf[MAX_L10N_DATA];
- 	int			encoding;
  
! 	encoding = GetDatabaseEncoding();
! 
! 	len = wcsftime(wbuf, MAX_L10N_DATA, format, tm);
! 	if (len == 0)
  
  		/*
  		 * strftime call failed - return 0 with the contents of dst
--- 601,628 ----
  
  #ifdef WIN32
  /*
!  * On WIN32, strftime() returns the encoding in CP_ACP (the default
!  * operating system codpage for that computer), which is likely different
!  * from SERVER_ENCODING.  This is especially important in Japanese versions
!  * of Windows which will use SJIS encoding, which we don't support as a
!  * server encoding.
!  *
!  * So, instead of using strftime(), use wcsftime() to return the value in
!  * wide characters (internally UTF16) and then convert it to the appropriate
!  * database encoding.
   *
   * Note that this only affects the calls to strftime() in this file, which are
   * used to get the locale-aware strings. Other parts of the backend use
   * pg_strftime(), which isn't locale-aware and does not need to be replaced.
   */
  static size_t
! strftime_win32(char *dst, size_t dstlen, const wchar_t *format, const struct tm *tm)
  {
! 	size_t		wchars;
  	wchar_t		wbuf[MAX_L10N_DATA];
  
! 	wchars = wcsftime(wbuf, MAX_L10N_DATA, format, tm);
! 	if (wchars == 0)
  
  		/*
  		 * strftime call failed - return 0 with the contents of dst
***************
*** 485,511 ****
  		 */
  		return 0;
  
! 	len = WideCharToMultiByte(CP_UTF8, 0, wbuf, len, dst, dstlen, NULL, NULL);
! 	if (len == 0)
! 		elog(ERROR,
! 			 "could not convert string to UTF-8:error %lu", GetLastError());
! 
! 	dst[len] = '\0';
! 	if (encoding != PG_UTF8)
! 	{
! 		char	   *convstr = pg_do_encoding_conversion(dst, len, PG_UTF8, encoding);
! 
! 		if (dst != convstr)
! 		{
! 			strlcpy(dst, convstr, dstlen);
! 			len = strlen(dst);
! 		}
! 	}
! 
! 	return len;
  }
  
  #define strftime(a,b,c,d) strftime_win32(a,b,L##c,d)
  #endif   /* WIN32 */
  
  
--- 630,641 ----
  		 */
  		return 0;
  
! 	return win32_wchar_to_db_encoding(wbuf, wchars, dst, dstlen);
  }
  
+ /* redefine strftime() */
  #define strftime(a,b,c,d) strftime_win32(a,b,L##c,d)
+ 
  #endif   /* WIN32 */
  
  
***************
*** 533,542 ****
  	elog(DEBUG3, "cache_locale_time() executed; locale: \"%s\"", locale_time);
  
  #ifdef WIN32
! 	/* set user's value of ctype locale */
  	save_lc_ctype = setlocale(LC_CTYPE, NULL);
  	if (save_lc_ctype)
  		save_lc_ctype = pstrdup(save_lc_ctype);
  
  	setlocale(LC_CTYPE, locale_time);
  #endif
--- 663,674 ----
  	elog(DEBUG3, "cache_locale_time() executed; locale: \"%s\"", locale_time);
  
  #ifdef WIN32
! 	/* See the WIN32 comment near the top of PGLC_localeconv() */
  	save_lc_ctype = setlocale(LC_CTYPE, NULL);
  	if (save_lc_ctype)
  		save_lc_ctype = pstrdup(save_lc_ctype);
+ 	else
+ 		save_lc_ctype = pstrdup("");
  
  	setlocale(LC_CTYPE, locale_time);
  #endif

diff -cprN head/src/backend/utils/adt/pg_locale.c work/src/backend/utils/adt/pg_locale.c
*** head/src/backend/utils/adt/pg_locale.c	2010-03-01 10:46:55.122677000 +0900
--- work/src/backend/utils/adt/pg_locale.c	2010-03-18 12:31:47.094400713 +0900
*************** static char lc_monetary_envbuf[LC_ENV_BU
*** 92,97 ****
--- 92,99 ----
  static char lc_numeric_envbuf[LC_ENV_BUFSIZE];
  static char lc_time_envbuf[LC_ENV_BUFSIZE];
  
+ static char *db_encoding_strdup(const char *str);
+ 
  #if defined(WIN32) && defined(LC_MESSAGES)
  static char *IsoLocaleName(const char *);		/* MSVC specific */
  #endif
*************** free_struct_lconv(struct lconv * s)
*** 386,391 ****
--- 388,413 ----
  		free(s->positive_sign);
  }
  
+ /*
+  * Converts strings encoded in the platform-dependent encoding to the database
+  * encoding and returns malloc'ed buffer.
+  */
+ static char *
+ db_encoding_strdup(const char *str)
+ {
+ 	char   *pstr;
+ 	char   *mstr;
+ 
+ 	/* convert the string to the database encoding */
+ 	pstr = (char *) pg_do_encoding_conversion(
+ 						(unsigned char *) str, strlen(str),
+ 						GetPlatformEncoding(), GetDatabaseEncoding());
+ 	mstr = strdup(pstr);
+ 	if (pstr != str)
+ 		pfree(pstr);
+ 
+ 	return mstr;
+ }
  
  /*
   * Return the POSIX lconv struct (contains number/money formatting
*************** PGLC_localeconv(void)
*** 424,439 ****
  	 * localeconv()'s results.
  	 */
  	CurrentLocaleConv = *extlconv;
! 	CurrentLocaleConv.currency_symbol = strdup(extlconv->currency_symbol);
! 	CurrentLocaleConv.decimal_point = strdup(extlconv->decimal_point);
! 	CurrentLocaleConv.grouping = strdup(extlconv->grouping);
! 	CurrentLocaleConv.thousands_sep = strdup(extlconv->thousands_sep);
! 	CurrentLocaleConv.int_curr_symbol = strdup(extlconv->int_curr_symbol);
! 	CurrentLocaleConv.mon_decimal_point = strdup(extlconv->mon_decimal_point);
! 	CurrentLocaleConv.mon_grouping = strdup(extlconv->mon_grouping);
! 	CurrentLocaleConv.mon_thousands_sep = strdup(extlconv->mon_thousands_sep);
! 	CurrentLocaleConv.negative_sign = strdup(extlconv->negative_sign);
! 	CurrentLocaleConv.positive_sign = strdup(extlconv->positive_sign);
  	CurrentLocaleConv.n_sign_posn = extlconv->n_sign_posn;
  
  	/* Try to restore internal settings */
--- 446,461 ----
  	 * localeconv()'s results.
  	 */
  	CurrentLocaleConv = *extlconv;
! 	CurrentLocaleConv.currency_symbol = db_encoding_strdup(extlconv->currency_symbol);
! 	CurrentLocaleConv.decimal_point = db_encoding_strdup(extlconv->decimal_point);
! 	CurrentLocaleConv.grouping = db_encoding_strdup(extlconv->grouping);
! 	CurrentLocaleConv.thousands_sep = db_encoding_strdup(extlconv->thousands_sep);
! 	CurrentLocaleConv.int_curr_symbol = db_encoding_strdup(extlconv->int_curr_symbol);
! 	CurrentLocaleConv.mon_decimal_point = db_encoding_strdup(extlconv->mon_decimal_point);
! 	CurrentLocaleConv.mon_grouping = db_encoding_strdup(extlconv->mon_grouping);
! 	CurrentLocaleConv.mon_thousands_sep = db_encoding_strdup(extlconv->mon_thousands_sep);
! 	CurrentLocaleConv.negative_sign = db_encoding_strdup(extlconv->negative_sign);
! 	CurrentLocaleConv.positive_sign = db_encoding_strdup(extlconv->positive_sign);
  	CurrentLocaleConv.n_sign_posn = extlconv->n_sign_posn;
  
  	/* Try to restore internal settings */
diff -cprN head/src/port/chklocale.c work/src/port/chklocale.c
*** head/src/port/chklocale.c	2010-02-26 11:29:55.507518000 +0900
--- work/src/port/chklocale.c	2010-03-18 12:31:47.191403027 +0900
*************** static const struct encoding_match encod
*** 182,187 ****
--- 182,188 ----
  	{PG_SHIFT_JIS_2004, "SJIS_2004"},
  
  	{PG_SQL_ASCII, "US-ASCII"},
+ 	{PG_SQL_ASCII, "ANSI_X3.4-1968"},
  
  	{PG_SQL_ASCII, NULL}		/* end marker */
  };

diff --git a/src/backend/utils/adt/pg_locale.c b/src/backend/utils/adt/pg_locale.c
index 79dece9..e172edf 100644
*** a/src/backend/utils/adt/pg_locale.c
--- b/src/backend/utils/adt/pg_locale.c
*************** free_struct_lconv(struct lconv * s)
*** 387,392 ****
--- 387,410 ----
  }
  
  
+ static char *
+ db_encoding_strdup(int encoding, const char *str)
+ {
+ 	char   *pstr;
+ 	char   *mstr;
+ 
+ 	/* convert the string to the database encoding */
+ 	pstr = (char *) pg_do_encoding_conversion(
+ 						(unsigned char *) str, strlen(str),
+ 						encoding, GetDatabaseEncoding());
+ 	mstr = strdup(pstr);
+ 	if (pstr != str)
+ 		pfree(pstr);
+ 
+ 	return mstr;
+ }
+ 
+ 
  /*
   * Return the POSIX lconv struct (contains number/money formatting
   * information) with locale information for all categories.
*************** PGLC_localeconv(void)
*** 398,403 ****
--- 416,426 ----
  	struct lconv *extlconv;
  	char	   *save_lc_monetary;
  	char	   *save_lc_numeric;
+ 	int			encoding;
+ 
+ #ifdef WIN32
+ 	char	   *save_lc_ctype;
+ #endif
  
  	/* Did we do it already? */
  	if (CurrentLocaleConvValid)
*************** PGLC_localeconv(void)
*** 413,439 ****
  	if (save_lc_numeric)
  		save_lc_numeric = pstrdup(save_lc_numeric);
  
  	setlocale(LC_MONETARY, locale_monetary);
  	setlocale(LC_NUMERIC, locale_numeric);
  
  	/* Get formatting information */
  	extlconv = localeconv();
  
  	/*
  	 * Must copy all values since restoring internal settings may overwrite
  	 * localeconv()'s results.
  	 */
  	CurrentLocaleConv = *extlconv;
! 	CurrentLocaleConv.currency_symbol = strdup(extlconv->currency_symbol);
! 	CurrentLocaleConv.decimal_point = strdup(extlconv->decimal_point);
! 	CurrentLocaleConv.grouping = strdup(extlconv->grouping);
! 	CurrentLocaleConv.thousands_sep = strdup(extlconv->thousands_sep);
! 	CurrentLocaleConv.int_curr_symbol = strdup(extlconv->int_curr_symbol);
! 	CurrentLocaleConv.mon_decimal_point = strdup(extlconv->mon_decimal_point);
  	CurrentLocaleConv.mon_grouping = strdup(extlconv->mon_grouping);
! 	CurrentLocaleConv.mon_thousands_sep = strdup(extlconv->mon_thousands_sep);
! 	CurrentLocaleConv.negative_sign = strdup(extlconv->negative_sign);
! 	CurrentLocaleConv.positive_sign = strdup(extlconv->positive_sign);
  	CurrentLocaleConv.n_sign_posn = extlconv->n_sign_posn;
  
  	/* Try to restore internal settings */
--- 436,472 ----
  	if (save_lc_numeric)
  		save_lc_numeric = pstrdup(save_lc_numeric);
  
+ #ifdef WIN32
+ 	/* set user's value of ctype locale */
+ 	save_lc_ctype = setlocale(LC_CTYPE, NULL);
+ 	if (save_lc_ctype)
+ 		save_lc_ctype = pstrdup(save_lc_ctype);
+ 
+ 	setlocale(LC_CTYPE, locale_monetary);
+ #endif
+ 
  	setlocale(LC_MONETARY, locale_monetary);
  	setlocale(LC_NUMERIC, locale_numeric);
  
  	/* Get formatting information */
  	extlconv = localeconv();
+ 	encoding = pg_get_encoding_from_locale(locale_monetary);
  
  	/*
  	 * Must copy all values since restoring internal settings may overwrite
  	 * localeconv()'s results.
  	 */
  	CurrentLocaleConv = *extlconv;
! 	CurrentLocaleConv.currency_symbol = db_encoding_strdup(encoding, extlconv->currency_symbol);
! 	CurrentLocaleConv.decimal_point = db_encoding_strdup(encoding, extlconv->decimal_point);
! 	CurrentLocaleConv.grouping = db_encoding_strdup(encoding, extlconv->grouping);
! 	CurrentLocaleConv.thousands_sep = db_encoding_strdup(encoding, extlconv->thousands_sep);
! 	CurrentLocaleConv.int_curr_symbol = db_encoding_strdup(encoding, extlconv->int_curr_symbol);
! 	CurrentLocaleConv.mon_decimal_point = db_encoding_strdup(encoding, extlconv->mon_decimal_point);
  	CurrentLocaleConv.mon_grouping = strdup(extlconv->mon_grouping);
! 	CurrentLocaleConv.mon_thousands_sep = db_encoding_strdup(encoding, extlconv->mon_thousands_sep);
! 	CurrentLocaleConv.negative_sign = db_encoding_strdup(encoding, extlconv->negative_sign);
! 	CurrentLocaleConv.positive_sign = db_encoding_strdup(encoding, extlconv->positive_sign);
  	CurrentLocaleConv.n_sign_posn = extlconv->n_sign_posn;
  
  	/* Try to restore internal settings */
*************** PGLC_localeconv(void)
*** 449,454 ****
--- 482,496 ----
  		pfree(save_lc_numeric);
  	}
  
+ #ifdef WIN32
+ 	/* try to restore internal ctype settings */
+ 	if (save_lc_ctype)
+ 	{
+ 		setlocale(LC_CTYPE, save_lc_ctype);
+ 		pfree(save_lc_ctype);
+ 	}
+ #endif
+ 
  	CurrentLocaleConvValid = true;
  	return &CurrentLocaleConv;
  }

diff --git a/src/backend/utils/adt/pg_locale.c b/src/backend/utils/adt/pg_locale.c
index 79dece9..077d29a 100644
*** a/src/backend/utils/adt/pg_locale.c
--- b/src/backend/utils/adt/pg_locale.c
*************** free_struct_lconv(struct lconv * s)
*** 387,392 ****
--- 387,410 ----
  }
  
  
+ static char *
+ db_encoding_strdup(int encoding, const char *str)
+ {
+ 	char   *pstr;
+ 	char   *mstr;
+ 
+ 	/* convert the string to the database encoding */
+ 	pstr = (char *) pg_do_encoding_conversion(
+ 						(unsigned char *) str, strlen(str),
+ 						encoding, GetDatabaseEncoding());
+ 	mstr = strdup(pstr);
+ 	if (pstr != str)
+ 		pfree(pstr);
+ 
+ 	return mstr;
+ }
+ 
+ 
  /*
   * Return the POSIX lconv struct (contains number/money formatting
   * information) with locale information for all categories.
*************** PGLC_localeconv(void)
*** 398,403 ****
--- 416,429 ----
  	struct lconv *extlconv;
  	char	   *save_lc_monetary;
  	char	   *save_lc_numeric;
+ 	char	   *decimal_point;
+ 	char	   *grouping;
+ 	char	   *thousands_sep;
+ 	int			encoding;
+ 
+ #ifdef WIN32
+ 	char	   *save_lc_ctype;
+ #endif
  
  	/* Did we do it already? */
  	if (CurrentLocaleConvValid)
*************** PGLC_localeconv(void)
*** 413,439 ****
  	if (save_lc_numeric)
  		save_lc_numeric = pstrdup(save_lc_numeric);
  
! 	setlocale(LC_MONETARY, locale_monetary);
  	setlocale(LC_NUMERIC, locale_numeric);
  
! 	/* Get formatting information */
  	extlconv = localeconv();
  
  	/*
  	 * Must copy all values since restoring internal settings may overwrite
  	 * localeconv()'s results.
  	 */
  	CurrentLocaleConv = *extlconv;
! 	CurrentLocaleConv.currency_symbol = strdup(extlconv->currency_symbol);
! 	CurrentLocaleConv.decimal_point = strdup(extlconv->decimal_point);
! 	CurrentLocaleConv.grouping = strdup(extlconv->grouping);
! 	CurrentLocaleConv.thousands_sep = strdup(extlconv->thousands_sep);
! 	CurrentLocaleConv.int_curr_symbol = strdup(extlconv->int_curr_symbol);
! 	CurrentLocaleConv.mon_decimal_point = strdup(extlconv->mon_decimal_point);
  	CurrentLocaleConv.mon_grouping = strdup(extlconv->mon_grouping);
! 	CurrentLocaleConv.mon_thousands_sep = strdup(extlconv->mon_thousands_sep);
! 	CurrentLocaleConv.negative_sign = strdup(extlconv->negative_sign);
! 	CurrentLocaleConv.positive_sign = strdup(extlconv->positive_sign);
  	CurrentLocaleConv.n_sign_posn = extlconv->n_sign_posn;
  
  	/* Try to restore internal settings */
--- 439,486 ----
  	if (save_lc_numeric)
  		save_lc_numeric = pstrdup(save_lc_numeric);
  
! #ifdef WIN32
! 	/* set user's value of ctype locale */
! 	save_lc_ctype = setlocale(LC_CTYPE, NULL);
! 	if (save_lc_ctype)
! 		save_lc_ctype = pstrdup(save_lc_ctype);
! #endif
! 
! 	/* Get formatting information for numeric */
! #ifdef WIN32
! 	setlocale(LC_CTYPE, locale_numeric);
! #endif
  	setlocale(LC_NUMERIC, locale_numeric);
+ 	extlconv = localeconv();
+ 	encoding = pg_get_encoding_from_locale(locale_numeric);
  
! 	decimal_point = db_encoding_strdup(encoding, extlconv->decimal_point);
! 	grouping = strdup(extlconv->grouping);
! 	thousands_sep = db_encoding_strdup(encoding, extlconv->thousands_sep);
! 
! 	/* Get formatting information for monetary */
! #ifdef WIN32
! 	setlocale(LC_CTYPE, locale_monetary);
! #endif
! 	setlocale(LC_MONETARY, locale_monetary);
  	extlconv = localeconv();
+ 	encoding = pg_get_encoding_from_locale(locale_monetary);
  
  	/*
  	 * Must copy all values since restoring internal settings may overwrite
  	 * localeconv()'s results.
  	 */
  	CurrentLocaleConv = *extlconv;
! 	CurrentLocaleConv.decimal_point = decimal_point;
! 	CurrentLocaleConv.grouping = grouping;
! 	CurrentLocaleConv.thousands_sep = thousands_sep;
! 	CurrentLocaleConv.currency_symbol = db_encoding_strdup(encoding, extlconv->currency_symbol);
! 	CurrentLocaleConv.int_curr_symbol = db_encoding_strdup(encoding, extlconv->int_curr_symbol);
! 	CurrentLocaleConv.mon_decimal_point = db_encoding_strdup(encoding, extlconv->mon_decimal_point);
  	CurrentLocaleConv.mon_grouping = strdup(extlconv->mon_grouping);
! 	CurrentLocaleConv.mon_thousands_sep = db_encoding_strdup(encoding, extlconv->mon_thousands_sep);
! 	CurrentLocaleConv.negative_sign = db_encoding_strdup(encoding, extlconv->negative_sign);
! 	CurrentLocaleConv.positive_sign = db_encoding_strdup(encoding, extlconv->positive_sign);
  	CurrentLocaleConv.n_sign_posn = extlconv->n_sign_posn;
  
  	/* Try to restore internal settings */
*************** PGLC_localeconv(void)
*** 449,454 ****
--- 496,510 ----
  		pfree(save_lc_numeric);
  	}
  
+ #ifdef WIN32
+ 	/* try to restore internal ctype settings */
+ 	if (save_lc_ctype)
+ 	{
+ 		setlocale(LC_CTYPE, save_lc_ctype);
+ 		pfree(save_lc_ctype);
+ 	}
+ #endif
+ 
  	CurrentLocaleConvValid = true;
  	return &CurrentLocaleConv;
  }

Index: src/backend/utils/adt/pg_locale.c
===================================================================
RCS file: /cvsroot/pgsql/src/backend/utils/adt/pg_locale.c,v
retrieving revision 1.54
diff -c -c -r1.54 pg_locale.c
*** src/backend/utils/adt/pg_locale.c	22 Apr 2010 01:55:52 -0000	1.54
--- src/backend/utils/adt/pg_locale.c	24 Apr 2010 22:43:53 -0000
***************
*** 41,46 ****
--- 41,50 ----
   * DOES NOT WORK RELIABLY: on some platforms the second setlocale() call
   * will change the memory save is pointing at.	To do this sort of thing
   * safely, you *must* pstrdup what setlocale returns the first time.
+  *
+  * FYI, The Open Group locale standard is defined here:
+  *
+  *  http://www.opengroup.org/onlinepubs/009695399/basedefs/xbd_chap07.html
   *----------
   */
  
***************
*** 424,430 ****
  	char	   *grouping;
  	char	   *thousands_sep;
  	int			encoding;
- 
  #ifdef WIN32
  	char	   *save_lc_ctype;
  #endif
--- 428,433 ----
***************
*** 435,459 ****
  
  	free_struct_lconv(&CurrentLocaleConv);
  
! 	/* Set user's values of monetary and numeric locales */
  	save_lc_monetary = setlocale(LC_MONETARY, NULL);
  	if (save_lc_monetary)
  		save_lc_monetary = pstrdup(save_lc_monetary);
  	save_lc_numeric = setlocale(LC_NUMERIC, NULL);
  	if (save_lc_numeric)
  		save_lc_numeric = pstrdup(save_lc_numeric);
  
  #ifdef WIN32
! 	/* set user's value of ctype locale */
  	save_lc_ctype = setlocale(LC_CTYPE, NULL);
  	if (save_lc_ctype)
  		save_lc_ctype = pstrdup(save_lc_ctype);
- #endif
  
! 	/* Get formatting information for numeric */
! #ifdef WIN32
  	setlocale(LC_CTYPE, locale_numeric);
  #endif
  	setlocale(LC_NUMERIC, locale_numeric);
  	extlconv = localeconv();
  	encoding = pg_get_encoding_from_locale(locale_numeric);
--- 438,485 ----
  
  	free_struct_lconv(&CurrentLocaleConv);
  
! 	/* Save user's values of monetary and numeric locales */
  	save_lc_monetary = setlocale(LC_MONETARY, NULL);
  	if (save_lc_monetary)
  		save_lc_monetary = pstrdup(save_lc_monetary);
+ 
  	save_lc_numeric = setlocale(LC_NUMERIC, NULL);
  	if (save_lc_numeric)
  		save_lc_numeric = pstrdup(save_lc_numeric);
  
  #ifdef WIN32
!    /*
! 	*  Ideally, monetary and numeric local symbols could be returned in
! 	*  any server encoding.  Unfortunately, the WIN32 API does not allow
! 	*  setlocale() to return values in a codepage/CTYPE that uses more
! 	*  than two bytes per character, like UTF-8:
! 	*
! 	*      http://msdn.microsoft.com/en-us/library/x99tb11d.aspx
! 	*
! 	*  Evidently, LC_CTYPE allows us to control the encoding used
! 	*  for strings returned by localeconv().  The Open Group
! 	*  standard, mentioned at the top of this C file, doesn't
! 	*  explicitly state this.
! 	*
! 	*  Therefore, we set LC_CTYPE to match LC_NUMERIC or LC_MONETARY
! 	*  (which cannot be UTF8), call localeconv(), and then convert from
! 	*  the numeric/monitary LC_CTYPE to the server encoding.  One
! 	*  example use of this is for the Euro symbol.
! 	*
! 	*  Perhaps someday we will use GetLocaleInfoW() which returns values
! 	*  in UTF16 and convert from that.
! 	*/
! 
! 	/* save user's value of ctype locale */
  	save_lc_ctype = setlocale(LC_CTYPE, NULL);
  	if (save_lc_ctype)
  		save_lc_ctype = pstrdup(save_lc_ctype);
  
! 	/* use numeric to set the ctype */
  	setlocale(LC_CTYPE, locale_numeric);
  #endif
+ 
+ 	/* Get formatting information for numeric */
  	setlocale(LC_NUMERIC, locale_numeric);
  	extlconv = localeconv();
  	encoding = pg_get_encoding_from_locale(locale_numeric);
***************
*** 462,471 ****
  	thousands_sep = db_encoding_strdup(encoding, extlconv->thousands_sep);
  	grouping = strdup(extlconv->grouping);
  
- 	/* Get formatting information for monetary */
  #ifdef WIN32
  	setlocale(LC_CTYPE, locale_monetary);
  #endif
  	setlocale(LC_MONETARY, locale_monetary);
  	extlconv = localeconv();
  	encoding = pg_get_encoding_from_locale(locale_monetary);
--- 488,499 ----
  	thousands_sep = db_encoding_strdup(encoding, extlconv->thousands_sep);
  	grouping = strdup(extlconv->grouping);
  
  #ifdef WIN32
+ 	/* use monetary to set the ctype */
  	setlocale(LC_CTYPE, locale_monetary);
  #endif
+ 
+ 	/* Get formatting information for monetary */
  	setlocale(LC_MONETARY, locale_monetary);
  	extlconv = localeconv();
  	encoding = pg_get_encoding_from_locale(locale_monetary);
***************
*** 500,506 ****
  	}
  
  #ifdef WIN32
! 	/* try to restore internal ctype settings */
  	if (save_lc_ctype)
  	{
  		setlocale(LC_CTYPE, save_lc_ctype);
--- 528,534 ----
  	}
  
  #ifdef WIN32
! 	/* Try to restore internal ctype settings */
  	if (save_lc_ctype)
  	{
  		setlocale(LC_CTYPE, save_lc_ctype);
***************
*** 514,526 ****
  
  #ifdef WIN32
  /*
!  * On win32, strftime() returns the encoding in CP_ACP, which is likely
!  * different from SERVER_ENCODING. This is especially important in Japanese
!  * versions of Windows which will use SJIS encoding, which we don't support
!  * as a server encoding.
   *
!  * Replace strftime() with a version that gets the string in UTF16 and then
!  * converts it to the appropriate encoding as necessary.
   *
   * Note that this only affects the calls to strftime() in this file, which are
   * used to get the locale-aware strings. Other parts of the backend use
--- 542,556 ----
  
  #ifdef WIN32
  /*
!  * On WIN32, strftime() returns the encoding in CP_ACP (the default
!  * operating system codpage for that computer), which is likely different
!  * from SERVER_ENCODING.  This is especially important in Japanese versions
!  * of Windows which will use SJIS encoding, which we don't support as a
!  * server encoding.
   *
!  * So, instead of using strftime(), use wcsftime() to return the value in
!  * wide characters (internally UTF16) and then convert it to the appropriate
!  * database encoding.
   *
   * Note that this only affects the calls to strftime() in this file, which are
   * used to get the locale-aware strings. Other parts of the backend use
***************
*** 537,543 ****
  
  	len = wcsftime(wbuf, MAX_L10N_DATA, format, tm);
  	if (len == 0)
- 
  		/*
  		 * strftime call failed - return 0 with the contents of dst
  		 * unspecified
--- 567,572 ----
***************
*** 564,570 ****
--- 593,601 ----
  	return len;
  }
  
+ /* redefine strftime() */
  #define strftime(a,b,c,d) strftime_win32(a,b,L##c,d)
+ 
  #endif   /* WIN32 */
  
  
***************
*** 580,586 ****
  	char		buf[MAX_L10N_DATA];
  	char	   *ptr;
  	int			i;
- 
  #ifdef WIN32
  	char	   *save_lc_ctype;
  #endif
--- 611,616 ----
***************
*** 591,610 ****
  
  	elog(DEBUG3, "cache_locale_time() executed; locale: \"%s\"", locale_time);
  
  #ifdef WIN32
! 	/* set user's value of ctype locale */
  	save_lc_ctype = setlocale(LC_CTYPE, NULL);
  	if (save_lc_ctype)
  		save_lc_ctype = pstrdup(save_lc_ctype);
  
  	setlocale(LC_CTYPE, locale_time);
  #endif
  
- 	/* set user's value of time locale */
- 	save_lc_time = setlocale(LC_TIME, NULL);
- 	if (save_lc_time)
- 		save_lc_time = pstrdup(save_lc_time);
- 
  	setlocale(LC_TIME, locale_time);
  
  	timenow = time(NULL);
--- 621,642 ----
  
  	elog(DEBUG3, "cache_locale_time() executed; locale: \"%s\"", locale_time);
  
+ 	/* save user's value of time locale */
+ 	save_lc_time = setlocale(LC_TIME, NULL);
+ 	if (save_lc_time)
+ 		save_lc_time = pstrdup(save_lc_time);
+ 
  #ifdef WIN32
! 	/* See the WIN32 comment near the top of PGLC_localeconv() */
! 	/* save user's value of ctype locale */
  	save_lc_ctype = setlocale(LC_CTYPE, NULL);
  	if (save_lc_ctype)
  		save_lc_ctype = pstrdup(save_lc_ctype);
  
+ 	/* use lc_time to set the ctype */
  	setlocale(LC_CTYPE, locale_time);
  #endif
  
  	setlocale(LC_TIME, locale_time);
  
  	timenow = time(NULL);

Index: src/backend/utils/adt/pg_locale.c
===================================================================
RCS file: /cvsroot/pgsql/src/backend/utils/adt/pg_locale.c,v
retrieving revision 1.55
diff -c -c -r1.55 pg_locale.c
*** src/backend/utils/adt/pg_locale.c	24 Apr 2010 22:54:56 -0000	1.55
--- src/backend/utils/adt/pg_locale.c	26 Apr 2010 13:30:03 -0000
***************
*** 627,633 ****
  		save_lc_time = pstrdup(save_lc_time);
  
  #ifdef WIN32
! 	/* See the WIN32 comment near the top of PGLC_localeconv() */
  	/* save user's value of ctype locale */
  	save_lc_ctype = setlocale(LC_CTYPE, NULL);
  	if (save_lc_ctype)
--- 627,641 ----
  		save_lc_time = pstrdup(save_lc_time);
  
  #ifdef WIN32
! 	/*
! 	 * On WIN32, there is no way to get locale-specific time values in a
! 	 * specified locale, like we do for monetary/numeric.  We can only get
! 	 * CP_ACP (see strftime_win32) or UTF16.  Therefore, we get UTF16 and
! 	 * convert it to the database locale.  However, wcsftime() internally
! 	 * uses LC_CTYPE, so we set it here.  See the WIN32 comment near the
! 	 * top of PGLC_localeconv().
! 	 */
! 
  	/* save user's value of ctype locale */
  	save_lc_ctype = setlocale(LC_CTYPE, NULL);
  	if (save_lc_ctype)