proposal: a width specification for s specifier (format function), fix behave when positional and ordered placeholders are used

*** a/doc/src/sgml/func.sgml
--- b/doc/src/sgml/func.sgml
***************
*** 1530,1536 ****
           SQL literal; <literal>%%</literal> outputs a literal <literal>%</>.
           A conversion can reference an explicit parameter position by preceding
           the conversion specifier with <literal><replaceable>n</>$</>, where
!          <replaceable>n</replaceable> is the argument position.
           See also <xref linkend="plpgsql-quote-literal-example">.
         </entry>
         <entry><literal>format('Hello %s, %1$s', 'World')</literal></entry>
--- 1530,1537 ----
           SQL literal; <literal>%%</literal> outputs a literal <literal>%</>.
           A conversion can reference an explicit parameter position by preceding
           the conversion specifier with <literal><replaceable>n</>$</>, where
!          <replaceable>n</replaceable> is the argument position. A warnig is raised
!          when positional and ordered placeholders are used together.
           See also <xref linkend="plpgsql-quote-literal-example">.
         </entry>
         <entry><literal>format('Hello %s, %1$s', 'World')</literal></entry>
*** a/src/backend/utils/adt/varlena.c
--- b/src/backend/utils/adt/varlena.c
***************
*** 3958,3964 **** text_format(PG_FUNCTION_ARGS)
  	const char *start_ptr;
  	const char *end_ptr;
  	text	   *result;
! 	int			arg = 0;
  
  	/* When format string is null, returns null */
  	if (PG_ARGISNULL(0))
--- 3958,3968 ----
  	const char *start_ptr;
  	const char *end_ptr;
  	text	   *result;
! 	int			arg;
! 	int		position = 0;
! 	bool		positional = false;
! 	bool		ordered = false;
! 	bool		warning_emmited = false;
  
  	/* When format string is null, returns null */
  	if (PG_ARGISNULL(0))
***************
*** 4006,4013 **** text_format(PG_FUNCTION_ARGS)
  		 */
  		if (*cp < '0' || *cp > '9')
  		{
! 			++arg;
! 			if (arg <= 0)		/* overflow? */
  			{
  				/*
  				 * Should not happen, as you can't pass billions of arguments
--- 4010,4025 ----
  		 */
  		if (*cp < '0' || *cp > '9')
  		{
! 			/* don't allow mix styles - reflects glibc behave */
! 			if (positional && !warning_emmited)
! 			{
! 				elog(WARNING, "ordered and positional placeholders are used together");
! 				warning_emmited = true;
! 			}
! 			ordered = true;
! 
! 			++position;
! 			if (position <= 0)		/* overflow? */
  			{
  				/*
  				 * Should not happen, as you can't pass billions of arguments
***************
*** 4017,4022 **** text_format(PG_FUNCTION_ARGS)
--- 4029,4035 ----
  						(errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
  						 errmsg("argument number is out of range")));
  			}
+ 			arg = position;
  		}
  		else
  		{
***************
*** 4054,4059 **** text_format(PG_FUNCTION_ARGS)
--- 4067,4079 ----
  						(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
  						 errmsg("unterminated conversion specifier")));
  
+ 			if (ordered && !warning_emmited)
+ 			{
+ 				elog(WARNING, "ordered and positional placeholders are used together");
+ 				warning_emmited = true;
+ 			}
+ 			positional = true;
+ 
  			/* There's no argument 0. */
  			if (arg == 0)
  				ereport(ERROR,
*** a/src/test/regress/expected/text.out
--- b/src/test/regress/expected/text.out
***************
*** 229,243 **** ERROR:  unterminated conversion specifier
--- 229,253 ----
  select format('%1$1', 1);
  ERROR:  unrecognized conversion specifier "1"
  --checkk mix of positional and ordered placeholders
+ --should raise warnings
  select format('Hello %s %1$s %s', 'World', 'Hello again');
+ WARNING:  ordered and positional placeholders are used together
              format             
  -------------------------------
   Hello World World Hello again
  (1 row)
  
  select format('Hello %s %s, %2$s %2$s', 'World', 'Hello again');
+ WARNING:  ordered and positional placeholders are used together
                        format                      
  --------------------------------------------------
   Hello World Hello again, Hello again Hello again
  (1 row)
  
+ select format('Hello %s %2$s %s', 'World', 'Hello again');
+ WARNING:  ordered and positional placeholders are used together
+                format                
+ -------------------------------------
+  Hello World Hello again Hello again
+ (1 row)
+ 
*** a/src/test/regress/sql/text.sql
--- b/src/test/regress/sql/text.sql
***************
*** 74,78 **** select format('%1s', 1);
--- 74,80 ----
  select format('%1$', 1);
  select format('%1$1', 1);
  --checkk mix of positional and ordered placeholders
+ --should raise warnings
  select format('Hello %s %1$s %s', 'World', 'Hello again');
  select format('Hello %s %s, %2$s %2$s', 'World', 'Hello again');
+ select format('Hello %s %2$s %s', 'World', 'Hello again');

*** a/doc/src/sgml/func.sgml
--- b/doc/src/sgml/func.sgml
***************
*** 1530,1536 ****
           SQL literal; <literal>%%</literal> outputs a literal <literal>%</>.
           A conversion can reference an explicit parameter position by preceding
           the conversion specifier with <literal><replaceable>n</>$</>, where
!          <replaceable>n</replaceable> is the argument position. A warnig is raised
           when positional and ordered placeholders are used together.
           See also <xref linkend="plpgsql-quote-literal-example">.
         </entry>
--- 1530,1538 ----
           SQL literal; <literal>%%</literal> outputs a literal <literal>%</>.
           A conversion can reference an explicit parameter position by preceding
           the conversion specifier with <literal><replaceable>n</>$</>, where
!          <replaceable>n</replaceable> is the argument position. Similary to C 
!          function <function>sprintf</>; is possible to specify a width for
!          <literal>%s</literal> conversion. A warnig is raised
           when positional and ordered placeholders are used together.
           See also <xref linkend="plpgsql-quote-literal-example">.
         </entry>
*** a/src/backend/utils/adt/varlena.c
--- b/src/backend/utils/adt/varlena.c
***************
*** 77,83 **** static bytea *bytea_substring(Datum str,
  static bytea *bytea_overlay(bytea *t1, bytea *t2, int sp, int sl);
  static StringInfo makeStringAggState(FunctionCallInfo fcinfo);
  void text_format_string_conversion(StringInfo buf, char conversion,
! 							  Oid typid, Datum value, bool isNull);
  
  static Datum text_to_array_internal(PG_FUNCTION_ARGS);
  static text *array_to_text_internal(FunctionCallInfo fcinfo, ArrayType *v,
--- 77,84 ----
  static bytea *bytea_overlay(bytea *t1, bytea *t2, int sp, int sl);
  static StringInfo makeStringAggState(FunctionCallInfo fcinfo);
  void text_format_string_conversion(StringInfo buf, char conversion,
! 							  Oid typid, Datum value, bool isNull,
! 							  bool with_width, int width);
  
  static Datum text_to_array_internal(PG_FUNCTION_ARGS);
  static text *array_to_text_internal(FunctionCallInfo fcinfo, ArrayType *v,
***************
*** 3947,3952 **** text_reverse(PG_FUNCTION_ARGS)
--- 3948,4028 ----
  }
  
  /*
+  * Returns ptr of first non digit char. Raise error,
+  * when no digit is processed or when result of parsing is not number
+  */
+ static const char *
+ parse_digit_subformat(const char *start_ptr, const char *end_ptr, int *value)
+ {
+ 	const char *cp = start_ptr;
+ 	bool	minus = false;
+ 	int	inum = 0;
+ 
+ 	/* continue, only when start_ptr is less than end_ptr */
+ 	if (cp < end_ptr)
+ 	{
+ 		if (*cp == '-')
+ 		{
+ 			minus = true;
+ 			start_ptr = cp++;
+ 		}
+ 
+ 		while (cp < end_ptr)
+ 		{
+ 			if (*cp >= '0' && *cp <= '9')
+ 			{
+ 				int	newnum = inum * 10 + (*cp - '0');
+ 
+ 				if (newnum / 10 != inum) /* overflow? */
+ 					ereport(ERROR,
+ 							(errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
+ 							 errmsg("number is out of range")));
+ 				inum = newnum;
+ 				++cp;
+ 			}
+ 			else
+ 				break;
+ 		}
+ 
+ 		*value = minus ? - inum : inum;
+ 	}
+ 
+ 	/* digit cannot be last char */
+ 	if (cp >= end_ptr)
+ 		ereport(ERROR,
+ 				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+ 				 errmsg("unterminated conversion specifier")));
+ 
+ 	/* we call this routine, only when we expected number */
+ 	if (cp == start_ptr)
+ 		ereport(ERROR,
+ 				(errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
+ 				 errmsg("invalid format, missing expected number")));
+ 
+ 	/* argument number must by greather than zero */
+ 	if (*cp == '$')
+ 	{
+ 		if (minus)
+ 			ereport(ERROR,
+ 					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+ 					 errmsg("conversion specifies argument 0, but arguments are numbered from 1")));
+ 
+ 		if (inum == 0)
+ 			ereport(ERROR,
+ 					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+ 					 errmsg("conversion specifies argument 0, but arguments are numbered from 1")));
+ 
+ 		/* $ must not be last char */
+ 		if (cp + 1 >= end_ptr)
+ 			ereport(ERROR,
+ 					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+ 					 errmsg("unterminated conversion specifier")));
+ 	}
+ 
+ 	return cp;
+ }
+ 
+ /*
   * Returns a formated string
   */
  Datum
***************
*** 3959,3965 **** text_format(PG_FUNCTION_ARGS)
  	const char *end_ptr;
  	text	   *result;
  	int			arg;
! 	int		position = 0;
  	bool		positional = false;
  	bool		ordered = false;
  	bool		warning_emmited = false;
--- 4035,4041 ----
  	const char *end_ptr;
  	text	   *result;
  	int			arg;
! 	int		ordered_nargs = 0;
  	bool		positional = false;
  	bool		ordered = false;
  	bool		warning_emmited = false;
***************
*** 3980,3985 **** text_format(PG_FUNCTION_ARGS)
--- 4056,4063 ----
  		Datum		value;
  		bool		isNull;
  		Oid			typid;
+ 		int		width = 0;
+ 		bool		with_width = false;
  
  		/*
  		 * If it's not the start of a conversion specifier, just copy it to
***************
*** 4004,4025 **** text_format(PG_FUNCTION_ARGS)
  			continue;
  		}
  
  		/*
! 		 * If the user hasn't specified an argument position, we just advance
! 		 * to the next one.  If they have, we must parse it.
  		 */
! 		if (*cp < '0' || *cp > '9')
  		{
! 			/* don't allow mix styles - reflects glibc behave */
! 			if (positional && !warning_emmited)
  			{
! 				elog(WARNING, "ordered and positional placeholders are used together");
! 				warning_emmited = true;
  			}
! 			ordered = true;
  
! 			++position;
! 			if (position <= 0)		/* overflow? */
  			{
  				/*
  				 * Should not happen, as you can't pass billions of arguments
--- 4082,4125 ----
  			continue;
  		}
  
+ 		arg = 0;
  		/*
! 		 * User can specify a width or a position or both. The width should
! 		 * be negative.
  		 */
! 		if (*cp == '-' || (*cp >= '0' && *cp <= '9'))
  		{
! 			cp = parse_digit_subformat(cp, end_ptr, &arg);
! 
! 			if (*cp == '$')
  			{
! 				++cp;
! 				if (*cp == '-' || (*cp >= '0' && *cp <= '9'))
! 				{
! 					cp = parse_digit_subformat(cp, end_ptr, &width);
! 
! 					if (*cp == '$')
! 						ereport(ERROR,
! 								(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
! 								 errmsg("argument number is defined yet")));
! 
! 					with_width = true;
! 				}
  			}
! 			else
! 			{
! 				/* previous digits was a width not argument number */
! 				width = arg;
! 				arg = 0;
! 				with_width = true;
! 			}
! 		}
  
! 		/* when argument not specified yet, use a next one */
! 		if (arg == 0)
! 		{
! 			++ordered_nargs;
! 			if (ordered_nargs <= 0)		/* overflow? */
  			{
  				/*
  				 * Should not happen, as you can't pass billions of arguments
***************
*** 4029,4084 **** text_format(PG_FUNCTION_ARGS)
  						(errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
  						 errmsg("argument number is out of range")));
  			}
! 			arg = position;
! 		}
! 		else
! 		{
! 			bool		unterminated = false;
! 
! 			/* Parse digit string. */
! 			arg = 0;
! 			do
! 			{
! 				int			newarg = arg * 10 + (*cp - '0');
  
! 				if (newarg / 10 != arg) /* overflow? */
! 					ereport(ERROR,
! 							(errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
! 							 errmsg("argument number is out of range")));
! 				arg = newarg;
! 				++cp;
! 			} while (cp < end_ptr && *cp >= '0' && *cp <= '9');
! 
! 			/*
! 			 * If we ran off the end, or if there's not a $ next, or if the $
! 			 * is the last character, the conversion specifier is improperly
! 			 * terminated.
! 			 */
! 			if (cp == end_ptr || *cp != '$')
! 				unterminated = true;
! 			else
  			{
! 				++cp;
! 				if (cp == end_ptr)
! 					unterminated = true;
  			}
- 			if (unterminated)
- 				ereport(ERROR,
- 						(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
- 						 errmsg("unterminated conversion specifier")));
  
  			if (ordered && !warning_emmited)
  			{
  				elog(WARNING, "ordered and positional placeholders are used together");
  				warning_emmited = true;
  			}
- 			positional = true;
  
! 			/* There's no argument 0. */
! 			if (arg == 0)
! 				ereport(ERROR,
! 						(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
! 						 errmsg("conversion specifies argument 0, but arguments are numbered from 1")));
  		}
  
  		/* Not enough arguments?  Deduct 1 to avoid counting format string. */
--- 4129,4154 ----
  						(errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
  						 errmsg("argument number is out of range")));
  			}
! 			arg = ordered_nargs;
  
! 			/* raise warning when found mixed placeholders, but only once */
! 			if (positional && !warning_emmited)
  			{
! 				elog(WARNING, "ordered and positional placeholders are used together");
! 				warning_emmited = true;
  			}
  
+ 			ordered = true;
+ 		}
+ 		else
+ 		{
  			if (ordered && !warning_emmited)
  			{
  				elog(WARNING, "ordered and positional placeholders are used together");
  				warning_emmited = true;
  			}
  
! 			positional = true;
  		}
  
  		/* Not enough arguments?  Deduct 1 to avoid counting format string. */
***************
*** 4099,4108 **** text_format(PG_FUNCTION_ARGS)
  		switch (*cp)
  		{
  			case 's':
  			case 'I':
  			case 'L':
! 				text_format_string_conversion(&str, *cp, typid, value, isNull);
  				break;
  			default:
  				ereport(ERROR,
  						(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
--- 4169,4186 ----
  		switch (*cp)
  		{
  			case 's':
+ 				text_format_string_conversion(&str, *cp, typid, value, isNull, with_width, width);
+ 				break;
+ 
  			case 'I':
  			case 'L':
! 				if (with_width)
! 					ereport(ERROR,
! 							(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
! 							 errmsg("conversion \"%c\" doesn't suppport the width", *cp)));
! 				text_format_string_conversion(&str, *cp, typid, value, isNull, false, 0);
  				break;
+ 
  			default:
  				ereport(ERROR,
  						(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
***************
*** 4121,4127 **** text_format(PG_FUNCTION_ARGS)
  /* Format a %s, %I, or %L conversion. */
  void
  text_format_string_conversion(StringInfo buf, char conversion,
! 							  Oid typid, Datum value, bool isNull)
  {
  	Oid			typOutput;
  	bool		typIsVarlena;
--- 4199,4206 ----
  /* Format a %s, %I, or %L conversion. */
  void
  text_format_string_conversion(StringInfo buf, char conversion,
! 							  Oid typid, Datum value, bool isNull,
! 							  bool with_width, int width)
  {
  	Oid			typOutput;
  	bool		typIsVarlena;
***************
*** 4158,4164 **** text_format_string_conversion(StringInfo buf, char conversion,
  		pfree(qstr);
  	}
  	else
! 		appendStringInfoString(buf, str);
  
  	/* Cleanup. */
  	pfree(str);
--- 4237,4266 ----
  		pfree(qstr);
  	}
  	else
! 	{
! 		/* fast path */
! 		if (!with_width)
! 			appendStringInfoString(buf, str);
! 		else
! 		{
! 			int	len = pg_mbstrlen(str);
! 
! 			if (width < 0)
! 			{
! 				/* allign to left */
! 				appendStringInfoString(buf, str);
! 				if (len < (-width))
! 					appendStringInfoSpaces(buf, - (len + width));
! 			}
! 			else
! 			{
! 				/* allign to right */
! 				if (len < width)
! 					appendStringInfoSpaces(buf, width - len);
! 				appendStringInfoString(buf, str);
! 			}
! 		}
! 	}
  
  	/* Cleanup. */
  	pfree(str);
*** a/src/test/regress/expected/text.out
--- b/src/test/regress/expected/text.out
***************
*** 222,233 **** select format('%1$s %4$s', 1, 2, 3);
  ERROR:  too few arguments for format
  select format('%1$s %13$s', 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12);
  ERROR:  too few arguments for format
- select format('%1s', 1);
- ERROR:  unterminated conversion specifier
  select format('%1$', 1);
  ERROR:  unterminated conversion specifier
  select format('%1$1', 1);
! ERROR:  unrecognized conversion specifier "1"
  --checkk mix of positional and ordered placeholders
  --should raise warnings
  select format('Hello %s %1$s %s', 'World', 'Hello again');
--- 222,231 ----
  ERROR:  too few arguments for format
  select format('%1$s %13$s', 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12);
  ERROR:  too few arguments for format
  select format('%1$', 1);
  ERROR:  unterminated conversion specifier
  select format('%1$1', 1);
! ERROR:  unterminated conversion specifier
  --checkk mix of positional and ordered placeholders
  --should raise warnings
  select format('Hello %s %1$s %s', 'World', 'Hello again');
***************
*** 251,253 **** WARNING:  ordered and positional placeholders are used together
--- 249,283 ----
   Hello World Hello again Hello again
  (1 row)
  
+ -- format with a width
+ select format('>>%10s<<', 'Hello');
+      format     
+ ----------------
+  >>     Hello<<
+ (1 row)
+ 
+ select format('>>%-10s<<', 'Hello');
+      format     
+ ----------------
+  >>Hello     <<
+ (1 row)
+ 
+ select format('>>%1$10s<<', 'Hello');
+      format     
+ ----------------
+  >>     Hello<<
+ (1 row)
+ 
+ select format('>>%1$-10s<<', 'Hello');
+      format     
+ ----------------
+  >>Hello     <<
+ (1 row)
+ 
+ -- should fail
+ select format('>>%1$1$s<<', 'Hello');
+ ERROR:  argument number is defined yet
+ select format('>>%10I<<', 'tablename');
+ ERROR:  conversion "I" doesn't suppport the width
+ select format('>>%1$10L<<', 'tablename');
+ ERROR:  conversion "L" doesn't suppport the width
*** a/src/test/regress/sql/text.sql
--- b/src/test/regress/sql/text.sql
***************
*** 70,76 **** select format('%1$s %12$s', 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12);
  -- should fail
  select format('%1$s %4$s', 1, 2, 3);
  select format('%1$s %13$s', 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12);
- select format('%1s', 1);
  select format('%1$', 1);
  select format('%1$1', 1);
  --checkk mix of positional and ordered placeholders
--- 70,75 ----
***************
*** 78,80 **** select format('%1$1', 1);
--- 77,90 ----
  select format('Hello %s %1$s %s', 'World', 'Hello again');
  select format('Hello %s %s, %2$s %2$s', 'World', 'Hello again');
  select format('Hello %s %2$s %s', 'World', 'Hello again');
+ 
+ -- format with a width
+ select format('>>%10s<<', 'Hello');
+ select format('>>%-10s<<', 'Hello');
+ select format('>>%1$10s<<', 'Hello');
+ select format('>>%1$-10s<<', 'Hello');
+ 
+ -- should fail
+ select format('>>%1$1$s<<', 'Hello');
+ select format('>>%10I<<', 'tablename');
+ select format('>>%1$10L<<', 'tablename');

*** a/doc/src/sgml/func.sgml
--- b/doc/src/sgml/func.sgml
***************
*** 1532,1538 ****
           SQL literal; <literal>%%</literal> outputs a literal <literal>%</>.
           A conversion can reference an explicit parameter position by preceding
           the conversion specifier with <literal><replaceable>n</>$</>, where
!          <replaceable>n</replaceable> is the argument position.
           See also <xref linkend="plpgsql-quote-literal-example">.
         </entry>
         <entry><literal>format('Hello %s, %1$s', 'World')</literal></entry>
--- 1532,1539 ----
           SQL literal; <literal>%%</literal> outputs a literal <literal>%</>.
           A conversion can reference an explicit parameter position by preceding
           the conversion specifier with <literal><replaceable>n</>$</>, where
!          <replaceable>n</replaceable> is the argument position. A warnig is raised
!          when positional and ordered placeholders are used together.
           See also <xref linkend="plpgsql-quote-literal-example">.
         </entry>
         <entry><literal>format('Hello %s, %1$s', 'World')</literal></entry>
*** a/src/backend/utils/adt/varlena.c
--- b/src/backend/utils/adt/varlena.c
***************
*** 4003,4008 **** text_format(PG_FUNCTION_ARGS)
--- 4003,4012 ----
  	Oid			element_type = InvalidOid;
  	Oid			prev_type = InvalidOid;
  	FmgrInfo	typoutputfinfo;
+ 	int		position = 0;
+ 	bool		positional = false;
+ 	bool		ordered = false;
+ 	bool		warning_emmited = false;
  
  	/* When format string is null, returns null */
  	if (PG_ARGISNULL(0))
***************
*** 4092,4099 **** text_format(PG_FUNCTION_ARGS)
  		 */
  		if (*cp < '0' || *cp > '9')
  		{
! 			++arg;
! 			if (arg <= 0)		/* overflow? */
  			{
  				/*
  				 * Should not happen, as you can't pass billions of arguments
--- 4096,4111 ----
  		 */
  		if (*cp < '0' || *cp > '9')
  		{
! 			/* don't allow mix styles - reflects glibc behave */
! 			if (positional && !warning_emmited)
! 			{
! 				elog(WARNING, "ordered and positional placeholders are used together");
! 				warning_emmited = true;
! 			}
! 			ordered = true;
! 
! 			++position;
! 			if (position <= 0)		/* overflow? */
  			{
  				/*
  				 * Should not happen, as you can't pass billions of arguments
***************
*** 4103,4108 **** text_format(PG_FUNCTION_ARGS)
--- 4115,4121 ----
  						(errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
  						 errmsg("argument number is out of range")));
  			}
+ 			arg = position;
  		}
  		else
  		{
***************
*** 4140,4145 **** text_format(PG_FUNCTION_ARGS)
--- 4153,4165 ----
  						(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
  						 errmsg("unterminated conversion specifier")));
  
+ 			if (ordered && !warning_emmited)
+ 			{
+ 				elog(WARNING, "ordered and positional placeholders are used together");
+ 				warning_emmited = true;
+ 			}
+ 			positional = true;
+ 
  			/* There's no argument 0. */
  			if (arg == 0)
  				ereport(ERROR,
*** a/src/test/regress/expected/text.out
--- b/src/test/regress/expected/text.out
***************
*** 265,282 **** ERROR:  unterminated conversion specifier
--- 265,292 ----
  select format('%1$1', 1);
  ERROR:  unrecognized conversion specifier "1"
  -- check mix of positional and ordered placeholders
+ -- should raise warning
  select format('Hello %s %1$s %s', 'World', 'Hello again');
+ WARNING:  ordered and positional placeholders are used together
              format             
  -------------------------------
   Hello World World Hello again
  (1 row)
  
  select format('Hello %s %s, %2$s %2$s', 'World', 'Hello again');
+ WARNING:  ordered and positional placeholders are used together
                        format                      
  --------------------------------------------------
   Hello World Hello again, Hello again Hello again
  (1 row)
  
+ select format('Hello %s %2$s %s', 'World', 'Hello again');
+ WARNING:  ordered and positional placeholders are used together
+                format                
+ -------------------------------------
+  Hello World Hello again Hello again
+ (1 row)
+ 
  -- check variadic labeled arguments
  select format('%s, %s', variadic array['Hello','World']);
      format    
*** a/src/test/regress/sql/text.sql
--- b/src/test/regress/sql/text.sql
***************
*** 82,89 **** select format('%1s', 1);
--- 82,91 ----
  select format('%1$', 1);
  select format('%1$1', 1);
  -- check mix of positional and ordered placeholders
+ -- should raise warning
  select format('Hello %s %1$s %s', 'World', 'Hello again');
  select format('Hello %s %s, %2$s %2$s', 'World', 'Hello again');
+ select format('Hello %s %2$s %s', 'World', 'Hello again');
  -- check variadic labeled arguments
  select format('%s, %s', variadic array['Hello','World']);
  select format('%s, %s', variadic array[1, 2]);

*** a/doc/src/sgml/func.sgml
--- b/doc/src/sgml/func.sgml
***************
*** 1532,1538 ****
           SQL literal; <literal>%%</literal> outputs a literal <literal>%</>.
           A conversion can reference an explicit parameter position by preceding
           the conversion specifier with <literal><replaceable>n</>$</>, where
!          <replaceable>n</replaceable> is the argument position. A warnig is raised
           when positional and ordered placeholders are used together.
           See also <xref linkend="plpgsql-quote-literal-example">.
         </entry>
--- 1532,1540 ----
           SQL literal; <literal>%%</literal> outputs a literal <literal>%</>.
           A conversion can reference an explicit parameter position by preceding
           the conversion specifier with <literal><replaceable>n</>$</>, where
!          <replaceable>n</replaceable> is the argument position. Similary to C 
!          function <function>sprintf</>; is possible to specify a width for
!          <literal>%s</literal> conversion. A warnig is raised
           when positional and ordered placeholders are used together.
           See also <xref linkend="plpgsql-quote-literal-example">.
         </entry>
*** a/src/backend/utils/adt/varlena.c
--- b/src/backend/utils/adt/varlena.c
***************
*** 78,84 **** static bytea *bytea_overlay(bytea *t1, bytea *t2, int sp, int sl);
  static StringInfo makeStringAggState(FunctionCallInfo fcinfo);
  static void text_format_string_conversion(StringInfo buf, char conversion,
  							  FmgrInfo *typOutputInfo,
! 							  Datum value, bool isNull);
  static Datum text_to_array_internal(PG_FUNCTION_ARGS);
  static text *array_to_text_internal(FunctionCallInfo fcinfo, ArrayType *v,
  					   const char *fldsep, const char *null_string);
--- 78,85 ----
  static StringInfo makeStringAggState(FunctionCallInfo fcinfo);
  static void text_format_string_conversion(StringInfo buf, char conversion,
  							  FmgrInfo *typOutputInfo,
! 							  Datum value, bool isNull,
! 							  bool use_width, int width);
  static Datum text_to_array_internal(PG_FUNCTION_ARGS);
  static text *array_to_text_internal(FunctionCallInfo fcinfo, ArrayType *v,
  					   const char *fldsep, const char *null_string);
***************
*** 3984,3989 **** text_reverse(PG_FUNCTION_ARGS)
--- 3985,4065 ----
  }
  
  /*
+  * Returns ptr of first non digit char. Raise error,
+  * when no digit is processed or when result of parsing is not number
+  */
+ static const char *
+ parse_digit_subformat(const char *start_ptr, const char *end_ptr, int *value)
+ {
+ 	const char *cp = start_ptr;
+ 	bool	minus = false;
+ 	int	inum = 0;
+ 
+ 	/* continue, only when start_ptr is less than end_ptr */
+ 	if (cp < end_ptr)
+ 	{
+ 		if (*cp == '-')
+ 		{
+ 			minus = true;
+ 			start_ptr = cp++;
+ 		}
+ 
+ 		while (cp < end_ptr)
+ 		{
+ 			if (*cp >= '0' && *cp <= '9')
+ 			{
+ 				int	newnum = inum * 10 + (*cp - '0');
+ 
+ 				if (newnum / 10 != inum) /* overflow? */
+ 					ereport(ERROR,
+ 							(errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
+ 							 errmsg("number is out of range")));
+ 				inum = newnum;
+ 				++cp;
+ 			}
+ 			else
+ 				break;
+ 		}
+ 
+ 		*value = minus ? - inum : inum;
+ 	}
+ 
+ 	/* digit cannot be last char */
+ 	if (cp >= end_ptr)
+ 		ereport(ERROR,
+ 				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+ 				 errmsg("unterminated conversion specifier")));
+ 
+ 	/* we call this routine, only when we expected number */
+ 	if (cp == start_ptr)
+ 		ereport(ERROR,
+ 				(errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
+ 				 errmsg("invalid format, missing expected number")));
+ 
+ 	/* argument number must by greather than zero */
+ 	if (*cp == '$')
+ 	{
+ 		if (minus)
+ 			ereport(ERROR,
+ 					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+ 					 errmsg("conversion specifies argument 0, but arguments are numbered from 1")));
+ 
+ 		if (inum == 0)
+ 			ereport(ERROR,
+ 					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+ 					 errmsg("conversion specifies argument 0, but arguments are numbered from 1")));
+ 
+ 		/* $ must not be last char */
+ 		if (cp + 1 >= end_ptr)
+ 			ereport(ERROR,
+ 					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+ 					 errmsg("unterminated conversion specifier")));
+ 	}
+ 
+ 	return cp;
+ }
+ 
+ /*
   * Returns a formated string
   */
  Datum
***************
*** 4003,4009 **** text_format(PG_FUNCTION_ARGS)
  	Oid			element_type = InvalidOid;
  	Oid			prev_type = InvalidOid;
  	FmgrInfo	typoutputfinfo;
! 	int		position = 0;
  	bool		positional = false;
  	bool		ordered = false;
  	bool		warning_emmited = false;
--- 4079,4085 ----
  	Oid			element_type = InvalidOid;
  	Oid			prev_type = InvalidOid;
  	FmgrInfo	typoutputfinfo;
! 	int		ordered_nargs = 0;
  	bool		positional = false;
  	bool		ordered = false;
  	bool		warning_emmited = false;
***************
*** 4066,4071 **** text_format(PG_FUNCTION_ARGS)
--- 4142,4149 ----
  		Datum		value;
  		bool		isNull;
  		Oid			typid;
+ 		int		width = 0;
+ 		bool		use_width = false;
  
  		/*
  		 * If it's not the start of a conversion specifier, just copy it to
***************
*** 4090,4111 **** text_format(PG_FUNCTION_ARGS)
  			continue;
  		}
  
  		/*
! 		 * If the user hasn't specified an argument position, we just advance
! 		 * to the next one.  If they have, we must parse it.
  		 */
! 		if (*cp < '0' || *cp > '9')
  		{
! 			/* don't allow mix styles - reflects glibc behave */
! 			if (positional && !warning_emmited)
  			{
! 				elog(WARNING, "ordered and positional placeholders are used together");
! 				warning_emmited = true;
  			}
! 			ordered = true;
  
! 			++position;
! 			if (position <= 0)		/* overflow? */
  			{
  				/*
  				 * Should not happen, as you can't pass billions of arguments
--- 4168,4211 ----
  			continue;
  		}
  
+ 		arg = 0;
  		/*
! 		 * User can specify a width or a position or both. The width should
! 		 * be negative.
  		 */
! 		if (*cp == '-' || (*cp >= '0' && *cp <= '9'))
  		{
! 			cp = parse_digit_subformat(cp, end_ptr, &arg);
! 
! 			if (*cp == '$')
  			{
! 				++cp;
! 				if (*cp == '-' || (*cp >= '0' && *cp <= '9'))
! 				{
! 					cp = parse_digit_subformat(cp, end_ptr, &width);
! 
! 					if (*cp == '$')
! 						ereport(ERROR,
! 								(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
! 								 errmsg("argument number is defined yet")));
! 
! 					use_width = true;
! 				}
  			}
! 			else
! 			{
! 				/* previous digits was a width not argument number */
! 				width = arg;
! 				arg = 0;
! 				use_width = true;
! 			}
! 		}
  
! 		/* when argument not specified yet, use a next one */
! 		if (arg == 0)
! 		{
! 			++ordered_nargs;
! 			if (ordered_nargs <= 0)		/* overflow? */
  			{
  				/*
  				 * Should not happen, as you can't pass billions of arguments
***************
*** 4115,4170 **** text_format(PG_FUNCTION_ARGS)
  						(errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
  						 errmsg("argument number is out of range")));
  			}
! 			arg = position;
! 		}
! 		else
! 		{
! 			bool		unterminated = false;
! 
! 			/* Parse digit string. */
! 			arg = 0;
! 			do
! 			{
! 				int			newarg = arg * 10 + (*cp - '0');
  
! 				if (newarg / 10 != arg) /* overflow? */
! 					ereport(ERROR,
! 							(errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
! 							 errmsg("argument number is out of range")));
! 				arg = newarg;
! 				++cp;
! 			} while (cp < end_ptr && *cp >= '0' && *cp <= '9');
! 
! 			/*
! 			 * If we ran off the end, or if there's not a $ next, or if the $
! 			 * is the last character, the conversion specifier is improperly
! 			 * terminated.
! 			 */
! 			if (cp == end_ptr || *cp != '$')
! 				unterminated = true;
! 			else
  			{
! 				++cp;
! 				if (cp == end_ptr)
! 					unterminated = true;
  			}
- 			if (unterminated)
- 				ereport(ERROR,
- 						(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
- 						 errmsg("unterminated conversion specifier")));
  
  			if (ordered && !warning_emmited)
  			{
  				elog(WARNING, "ordered and positional placeholders are used together");
  				warning_emmited = true;
  			}
- 			positional = true;
  
! 			/* There's no argument 0. */
! 			if (arg == 0)
! 				ereport(ERROR,
! 						(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
! 						 errmsg("conversion specifies argument 0, but arguments are numbered from 1")));
  		}
  
  		/* Not enough arguments?  Deduct 1 to avoid counting format string. */
--- 4215,4240 ----
  						(errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
  						 errmsg("argument number is out of range")));
  			}
! 			arg = ordered_nargs;
  
! 			/* raise warning when found mixed placeholders, but only once */
! 			if (positional && !warning_emmited)
  			{
! 				elog(WARNING, "ordered and positional placeholders are used together");
! 				warning_emmited = true;
  			}
  
+ 			ordered = true;
+ 		}
+ 		else
+ 		{
  			if (ordered && !warning_emmited)
  			{
  				elog(WARNING, "ordered and positional placeholders are used together");
  				warning_emmited = true;
  			}
  
! 			positional = true;
  		}
  
  		/* Not enough arguments?  Deduct 1 to avoid counting format string. */
***************
*** 4212,4221 **** text_format(PG_FUNCTION_ARGS)
  		switch (*cp)
  		{
  			case 's':
  			case 'I':
  			case 'L':
  				text_format_string_conversion(&str, *cp, &typoutputfinfo,
! 											  value, isNull);
  				break;
  			default:
  				ereport(ERROR,
--- 4282,4301 ----
  		switch (*cp)
  		{
  			case 's':
+ 				text_format_string_conversion(&str, *cp, &typoutputfinfo,
+ 											  value, isNull,
+ 											  use_width, width);
+ 				break;
+ 
  			case 'I':
  			case 'L':
+ 				if (use_width)
+ 					ereport(ERROR,
+ 							(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+ 							 errmsg("conversion \"%c\" doesn't support the width specification", *cp)));
  				text_format_string_conversion(&str, *cp, &typoutputfinfo,
! 											  value, isNull,
! 											  false, 0);
  				break;
  			default:
  				ereport(ERROR,
***************
*** 4242,4248 **** text_format(PG_FUNCTION_ARGS)
  static void
  text_format_string_conversion(StringInfo buf, char conversion,
  							  FmgrInfo *typOutputInfo,
! 							  Datum value, bool isNull)
  {
  	char	   *str;
  
--- 4322,4329 ----
  static void
  text_format_string_conversion(StringInfo buf, char conversion,
  							  FmgrInfo *typOutputInfo,
! 							  Datum value, bool isNull,
! 							  bool use_width, int width)
  {
  	char	   *str;
  
***************
*** 4276,4282 **** text_format_string_conversion(StringInfo buf, char conversion,
  		pfree(qstr);
  	}
  	else
! 		appendStringInfoString(buf, str);
  
  	/* Cleanup. */
  	pfree(str);
--- 4357,4386 ----
  		pfree(qstr);
  	}
  	else
! 	{
! 		/* fast path */
! 		if (!use_width)
! 			appendStringInfoString(buf, str);
! 		else
! 		{
! 			int	len = pg_mbstrlen(str);
! 
! 			if (width < 0)
! 			{
! 				/* allign to left */
! 				appendStringInfoString(buf, str);
! 				if (len < (-width))
! 					appendStringInfoSpaces(buf, - (len + width));
! 			}
! 			else
! 			{
! 				/* allign to right */
! 				if (len < width)
! 					appendStringInfoSpaces(buf, width - len);
! 				appendStringInfoString(buf, str);
! 			}
! 		}
! 	}
  
  	/* Cleanup. */
  	pfree(str);
*** a/src/test/regress/expected/text.out
--- b/src/test/regress/expected/text.out
***************
*** 258,269 **** select format('%1$s %4$s', 1, 2, 3);
  ERROR:  too few arguments for format
  select format('%1$s %13$s', 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12);
  ERROR:  too few arguments for format
- select format('%1s', 1);
- ERROR:  unterminated conversion specifier
  select format('%1$', 1);
  ERROR:  unterminated conversion specifier
  select format('%1$1', 1);
! ERROR:  unrecognized conversion specifier "1"
  -- check mix of positional and ordered placeholders
  -- should raise warning
  select format('Hello %s %1$s %s', 'World', 'Hello again');
--- 258,267 ----
  ERROR:  too few arguments for format
  select format('%1$s %13$s', 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12);
  ERROR:  too few arguments for format
  select format('%1$', 1);
  ERROR:  unterminated conversion specifier
  select format('%1$1', 1);
! ERROR:  unterminated conversion specifier
  -- check mix of positional and ordered placeholders
  -- should raise warning
  select format('Hello %s %1$s %s', 'World', 'Hello again');
***************
*** 340,342 **** from generate_series(1,200) g(i);
--- 338,372 ----
   1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,160,161,162,163,164,165,166,167,168,169,170,171,172,173,174,175,176,177,178,179,180,181,182,183,184,185,186,187,188,189,190,191,192,193,194,195,196,197,198,199,200
  (1 row)
  
+ -- format with a width
+ select format('>>%10s<<', 'Hello');
+      format     
+ ----------------
+  >>     Hello<<
+ (1 row)
+ 
+ select format('>>%-10s<<', 'Hello');
+      format     
+ ----------------
+  >>Hello     <<
+ (1 row)
+ 
+ select format('>>%1$10s<<', 'Hello');
+      format     
+ ----------------
+  >>     Hello<<
+ (1 row)
+ 
+ select format('>>%1$-10s<<', 'Hello');
+      format     
+ ----------------
+  >>Hello     <<
+ (1 row)
+ 
+ -- should fail
+ select format('>>%1$1$s<<', 'Hello');
+ ERROR:  argument number is defined yet
+ select format('>>%10I<<', 'tablename');
+ ERROR:  conversion "I" doesn't support the width specification
+ select format('>>%1$10L<<', 'tablename');
+ ERROR:  conversion "L" doesn't support the width specification
*** a/src/test/regress/sql/text.sql
--- b/src/test/regress/sql/text.sql
***************
*** 78,84 **** select format('%1$s %12$s', 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12);
  -- should fail
  select format('%1$s %4$s', 1, 2, 3);
  select format('%1$s %13$s', 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12);
- select format('%1s', 1);
  select format('%1$', 1);
  select format('%1$1', 1);
  -- check mix of positional and ordered placeholders
--- 78,83 ----
***************
*** 99,101 **** select format('Hello', variadic NULL::int[]);
--- 98,112 ----
  -- variadic argument allows simulating more than FUNC_MAX_ARGS parameters
  select format(string_agg('%s',','), variadic array_agg(i))
  from generate_series(1,200) g(i);
+ 
+ 
+ -- format with a width
+ select format('>>%10s<<', 'Hello');
+ select format('>>%-10s<<', 'Hello');
+ select format('>>%1$10s<<', 'Hello');
+ select format('>>%1$-10s<<', 'Hello');
+ 
+ -- should fail
+ select format('>>%1$1$s<<', 'Hello');
+ select format('>>%10I<<', 'tablename');
+ select format('>>%1$10L<<', 'tablename');

*** a/src/backend/utils/adt/varlena.c
--- b/src/backend/utils/adt/varlena.c
***************
*** 78,84 **** static bytea *bytea_overlay(bytea *t1, bytea *t2, int sp, int sl);
  static StringInfo makeStringAggState(FunctionCallInfo fcinfo);
  static void text_format_string_conversion(StringInfo buf, char conversion,
  							  FmgrInfo *typOutputInfo,
! 							  Datum value, bool isNull);
  static Datum text_to_array_internal(PG_FUNCTION_ARGS);
  static text *array_to_text_internal(FunctionCallInfo fcinfo, ArrayType *v,
  					   const char *fldsep, const char *null_string);
--- 78,85 ----
  static StringInfo makeStringAggState(FunctionCallInfo fcinfo);
  static void text_format_string_conversion(StringInfo buf, char conversion,
  							  FmgrInfo *typOutputInfo,
! 							  Datum value, bool isNull,
! 							  int flags, bool use_width, int width);
  static Datum text_to_array_internal(PG_FUNCTION_ARGS);
  static text *array_to_text_internal(FunctionCallInfo fcinfo, ArrayType *v,
  					   const char *fldsep, const char *null_string);
***************
*** 3997,4002 **** text_reverse(PG_FUNCTION_ARGS)
--- 3998,4134 ----
  }
  
  /*
+  * Returns pointer of first non digit char
+  *
+  * When some digits are processed, then inum returns parsed number
+  * and is_valid is true, otherwise is_valid is false.
+  */
+ static const char *
+ text_format_parse_digits(const char *start_ptr, const char *end_ptr,
+ 				int	*inum,					/* OUT param */
+ 				bool	*is_valid)				/* OUT param */
+ {
+ 	const char *cp = start_ptr;
+ 
+ 	*is_valid = false;
+ 	*inum = 0;
+ 
+ 	/* continue, only when start_ptr is less than end_ptr */
+ 	while (cp < end_ptr)
+ 	{
+ 		if (*cp >= '0' && *cp <= '9')
+ 		{
+ 			int	newnum = *inum * 10 + (*cp - '0');
+ 
+ 			if (newnum / 10 != *inum) /* overflow? */
+ 				ereport(ERROR,
+ 						(errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
+ 						 errmsg("number is out of range")));
+ 			*inum = newnum;
+ 			*is_valid = true;
+ 			++cp;
+ 		}
+ 		else
+ 			break;
+ 	}
+ 
+ 	/* should not be after last char of format string */
+ 	if (cp >= end_ptr)
+ 		ereport(ERROR,
+ 				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+ 				 errmsg("unterminated conversion specifier")));
+ 
+ 	return cp;
+ }
+ 
+ #define TEXT_FORMAT_FLAG_MINUS	0x0001			/* is minus in format string? */
+ 
+ #define TEXT_FORMAT_NEXT_CHAR(ptr, end_ptr) \
+ do { \
+ 	if (++(ptr) >= (end_ptr)) \
+ 		ereport(ERROR, \
+ 				(errcode(ERRCODE_INVALID_PARAMETER_VALUE), \
+ 				 errmsg("unterminated conversion specifier"))); \
+ } while (0)
+ 
+ /*
+  * parse format specification
+  *             [parameter][flags][width]type
+  *
+  * -1 in int OUT parameters signalize so this attribut is missing,
+  * all values should be zero or greather than zero. Raise exeption
+  * when some parameter is out of range.
+  */
+ static const char *
+ text_format_parse_format(const char *start_ptr, const char *end_ptr,
+ 				int *parameter,						/* OUT param */
+ 				int *flags,						/* OUT param */
+ 				int *width,						/* OUT param */
+ 				bool *indirect_width,					/* OUT param */
+ 				int *indirect_width_parameter)				/* OUT param */
+ {
+ 	int	   inum;
+ 	bool	   is_valid;
+ 
+ 	/* set defaults to out parameters */
+ 	*parameter = -1;
+ 	*flags = 0;
+ 	*width = -1;
+ 	*indirect_width = false;
+ 	*indirect_width_parameter = -1;
+ 
+ 	/* try to identify first number */
+ 	start_ptr = text_format_parse_digits(start_ptr, end_ptr, &inum, &is_valid);
+ 	if (is_valid)
+ 	{
+ 		/* number on this position can be parameter number or the width */
+ 		if (*start_ptr != '$')
+ 		{
+ 			*width = inum;
+ 			return start_ptr;
+ 		}
+ 
+ 		*parameter = inum;
+ 		TEXT_FORMAT_NEXT_CHAR(start_ptr, end_ptr);
+ 	}
+ 
+ 	/* try to parse flags, only minus is supported now */
+ 	if (*start_ptr == '-')
+ 	{
+ 		*flags = *flags | TEXT_FORMAT_FLAG_MINUS;
+ 		TEXT_FORMAT_NEXT_CHAR(start_ptr, end_ptr);
+ 	}
+ 
+ 	/* try to parse indirect width */
+ 	if (*start_ptr == '*')
+ 	{
+ 		start_ptr = text_format_parse_digits(++start_ptr, end_ptr, &inum, &is_valid);
+ 		if (is_valid)
+ 		{
+ 			/* number in this position should be closed by $ */
+ 			if (*start_ptr != '$')
+ 				ereport(ERROR,
+ 						(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+ 						 errmsg("unexpected char \"%c\"", *start_ptr)));
+ 			TEXT_FORMAT_NEXT_CHAR(start_ptr, end_ptr);
+ 
+ 			*indirect_width_parameter = inum;
+ 		}
+ 		else
+ 			*indirect_width = true;
+ 
+ 		return start_ptr;
+ 	}
+ 
+ 	/* last possible nummber - width */
+ 	start_ptr = text_format_parse_digits(start_ptr, end_ptr, &inum, &is_valid);
+ 	if (is_valid)
+ 		*width = inum;
+ 
+ 	return start_ptr;
+ }
+ 
+ /*
   * Returns a formated string
   */
  Datum
***************
*** 4016,4021 **** text_format(PG_FUNCTION_ARGS)
--- 4148,4155 ----
  	Oid			element_type = InvalidOid;
  	Oid			prev_type = InvalidOid;
  	FmgrInfo	typoutputfinfo;
+ 	FmgrInfo		typoutputinfo_width;
+ 	Oid			prev_type_width = InvalidOid;
  
  	/* When format string is null, returns null */
  	if (PG_ARGISNULL(0))
***************
*** 4088,4093 **** text_format(PG_FUNCTION_ARGS)
--- 4222,4233 ----
  		Datum		value;
  		bool		isNull;
  		Oid			typid;
+ 		int parameter;
+ 		int flags;
+ 		int width;
+ 		bool indirect_width;
+ 		int indirect_width_parameter;
+ 		bool		use_width;
  
  		/*
  		 * If it's not the start of a conversion specifier, just copy it to
***************
*** 4099,4109 **** text_format(PG_FUNCTION_ARGS)
  			continue;
  		}
  
! 		/* Did we run off the end of the string? */
! 		if (++cp >= end_ptr)
! 			ereport(ERROR,
! 					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
! 					 errmsg("unterminated conversion specifier")));
  
  		/* Easy case: %% outputs a single % */
  		if (*cp == '%')
--- 4239,4246 ----
  			continue;
  		}
  
! 		/* go to next char */
! 		TEXT_FORMAT_NEXT_CHAR(cp, end_ptr);
  
  		/* Easy case: %% outputs a single % */
  		if (*cp == '%')
***************
*** 4112,4125 **** text_format(PG_FUNCTION_ARGS)
  			continue;
  		}
  
! 		/*
! 		 * If the user hasn't specified an argument position, we just advance
! 		 * to the next one.  If they have, we must parse it.
! 		 */
! 		if (*cp < '0' || *cp > '9')
  		{
! 			++arg;
! 			if (arg <= 0)		/* overflow? */
  			{
  				/*
  				 * Should not happen, as you can't pass billions of arguments
--- 4249,4264 ----
  			continue;
  		}
  
! 		cp = text_format_parse_format(cp, end_ptr,
! 								&parameter,
! 								&flags,
! 								&width,
! 								&indirect_width,
! 								&indirect_width_parameter);
! 
! 		if (indirect_width)
  		{
! 			if (++arg <= 0)		/* overflow? */
  			{
  				/*
  				 * Should not happen, as you can't pass billions of arguments
***************
*** 4129,4177 **** text_format(PG_FUNCTION_ARGS)
  						(errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
  						 errmsg("argument number is out of range")));
  			}
  		}
! 		else
  		{
! 			bool		unterminated = false;
! 
! 			/* Parse digit string. */
! 			arg = 0;
! 			do
! 			{
! 				int			newarg = arg * 10 + (*cp - '0');
! 
! 				if (newarg / 10 != arg) /* overflow? */
! 					ereport(ERROR,
! 							(errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
! 							 errmsg("argument number is out of range")));
! 				arg = newarg;
! 				++cp;
! 			} while (cp < end_ptr && *cp >= '0' && *cp <= '9');
  
! 			/*
! 			 * If we ran off the end, or if there's not a $ next, or if the $
! 			 * is the last character, the conversion specifier is improperly
! 			 * terminated.
! 			 */
! 			if (cp == end_ptr || *cp != '$')
! 				unterminated = true;
! 			else
  			{
! 				++cp;
! 				if (cp == end_ptr)
! 					unterminated = true;
! 			}
! 			if (unterminated)
! 				ereport(ERROR,
! 						(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
! 						 errmsg("unterminated conversion specifier")));
! 
! 			/* There's no argument 0. */
! 			if (arg == 0)
  				ereport(ERROR,
! 						(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
! 						 errmsg("conversion specifies argument 0, but arguments are numbered from 1")));
  		}
  
  		/* Not enough arguments?  Deduct 1 to avoid counting format string. */
  		if (arg > nargs - 1)
--- 4268,4301 ----
  						(errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
  						 errmsg("argument number is out of range")));
  			}
+ 			indirect_width_parameter = arg;
  		}
! 		else if (indirect_width_parameter != -1)
  		{
! 			/* be consistent, move ordered argument together with positional */
! 			arg = indirect_width_parameter;
! 		}
  
! 		if (parameter == -1)
! 		{
! 			if (++arg <= 0)		/* overflow? */
  			{
! 				/*
! 				 * Should not happen, as you can't pass billions of arguments
! 				 * to a function, but better safe than sorry.
! 				 */
  				ereport(ERROR,
! 						(errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
! 						 errmsg("argument number is out of range")));
! 			}
  		}
+ 		else
+ 			arg = parameter;
+ 
+ 		if (arg == 0)
+ 			ereport(ERROR,
+ 					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+ 					 errmsg("conversion specifies argument 0, but arguments are numbered from 1")));
  
  		/* Not enough arguments?  Deduct 1 to avoid counting format string. */
  		if (arg > nargs - 1)
***************
*** 4179,4184 **** text_format(PG_FUNCTION_ARGS)
--- 4303,4380 ----
  					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
  					 errmsg("too few arguments for format")));
  
+ 		if (indirect_width_parameter != -1)
+ 		{
+ 
+ 			if (indirect_width_parameter == 0)
+ 				ereport(ERROR,
+ 						(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+ 						 errmsg("conversion specifies argument 0, but arguments are numbered from 1")));
+ 
+ 			/* Not enough arguments?  Deduct 1 to avoid counting format string. */
+ 			if (indirect_width_parameter > nargs - 1)
+ 				ereport(ERROR,
+ 						(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+ 						 errmsg("too few arguments for format")));
+ 
+ 			/* get value of related parameter that holds width and coerce to int */
+ 			if (!funcvariadic)
+ 			{
+ 				value = PG_GETARG_DATUM(indirect_width_parameter);
+ 				isNull = PG_ARGISNULL(indirect_width_parameter);
+ 				typid = get_fn_expr_argtype(fcinfo->flinfo, indirect_width_parameter);
+ 			}
+ 			else
+ 			{
+ 				value = elements[indirect_width_parameter - 1];
+ 				isNull = nulls[indirect_width_parameter - 1];
+ 				typid = element_type;
+ 			}
+ 			if (!OidIsValid(typid))
+ 				elog(ERROR, "could not determine data type of format() input");
+ 
+ 			/* QUESTION: is it correct? */
+ 			if (isNull)
+ 				ereport(ERROR,
+ 						(errcode(ERRCODE_NULL_VALUE_NOT_ALLOWED),
+ 				errmsg("width should not be NULL")));
+ 
+ 			/* simple IO cast to int */
+ 			if (typid != INT4OID)
+ 			{
+ 				char			*str;
+ 
+ 				if (typid != prev_type_width)
+ 				{
+ 					Oid			typoutputfunc;
+ 					bool		typIsVarlena;
+ 
+ 					getTypeOutputInfo(typid, &typoutputfunc, &typIsVarlena);
+ 					fmgr_info(typoutputfunc, &typoutputinfo_width);
+ 					prev_type_width = typid;
+ 				}
+ 
+ 				/* Stringify. */
+ 				str = OutputFunctionCall(&typoutputinfo_width, value);
+ 
+ 				/* get int value */
+ 				width = pg_atoi(str, sizeof(int32), '\0');
+ 				pfree(str);
+ 			}
+ 			else
+ 				width = DatumGetInt32(value);
+ 
+ 			use_width = true;
+ 		}
+ 		else if (width != -1)
+ 		{
+ 			use_width = true;
+ 		}
+ 		else
+ 		{
+ 			use_width = false;
+ 		}
+ 
  		/* Get the value and type of the selected argument */
  		if (!funcvariadic)
  		{
***************
*** 4221,4227 **** text_format(PG_FUNCTION_ARGS)
  			case 'I':
  			case 'L':
  				text_format_string_conversion(&str, *cp, &typoutputfinfo,
! 											  value, isNull);
  				break;
  			default:
  				ereport(ERROR,
--- 4417,4424 ----
  			case 'I':
  			case 'L':
  				text_format_string_conversion(&str, *cp, &typoutputfinfo,
! 											  value, isNull,
! 											  flags, use_width, width);
  				break;
  			default:
  				ereport(ERROR,
***************
*** 4244,4254 **** text_format(PG_FUNCTION_ARGS)
  	PG_RETURN_TEXT_P(result);
  }
  
  /* Format a %s, %I, or %L conversion. */
  static void
  text_format_string_conversion(StringInfo buf, char conversion,
  							  FmgrInfo *typOutputInfo,
! 							  Datum value, bool isNull)
  {
  	char	   *str;
  
--- 4441,4497 ----
  	PG_RETURN_TEXT_P(result);
  }
  
+ /*
+  * Add spaces on begin or on end when it is necessary
+  */
+ static void
+ text_format_append_string(StringInfo buf, const char *str,
+ 					  int flags, bool use_width, int width)
+ {
+ 	bool		align_to_left;
+ 	int		len;
+ 
+ 	/* fast path */
+ 	if (!use_width)
+ 	{
+ 		appendStringInfoString(buf, str);
+ 		return;
+ 	}
+ 
+ 	if (width < 0)
+ 	{
+ 		width = -width;
+ 		align_to_left = true;
+ 	}
+ 	else if (flags & TEXT_FORMAT_FLAG_MINUS)
+ 	{
+ 		align_to_left = true;
+ 	}
+ 	else
+ 		align_to_left = false;
+ 
+ 	len = pg_mbstrlen(str);
+ 	if (align_to_left)
+ 	{
+ 		appendStringInfoString(buf, str);
+ 		if (len < width)
+ 			appendStringInfoSpaces(buf, width - len);
+ 	}
+ 	else
+ 	{
+ 		/* align_to_right */
+ 		if (len < width)
+ 			appendStringInfoSpaces(buf, width - len);
+ 		appendStringInfoString(buf, str);
+ 	}
+ }
+ 
  /* Format a %s, %I, or %L conversion. */
  static void
  text_format_string_conversion(StringInfo buf, char conversion,
  							  FmgrInfo *typOutputInfo,
! 							  Datum value, bool isNull,
! 							  int flags, bool use_width, int width)
  {
  	char	   *str;
  
***************
*** 4271,4288 **** text_format_string_conversion(StringInfo buf, char conversion,
  	if (conversion == 'I')
  	{
  		/* quote_identifier may or may not allocate a new string. */
! 		appendStringInfoString(buf, quote_identifier(str));
  	}
  	else if (conversion == 'L')
! 	{
! 		char	   *qstr = quote_literal_cstr(str);
  
! 		appendStringInfoString(buf, qstr);
  		/* quote_literal_cstr() always allocates a new string */
  		pfree(qstr);
  	}
  	else
! 		appendStringInfoString(buf, str);
  
  	/* Cleanup. */
  	pfree(str);
--- 4514,4533 ----
  	if (conversion == 'I')
  	{
  		/* quote_identifier may or may not allocate a new string. */
! 		text_format_append_string(buf, quote_identifier(str),
! 							flags, use_width, width);
  	}
  	else if (conversion == 'L')
! 	{		char	   *qstr = quote_literal_cstr(str);
  
! 		text_format_append_string(buf, qstr,
! 							flags, use_width, width);
  		/* quote_literal_cstr() always allocates a new string */
  		pfree(qstr);
  	}
  	else
! 		text_format_append_string(buf, str,
! 							flags, use_width, width);
  
  	/* Cleanup. */
  	pfree(str);
*** a/src/test/regress/expected/text.out
--- b/src/test/regress/expected/text.out
***************
*** 257,267 **** ERROR:  too few arguments for format
  select format('%1$s %13$s', 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12);
  ERROR:  too few arguments for format
  select format('%1s', 1);
! ERROR:  unterminated conversion specifier
  select format('%1$', 1);
  ERROR:  unterminated conversion specifier
  select format('%1$1', 1);
! ERROR:  unrecognized conversion specifier "1"
  -- check mix of positional and ordered placeholders
  select format('Hello %s %1$s %s', 'World', 'Hello again');
              format             
--- 257,271 ----
  select format('%1$s %13$s', 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12);
  ERROR:  too few arguments for format
  select format('%1s', 1);
!  format 
! --------
!  1
! (1 row)
! 
  select format('%1$', 1);
  ERROR:  unterminated conversion specifier
  select format('%1$1', 1);
! ERROR:  unterminated conversion specifier
  -- check mix of positional and ordered placeholders
  select format('Hello %s %1$s %s', 'World', 'Hello again');
              format             
***************
*** 328,330 **** from generate_series(1,200) g(i);
--- 332,371 ----
   1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,160,161,162,163,164,165,166,167,168,169,170,171,172,173,174,175,176,177,178,179,180,181,182,183,184,185,186,187,188,189,190,191,192,193,194,195,196,197,198,199,200
  (1 row)
  
+ -- left, right align
+ select format('>>%10s<<', 'Hello')
+ union all
+ select format('>>%-10s<<', 'Hello')
+ union all
+ select format('>>%1$10s<<', 'Hello')
+ union all
+ select format('>>%1$-10I<<', 'Hello')
+ union all
+ select format('>>%2$*1$L<<', 10, 'Hello')
+ union all
+ select format('>>%*s<<', 10, 'Hello');
+      format     
+ ----------------
+  >>     Hello<<
+  >>Hello     <<
+  >>     Hello<<
+  >>"Hello"   <<
+  >>   'Hello'<<
+  >>     Hello<<
+ (6 rows)
+ 
+ select format('>>%*1$s<<', 10, 'Hello');
+      format     
+ ----------------
+  >>     Hello<<
+ (1 row)
+ 
+ select format('>>%-s<<', 'Hello');
+   format   
+ -----------
+  >>Hello<<
+ (1 row)
+ 
+ -- should fail
+ select format('>>%2$*1$L<<', NULL, 'Hello');
+ ERROR:  width should not be NULL
*** a/src/test/regress/sql/text.sql
--- b/src/test/regress/sql/text.sql
***************
*** 97,99 **** select format('Hello', variadic NULL);
--- 97,120 ----
  -- variadic argument allows simulating more than FUNC_MAX_ARGS parameters
  select format(string_agg('%s',','), variadic array_agg(i))
  from generate_series(1,200) g(i);
+ 
+ -- left, right align
+ select format('>>%10s<<', 'Hello')
+ union all
+ select format('>>%-10s<<', 'Hello')
+ union all
+ select format('>>%1$10s<<', 'Hello')
+ union all
+ select format('>>%1$-10I<<', 'Hello')
+ union all
+ select format('>>%2$*1$L<<', 10, 'Hello')
+ union all
+ select format('>>%*s<<', 10, 'Hello');
+ 
+ select format('>>%*1$s<<', 10, 'Hello');
+ select format('>>%-s<<', 'Hello');
+ 
+ -- should fail
+ select format('>>%2$*1$L<<', NULL, 'Hello');
+ 
+ 

*** a/src/backend/utils/adt/varlena.c
--- b/src/backend/utils/adt/varlena.c
***************
*** 78,84 **** static bytea *bytea_overlay(bytea *t1, bytea *t2, int sp, int sl);
  static StringInfo makeStringAggState(FunctionCallInfo fcinfo);
  static void text_format_string_conversion(StringInfo buf, char conversion,
  							  FmgrInfo *typOutputInfo,
! 							  Datum value, bool isNull);
  static Datum text_to_array_internal(PG_FUNCTION_ARGS);
  static text *array_to_text_internal(FunctionCallInfo fcinfo, ArrayType *v,
  					   const char *fldsep, const char *null_string);
--- 78,85 ----
  static StringInfo makeStringAggState(FunctionCallInfo fcinfo);
  static void text_format_string_conversion(StringInfo buf, char conversion,
  							  FmgrInfo *typOutputInfo,
! 							  Datum value, bool isNull,
! 							  int flags, bool use_width, int width);
  static Datum text_to_array_internal(PG_FUNCTION_ARGS);
  static text *array_to_text_internal(FunctionCallInfo fcinfo, ArrayType *v,
  					   const char *fldsep, const char *null_string);
***************
*** 3997,4002 **** text_reverse(PG_FUNCTION_ARGS)
--- 3998,4134 ----
  }
  
  /*
+  * Returns pointer of first non digit char
+  *
+  * When some digits are processed, then inum returns parsed number
+  * and is_valid is true, otherwise is_valid is false.
+  */
+ static const char *
+ text_format_parse_digits(const char *start_ptr, const char *end_ptr,
+ 				int	*inum,					/* OUT param */
+ 				bool	*is_valid)				/* OUT param */
+ {
+ 	const char *cp = start_ptr;
+ 
+ 	*is_valid = false;
+ 	*inum = 0;
+ 
+ 	/* continue, only when start_ptr is less than end_ptr */
+ 	while (cp < end_ptr)
+ 	{
+ 		if (*cp >= '0' && *cp <= '9')
+ 		{
+ 			int	newnum = *inum * 10 + (*cp - '0');
+ 
+ 			if (newnum / 10 != *inum) /* overflow? */
+ 				ereport(ERROR,
+ 						(errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
+ 						 errmsg("number is out of range")));
+ 			*inum = newnum;
+ 			*is_valid = true;
+ 			++cp;
+ 		}
+ 		else
+ 			break;
+ 	}
+ 
+ 	/* should not be after last char of format string */
+ 	if (cp >= end_ptr)
+ 		ereport(ERROR,
+ 				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+ 				 errmsg("unterminated conversion specifier")));
+ 
+ 	return cp;
+ }
+ 
+ #define TEXT_FORMAT_FLAG_MINUS	0x0001			/* is minus in format string? */
+ 
+ #define TEXT_FORMAT_NEXT_CHAR(ptr, end_ptr) \
+ do { \
+ 	if (++(ptr) >= (end_ptr)) \
+ 		ereport(ERROR, \
+ 				(errcode(ERRCODE_INVALID_PARAMETER_VALUE), \
+ 				 errmsg("unterminated conversion specifier"))); \
+ } while (0)
+ 
+ /*
+  * parse format specification
+  *             [parameter][flags][width]type
+  *
+  * -1 in int OUT parameters signalize so this attribut is missing,
+  * all values should be zero or greather than zero. Raise exeption
+  * when some parameter is out of range.
+  */
+ static const char *
+ text_format_parse_format(const char *start_ptr, const char *end_ptr,
+ 				int *parameter,						/* OUT param */
+ 				int *flags,						/* OUT param */
+ 				int *width,						/* OUT param */
+ 				bool *indirect_width,					/* OUT param */
+ 				int *indirect_width_parameter)				/* OUT param */
+ {
+ 	int	   inum;
+ 	bool	   is_valid;
+ 
+ 	/* set defaults to out parameters */
+ 	*parameter = -1;
+ 	*flags = 0;
+ 	*width = -1;
+ 	*indirect_width = false;
+ 	*indirect_width_parameter = -1;
+ 
+ 	/* try to identify first number */
+ 	start_ptr = text_format_parse_digits(start_ptr, end_ptr, &inum, &is_valid);
+ 	if (is_valid)
+ 	{
+ 		/* number on this position can be parameter number or the width */
+ 		if (*start_ptr != '$')
+ 		{
+ 			*width = inum;
+ 			return start_ptr;
+ 		}
+ 
+ 		*parameter = inum;
+ 		TEXT_FORMAT_NEXT_CHAR(start_ptr, end_ptr);
+ 	}
+ 
+ 	/* try to parse flags, only minus is supported now */
+ 	if (*start_ptr == '-')
+ 	{
+ 		*flags = *flags | TEXT_FORMAT_FLAG_MINUS;
+ 		TEXT_FORMAT_NEXT_CHAR(start_ptr, end_ptr);
+ 	}
+ 
+ 	/* try to parse indirect width */
+ 	if (*start_ptr == '*')
+ 	{
+ 		start_ptr = text_format_parse_digits(++start_ptr, end_ptr, &inum, &is_valid);
+ 		if (is_valid)
+ 		{
+ 			/* number in this position should be closed by $ */
+ 			if (*start_ptr != '$')
+ 				ereport(ERROR,
+ 						(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+ 						 errmsg("unexpected char \"%c\"", *start_ptr)));
+ 			TEXT_FORMAT_NEXT_CHAR(start_ptr, end_ptr);
+ 
+ 			*indirect_width_parameter = inum;
+ 		}
+ 		else
+ 			*indirect_width = true;
+ 
+ 		return start_ptr;
+ 	}
+ 
+ 	/* last possible nummber - width */
+ 	start_ptr = text_format_parse_digits(start_ptr, end_ptr, &inum, &is_valid);
+ 	if (is_valid)
+ 		*width = inum;
+ 
+ 	return start_ptr;
+ }
+ 
+ /*
   * Returns a formated string
   */
  Datum
***************
*** 4016,4021 **** text_format(PG_FUNCTION_ARGS)
--- 4148,4155 ----
  	Oid			element_type = InvalidOid;
  	Oid			prev_type = InvalidOid;
  	FmgrInfo	typoutputfinfo;
+ 	FmgrInfo		typoutputinfo_width;
+ 	Oid			prev_type_width = InvalidOid;
  
  	/* When format string is null, returns null */
  	if (PG_ARGISNULL(0))
***************
*** 4088,4093 **** text_format(PG_FUNCTION_ARGS)
--- 4222,4233 ----
  		Datum		value;
  		bool		isNull;
  		Oid			typid;
+ 		int parameter;
+ 		int flags;
+ 		int width;
+ 		bool indirect_width;
+ 		int indirect_width_parameter;
+ 		bool		use_width;
  
  		/*
  		 * If it's not the start of a conversion specifier, just copy it to
***************
*** 4099,4109 **** text_format(PG_FUNCTION_ARGS)
  			continue;
  		}
  
! 		/* Did we run off the end of the string? */
! 		if (++cp >= end_ptr)
! 			ereport(ERROR,
! 					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
! 					 errmsg("unterminated conversion specifier")));
  
  		/* Easy case: %% outputs a single % */
  		if (*cp == '%')
--- 4239,4246 ----
  			continue;
  		}
  
! 		/* go to next char */
! 		TEXT_FORMAT_NEXT_CHAR(cp, end_ptr);
  
  		/* Easy case: %% outputs a single % */
  		if (*cp == '%')
***************
*** 4112,4125 **** text_format(PG_FUNCTION_ARGS)
  			continue;
  		}
  
! 		/*
! 		 * If the user hasn't specified an argument position, we just advance
! 		 * to the next one.  If they have, we must parse it.
! 		 */
! 		if (*cp < '0' || *cp > '9')
  		{
! 			++arg;
! 			if (arg <= 0)		/* overflow? */
  			{
  				/*
  				 * Should not happen, as you can't pass billions of arguments
--- 4249,4264 ----
  			continue;
  		}
  
! 		cp = text_format_parse_format(cp, end_ptr,
! 								&parameter,
! 								&flags,
! 								&width,
! 								&indirect_width,
! 								&indirect_width_parameter);
! 
! 		if (indirect_width)
  		{
! 			if (++arg <= 0)		/* overflow? */
  			{
  				/*
  				 * Should not happen, as you can't pass billions of arguments
***************
*** 4129,4177 **** text_format(PG_FUNCTION_ARGS)
  						(errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
  						 errmsg("argument number is out of range")));
  			}
  		}
! 		else
  		{
! 			bool		unterminated = false;
! 
! 			/* Parse digit string. */
! 			arg = 0;
! 			do
! 			{
! 				int			newarg = arg * 10 + (*cp - '0');
! 
! 				if (newarg / 10 != arg) /* overflow? */
! 					ereport(ERROR,
! 							(errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
! 							 errmsg("argument number is out of range")));
! 				arg = newarg;
! 				++cp;
! 			} while (cp < end_ptr && *cp >= '0' && *cp <= '9');
  
! 			/*
! 			 * If we ran off the end, or if there's not a $ next, or if the $
! 			 * is the last character, the conversion specifier is improperly
! 			 * terminated.
! 			 */
! 			if (cp == end_ptr || *cp != '$')
! 				unterminated = true;
! 			else
  			{
! 				++cp;
! 				if (cp == end_ptr)
! 					unterminated = true;
! 			}
! 			if (unterminated)
! 				ereport(ERROR,
! 						(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
! 						 errmsg("unterminated conversion specifier")));
! 
! 			/* There's no argument 0. */
! 			if (arg == 0)
  				ereport(ERROR,
! 						(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
! 						 errmsg("conversion specifies argument 0, but arguments are numbered from 1")));
  		}
  
  		/* Not enough arguments?  Deduct 1 to avoid counting format string. */
  		if (arg > nargs - 1)
--- 4268,4301 ----
  						(errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
  						 errmsg("argument number is out of range")));
  			}
+ 			indirect_width_parameter = arg;
  		}
! 		else if (indirect_width_parameter != -1)
  		{
! 			/* be consistent, move ordered argument together with positional */
! 			arg = indirect_width_parameter;
! 		}
  
! 		if (parameter == -1)
! 		{
! 			if (++arg <= 0)		/* overflow? */
  			{
! 				/*
! 				 * Should not happen, as you can't pass billions of arguments
! 				 * to a function, but better safe than sorry.
! 				 */
  				ereport(ERROR,
! 						(errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
! 						 errmsg("argument number is out of range")));
! 			}
  		}
+ 		else
+ 			arg = parameter;
+ 
+ 		if (arg == 0)
+ 			ereport(ERROR,
+ 					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+ 					 errmsg("conversion specifies argument 0, but arguments are numbered from 1")));
  
  		/* Not enough arguments?  Deduct 1 to avoid counting format string. */
  		if (arg > nargs - 1)
***************
*** 4179,4184 **** text_format(PG_FUNCTION_ARGS)
--- 4303,4376 ----
  					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
  					 errmsg("too few arguments for format")));
  
+ 		if (indirect_width_parameter != -1)
+ 		{
+ 
+ 			if (indirect_width_parameter == 0)
+ 				ereport(ERROR,
+ 						(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+ 						 errmsg("conversion specifies argument 0, but arguments are numbered from 1")));
+ 
+ 			/* Not enough arguments?  Deduct 1 to avoid counting format string. */
+ 			if (indirect_width_parameter > nargs - 1)
+ 				ereport(ERROR,
+ 						(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+ 						 errmsg("too few arguments for format")));
+ 
+ 			/* get value of related parameter that holds width and coerce to int */
+ 			if (!funcvariadic)
+ 			{
+ 				value = PG_GETARG_DATUM(indirect_width_parameter);
+ 				isNull = PG_ARGISNULL(indirect_width_parameter);
+ 				typid = get_fn_expr_argtype(fcinfo->flinfo, indirect_width_parameter);
+ 			}
+ 			else
+ 			{
+ 				value = elements[indirect_width_parameter - 1];
+ 				isNull = nulls[indirect_width_parameter - 1];
+ 				typid = element_type;
+ 			}
+ 			if (!OidIsValid(typid))
+ 				elog(ERROR, "could not determine data type of format() input");
+ 
+ 			/* QUESTION: is it correct? */
+ 			if (isNull)
+ 				ereport(ERROR,
+ 						(errcode(ERRCODE_NULL_VALUE_NOT_ALLOWED),
+ 				errmsg("width should not be NULL")));
+ 
+ 			/* simple IO cast to int */
+ 			if (typid != INT4OID)
+ 			{
+ 				char			*str;
+ 
+ 				if (typid != prev_type_width)
+ 				{
+ 					Oid			typoutputfunc;
+ 					bool		typIsVarlena;
+ 
+ 					getTypeOutputInfo(typid, &typoutputfunc, &typIsVarlena);
+ 					fmgr_info(typoutputfunc, &typoutputinfo_width);
+ 					prev_type_width = typid;
+ 				}
+ 
+ 				/* Stringify. */
+ 				str = OutputFunctionCall(&typoutputinfo_width, value);
+ 
+ 				/* get int value */
+ 				width = pg_atoi(str, sizeof(int32), '\0');
+ 				pfree(str);
+ 			}
+ 			else
+ 				width = DatumGetInt32(value);
+ 
+ 			use_width = true;
+ 		}
+ 		else if (width != -1)
+ 			use_width = true;
+ 		else
+ 			use_width = false;
+ 
  		/* Get the value and type of the selected argument */
  		if (!funcvariadic)
  		{
***************
*** 4221,4227 **** text_format(PG_FUNCTION_ARGS)
  			case 'I':
  			case 'L':
  				text_format_string_conversion(&str, *cp, &typoutputfinfo,
! 											  value, isNull);
  				break;
  			default:
  				ereport(ERROR,
--- 4413,4420 ----
  			case 'I':
  			case 'L':
  				text_format_string_conversion(&str, *cp, &typoutputfinfo,
! 											  value, isNull,
! 											  flags, use_width, width);
  				break;
  			default:
  				ereport(ERROR,
***************
*** 4244,4254 **** text_format(PG_FUNCTION_ARGS)
  	PG_RETURN_TEXT_P(result);
  }
  
  /* Format a %s, %I, or %L conversion. */
  static void
  text_format_string_conversion(StringInfo buf, char conversion,
  							  FmgrInfo *typOutputInfo,
! 							  Datum value, bool isNull)
  {
  	char	   *str;
  
--- 4437,4493 ----
  	PG_RETURN_TEXT_P(result);
  }
  
+ /*
+  * Add spaces on begin or on end when it is necessary
+  */
+ static void
+ text_format_append_string(StringInfo buf, const char *str,
+ 					  int flags, bool use_width, int width)
+ {
+ 	bool		align_to_left;
+ 	int		len;
+ 
+ 	/* fast path */
+ 	if (!use_width)
+ 	{
+ 		appendStringInfoString(buf, str);
+ 		return;
+ 	}
+ 
+ 	if (width < 0)
+ 	{
+ 		width = -width;
+ 		align_to_left = true;
+ 	}
+ 	else if (flags & TEXT_FORMAT_FLAG_MINUS)
+ 	{
+ 		align_to_left = true;
+ 	}
+ 	else
+ 		align_to_left = false;
+ 
+ 	len = pg_mbstrlen(str);
+ 	if (align_to_left)
+ 	{
+ 		appendStringInfoString(buf, str);
+ 		if (len < width)
+ 			appendStringInfoSpaces(buf, width - len);
+ 	}
+ 	else
+ 	{
+ 		/* align_to_right */
+ 		if (len < width)
+ 			appendStringInfoSpaces(buf, width - len);
+ 		appendStringInfoString(buf, str);
+ 	}
+ }
+ 
  /* Format a %s, %I, or %L conversion. */
  static void
  text_format_string_conversion(StringInfo buf, char conversion,
  							  FmgrInfo *typOutputInfo,
! 							  Datum value, bool isNull,
! 							  int flags, bool use_width, int width)
  {
  	char	   *str;
  
***************
*** 4256,4262 **** text_format_string_conversion(StringInfo buf, char conversion,
  	if (isNull)
  	{
  		if (conversion == 'L')
! 			appendStringInfoString(buf, "NULL");
  		else if (conversion == 'I')
  			ereport(ERROR,
  					(errcode(ERRCODE_NULL_VALUE_NOT_ALLOWED),
--- 4495,4502 ----
  	if (isNull)
  	{
  		if (conversion == 'L')
! 			text_format_append_string(buf, "NULL",
! 							flags, use_width, width);
  		else if (conversion == 'I')
  			ereport(ERROR,
  					(errcode(ERRCODE_NULL_VALUE_NOT_ALLOWED),
***************
*** 4271,4288 **** text_format_string_conversion(StringInfo buf, char conversion,
  	if (conversion == 'I')
  	{
  		/* quote_identifier may or may not allocate a new string. */
! 		appendStringInfoString(buf, quote_identifier(str));
  	}
  	else if (conversion == 'L')
! 	{
! 		char	   *qstr = quote_literal_cstr(str);
  
! 		appendStringInfoString(buf, qstr);
  		/* quote_literal_cstr() always allocates a new string */
  		pfree(qstr);
  	}
  	else
! 		appendStringInfoString(buf, str);
  
  	/* Cleanup. */
  	pfree(str);
--- 4511,4530 ----
  	if (conversion == 'I')
  	{
  		/* quote_identifier may or may not allocate a new string. */
! 		text_format_append_string(buf, quote_identifier(str),
! 							flags, use_width, width);
  	}
  	else if (conversion == 'L')
! 	{		char	   *qstr = quote_literal_cstr(str);
  
! 		text_format_append_string(buf, qstr,
! 							flags, use_width, width);
  		/* quote_literal_cstr() always allocates a new string */
  		pfree(qstr);
  	}
  	else
! 		text_format_append_string(buf, str,
! 							flags, use_width, width);
  
  	/* Cleanup. */
  	pfree(str);
*** a/src/test/regress/expected/text.out
--- b/src/test/regress/expected/text.out
***************
*** 257,267 **** ERROR:  too few arguments for format
  select format('%1$s %13$s', 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12);
  ERROR:  too few arguments for format
  select format('%1s', 1);
! ERROR:  unterminated conversion specifier
  select format('%1$', 1);
  ERROR:  unterminated conversion specifier
  select format('%1$1', 1);
! ERROR:  unrecognized conversion specifier "1"
  -- check mix of positional and ordered placeholders
  select format('Hello %s %1$s %s', 'World', 'Hello again');
              format             
--- 257,271 ----
  select format('%1$s %13$s', 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12);
  ERROR:  too few arguments for format
  select format('%1s', 1);
!  format 
! --------
!  1
! (1 row)
! 
  select format('%1$', 1);
  ERROR:  unterminated conversion specifier
  select format('%1$1', 1);
! ERROR:  unterminated conversion specifier
  -- check mix of positional and ordered placeholders
  select format('Hello %s %1$s %s', 'World', 'Hello again');
              format             
***************
*** 328,330 **** from generate_series(1,200) g(i);
--- 332,377 ----
   1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,160,161,162,163,164,165,166,167,168,169,170,171,172,173,174,175,176,177,178,179,180,181,182,183,184,185,186,187,188,189,190,191,192,193,194,195,196,197,198,199,200
  (1 row)
  
+ -- left, right align
+ select format('>>%10s<<', 'Hello')
+ union all
+ select format('>>%-10s<<', 'Hello')
+ union all
+ select format('>>%1$10s<<', 'Hello')
+ union all
+ select format('>>%1$-10I<<', 'Hello')
+ union all
+ select format('>>%2$*1$L<<', 10, 'Hello')
+ union all
+ select format('>>%*s<<', 10, 'Hello');
+      format     
+ ----------------
+  >>     Hello<<
+  >>Hello     <<
+  >>     Hello<<
+  >>"Hello"   <<
+  >>   'Hello'<<
+  >>     Hello<<
+ (6 rows)
+ 
+ select format('>>%*1$s<<', 10, 'Hello');
+      format     
+ ----------------
+  >>     Hello<<
+ (1 row)
+ 
+ select format('>>%-s<<', 'Hello');
+   format   
+ -----------
+  >>Hello<<
+ (1 row)
+ 
+ select format('>>%10L<<', NULL);
+      format     
+ ----------------
+  >>      NULL<<
+ (1 row)
+ 
+ -- should fail
+ select format('>>%2$*1$L<<', NULL, 'Hello');
+ ERROR:  width should not be NULL
*** a/src/test/regress/sql/text.sql
--- b/src/test/regress/sql/text.sql
***************
*** 97,99 **** select format('Hello', variadic NULL);
--- 97,119 ----
  -- variadic argument allows simulating more than FUNC_MAX_ARGS parameters
  select format(string_agg('%s',','), variadic array_agg(i))
  from generate_series(1,200) g(i);
+ 
+ -- left, right align
+ select format('>>%10s<<', 'Hello')
+ union all
+ select format('>>%-10s<<', 'Hello')
+ union all
+ select format('>>%1$10s<<', 'Hello')
+ union all
+ select format('>>%1$-10I<<', 'Hello')
+ union all
+ select format('>>%2$*1$L<<', 10, 'Hello')
+ union all
+ select format('>>%*s<<', 10, 'Hello');
+ 
+ select format('>>%*1$s<<', 10, 'Hello');
+ select format('>>%-s<<', 'Hello');
+ select format('>>%10L<<', NULL);
+ 
+ -- should fail
+ select format('>>%2$*1$L<<', NULL, 'Hello');

diff --git a/doc/src/sgml/func.sgml b/doc/src/sgml/func.sgml
new file mode 100644
index 3879186..737d677
*** a/doc/src/sgml/func.sgml
--- b/doc/src/sgml/func.sgml
***************
*** 1524,1539 ****
         <entry><type>text</type></entry>
         <entry>
           Format arguments according to a format string.
!          This function is similar to the C function
!          <function>sprintf</>, but only the following conversion specifications
!          are recognized: <literal>%s</literal> interpolates the corresponding
!          argument as a string; <literal>%I</literal> escapes its argument as
!          an SQL identifier; <literal>%L</literal> escapes its argument as an
!          SQL literal; <literal>%%</literal> outputs a literal <literal>%</>.
!          A conversion can reference an explicit parameter position by preceding
!          the conversion specifier with <literal><replaceable>n</>$</>, where
!          <replaceable>n</replaceable> is the argument position.
!          See also <xref linkend="plpgsql-quote-literal-example">.
         </entry>
         <entry><literal>format('Hello %s, %1$s', 'World')</literal></entry>
         <entry><literal>Hello World, World</literal></entry>
--- 1524,1531 ----
         <entry><type>text</type></entry>
         <entry>
           Format arguments according to a format string.
!          This function is similar to the C function <function>sprintf</>.
!          See <xref linkend="functions-string-format">.
         </entry>
         <entry><literal>format('Hello %s, %1$s', 'World')</literal></entry>
         <entry><literal>Hello World, World</literal></entry>
***************
*** 2847,2852 ****
--- 2839,3024 ----
      </tgroup>
     </table>
  
+    <sect2 id="functions-string-format">
+     <title><function>format</function></title>
+ 
+     <indexterm>
+      <primary>format</primary>
+     </indexterm>
+ 
+     <para>
+      The function <function>format</> produces formatted output according to
+      a format string in a similar way to the C function <function>sprintf</>.
+     </para>
+ 
+     <para>
+ <synopsis>
+ format(<parameter>formatstr</> <type>text</> [, <parameter>str</> <type>"any"</> [, ...] ])
+ </synopsis>
+      <replaceable>formatstr</> is a format string that specifies how the
+      result should be formatted.  Text in the format string is copied directly
+      to the result, except where <firstterm>format specifiers</> are used.
+      Format specifiers act as placeholders in the string, allowing subsequent
+      function arguments to be formatted and inserted into the result.
+     </para>
+ 
+     <para>
+      Format specifiers are introduced by a <literal>%</> character and take
+      the form
+ <synopsis>
+ %[<replaceable>parameter</>][<replaceable>flags</>][<replaceable>width</>]<replaceable>type</>
+ </synopsis>
+      <variablelist>
+       <varlistentry>
+        <term><replaceable>parameter</replaceable> (optional)</term>
+        <listitem>
+         <para>
+          An expression of the form <literal><replaceable>n</>$</> where
+          <replaceable>n</> is the index of the argument to use for the format
+          specifier's value.  An index of 1 means the first argument after
+          <replaceable>formatstr</>.  If the <replaceable>parameter</> field is
+          omitted, the default is to use the next argument.
+         </para>
+ <screen>
+ SELECT format('Testing %s, %s, %s', 'one', 'two', 'three');
+ <lineannotation>Result: </><computeroutput>Testing one, two, three</>
+ 
+ SELECT format('Testing %3$s, %2$s, %1$s', 'one', 'two', 'three');
+ <lineannotation>Result: </><computeroutput>Testing three, two, one</>
+ </screen>
+ 
+         <para>
+          Note that unlike the C function <function>sprintf</> defined in the
+          Single UNIX Specification, the <function>format</> function in
+          <productname>PostgreSQL</> allows format specifiers with and without
+          explicit <replaceable>parameter</> fields to be mixed in the same
+          format string.  A format specifier without a
+          <replaceable>parameter</> field always uses the next argument after
+          the last argument consumed.  In addition, the
+          <productname>PostgreSQL</> <function>format</> function does not
+          require all function arguments to be referred to in the format
+          string.
+         </para>
+ <screen>
+ SELECT format('Testing %3$s, %2$s, %s', 'one', 'two', 'three');
+ <lineannotation>Result: </><computeroutput>Testing three, two, three</>
+ </screen>
+        </listitem>
+       </varlistentry>
+ 
+       <varlistentry>
+        <term><replaceable>flags</replaceable> (optional)</term>
+        <listitem>
+         <para>
+          Additional options controlling how the format specifier's output is
+          formatted.  Currently the only supported flag is an minus sign
+          (<literal>-</>) which will cause the format specifier's output to be
+          left-aligned.  This has no effect unless the <replaceable>width</>
+          field is also specified.
+         </para>
+ <screen>
+ SELECT format('|%10s|%-10s|', 'foo', 'bar');
+ <lineannotation>Result: </><computeroutput>|       foo|bar       |</>
+ </screen>
+        </listitem>
+       </varlistentry>
+ 
+       <varlistentry>
+        <term><replaceable>width</replaceable> (optional)</term>
+        <listitem>
+         <para>
+          Specifies the <emphasis>minimum</> number of characters to use to
+          display the format specifier's output.  The width may be specified
+          using any of the following: a positive integer; an asterisk
+          (<literal>*</>) to use the next function argument as the width; or an
+          expression of the form <literal>*<replaceable>n</>$</> to use the
+          <replaceable>n</>th function argument as the width.
+         </para>
+ 
+         <para>
+          If the width comes from a function argument, that argument is
+          consumed <emphasis>before</> the argument that is used for the format
+          specifier's value.  If the width argument is negative, the result is
+          left aligned, as if the <literal>-</> flag had been specified.
+         </para>
+ <screen>
+ SELECT format('|%10s|', 'foo');
+ <lineannotation>Result: </><computeroutput>|       foo|</>
+ 
+ SELECT format('|%*s|', 10, 'foo');
+ <lineannotation>Result: </><computeroutput>|       foo|</>
+ 
+ SELECT format('|%*s|', -10, 'foo');
+ <lineannotation>Result: </><computeroutput>|foo       |</>
+ 
+ SELECT format('|%-*s|', 10, 'foo');
+ <lineannotation>Result: </><computeroutput>|foo       |</>
+ 
+ SELECT format('|%-*s|', -10, 'foo');
+ <lineannotation>Result: </><computeroutput>|foo       |</>
+ 
+ SELECT format('|%*2$s|', 'foo', 10, 'bar');
+ <lineannotation>Result: </><computeroutput>|       bar|</>
+ 
+ SELECT format('|%3$*2$s|', 'foo', 10, 'bar');
+ <lineannotation>Result: </><computeroutput>|       bar|</>
+ </screen>
+        </listitem>
+       </varlistentry>
+ 
+       <varlistentry>
+        <term><replaceable>type</replaceable> (required)</term>
+        <listitem>
+         <para>
+          The type of format conversion to use to produce the format
+          specifier's output.  The following types are supported:
+          <itemizedlist>
+           <listitem>
+            <para>
+             <literal>s</literal> formats the argument value as a simple
+             string.  A null value is treated as an empty string.
+            </para>
+           </listitem>
+           <listitem>
+            <para>
+             <literal>I</literal> escapes the value as an SQL identifier.  It
+             is an error for the value to be null.
+            </para>
+           </listitem>
+           <listitem>
+            <para>
+             <literal>L</literal> escapes the value as an SQL literal.  A null
+             value is displayed as the literal value <literal>NULL</>.
+            </para>
+           </listitem>
+          </itemizedlist>
+         </para>
+ <screen>
+ SELECT format('Hello %s', 'World');
+ <lineannotation>Result: </lineannotation><computeroutput>Hello World</computeroutput>
+ 
+ SELECT format('DROP TABLE %I', 'Foo bar');
+ <lineannotation>Result: </lineannotation><computeroutput>DROP TABLE "Foo bar"</computeroutput>
+ 
+ SELECT format('SELECT %L', E'O\'Reilly');
+ <lineannotation>Result: </lineannotation><computeroutput>SELECT 'O''Reilly'</computeroutput>
+ </screen>
+ 
+         <para>
+          The <literal>%I</> and <literal>%L</> format specifiers may be used
+          to safely construct dynamic SQL statements.  See
+          <xref linkend="plpgsql-quote-literal-example">.
+         </para>
+        </listitem>
+       </varlistentry>
+      </variablelist>
+     </para>
+ 
+     <para>
+      In addition to the format specifiers above, the special escape sequence
+      <literal>%%</> may be used to output a literal <literal>%</> character.
+     </para>
+    </sect2>
    </sect1>
  
  

diff --git a/doc/src/sgml/func.sgml b/doc/src/sgml/func.sgml
new file mode 100644
index 3879186..240a6e7
*** a/doc/src/sgml/func.sgml
--- b/doc/src/sgml/func.sgml
***************
*** 1519,1539 ****
           <primary>format</primary>
          </indexterm>
          <literal><function>format</function>(<parameter>formatstr</parameter> <type>text</type>
!         [, <parameter>str</parameter> <type>"any"</type> [, ...] ])</literal>
         </entry>
         <entry><type>text</type></entry>
         <entry>
           Format arguments according to a format string.
!          This function is similar to the C function
!          <function>sprintf</>, but only the following conversion specifications
!          are recognized: <literal>%s</literal> interpolates the corresponding
!          argument as a string; <literal>%I</literal> escapes its argument as
!          an SQL identifier; <literal>%L</literal> escapes its argument as an
!          SQL literal; <literal>%%</literal> outputs a literal <literal>%</>.
!          A conversion can reference an explicit parameter position by preceding
!          the conversion specifier with <literal><replaceable>n</>$</>, where
!          <replaceable>n</replaceable> is the argument position.
!          See also <xref linkend="plpgsql-quote-literal-example">.
         </entry>
         <entry><literal>format('Hello %s, %1$s', 'World')</literal></entry>
         <entry><literal>Hello World, World</literal></entry>
--- 1519,1531 ----
           <primary>format</primary>
          </indexterm>
          <literal><function>format</function>(<parameter>formatstr</parameter> <type>text</type>
!         [, <parameter>formatarg</parameter> <type>"any"</type> [, ...] ])</literal>
         </entry>
         <entry><type>text</type></entry>
         <entry>
           Format arguments according to a format string.
!          This function is similar to the C function <function>sprintf</>.
!          See <xref linkend="functions-string-format">.
         </entry>
         <entry><literal>format('Hello %s, %1$s', 'World')</literal></entry>
         <entry><literal>Hello World, World</literal></entry>
***************
*** 2847,2852 ****
--- 2839,3024 ----
      </tgroup>
     </table>
  
+    <sect2 id="functions-string-format">
+     <title><function>format</function></title>
+ 
+     <indexterm>
+      <primary>format</primary>
+     </indexterm>
+ 
+     <para>
+      The function <function>format</> produces formatted output according to
+      a format string in a similar way to the C function <function>sprintf</>.
+     </para>
+ 
+     <para>
+ <synopsis>
+ format(<parameter>formatstr</> <type>text</> [, <parameter>formatarg</> <type>"any"</> [, ...] ])
+ </synopsis>
+      <replaceable>formatstr</> is a format string that specifies how the
+      result should be formatted.  Text in the format string is copied directly
+      to the result, except where <firstterm>format specifiers</> are used.
+      Format specifiers act as placeholders in the string, allowing subsequent
+      function arguments to be formatted and inserted into the result.
+     </para>
+ 
+     <para>
+      Format specifiers are introduced by a <literal>%</> character and take
+      the form
+ <synopsis>
+ %[<replaceable>parameter</>][<replaceable>flags</>][<replaceable>width</>]<replaceable>type</>
+ </synopsis>
+      <variablelist>
+       <varlistentry>
+        <term><replaceable>parameter</replaceable> (optional)</term>
+        <listitem>
+         <para>
+          An expression of the form <literal><replaceable>n</>$</> where
+          <replaceable>n</> is the index of the argument to use for the format
+          specifier's value.  An index of 1 means the first argument after
+          <replaceable>formatstr</>.  If the <replaceable>parameter</> field is
+          omitted, the default is to use the next argument.
+         </para>
+ <screen>
+ SELECT format('Testing %s, %s, %s', 'one', 'two', 'three');
+ <lineannotation>Result: </><computeroutput>Testing one, two, three</>
+ 
+ SELECT format('Testing %3$s, %2$s, %1$s', 'one', 'two', 'three');
+ <lineannotation>Result: </><computeroutput>Testing three, two, one</>
+ </screen>
+ 
+         <para>
+          Note that unlike the C function <function>sprintf</> defined in the
+          Single UNIX Specification, the <function>format</> function in
+          <productname>PostgreSQL</> allows format specifiers with and without
+          explicit <replaceable>parameter</> fields to be mixed in the same
+          format string.  A format specifier without a
+          <replaceable>parameter</> field always uses the next argument after
+          the last argument consumed.  In addition, the
+          <productname>PostgreSQL</> <function>format</> function does not
+          require all function arguments to be referred to in the format
+          string.
+         </para>
+ <screen>
+ SELECT format('Testing %3$s, %2$s, %s', 'one', 'two', 'three');
+ <lineannotation>Result: </><computeroutput>Testing three, two, three</>
+ </screen>
+        </listitem>
+       </varlistentry>
+ 
+       <varlistentry>
+        <term><replaceable>flags</replaceable> (optional)</term>
+        <listitem>
+         <para>
+          Additional options controlling how the format specifier's output is
+          formatted.  Currently the only supported flag is an minus sign
+          (<literal>-</>) which will cause the format specifier's output to be
+          left-aligned.  This has no effect unless the <replaceable>width</>
+          field is also specified.
+         </para>
+ <screen>
+ SELECT format('|%10s|%-10s|', 'foo', 'bar');
+ <lineannotation>Result: </><computeroutput>|       foo|bar       |</>
+ </screen>
+        </listitem>
+       </varlistentry>
+ 
+       <varlistentry>
+        <term><replaceable>width</replaceable> (optional)</term>
+        <listitem>
+         <para>
+          Specifies the <emphasis>minimum</> number of characters to use to
+          display the format specifier's output.  The width may be specified
+          using any of the following: a positive integer; an asterisk
+          (<literal>*</>) to use the next function argument as the width; or an
+          expression of the form <literal>*<replaceable>n</>$</> to use the
+          <replaceable>n</>th function argument as the width.
+         </para>
+ 
+         <para>
+          If the width comes from a function argument, that argument is
+          consumed <emphasis>before</> the argument that is used for the format
+          specifier's value.  If the width argument is negative, the result is
+          left aligned, as if the <literal>-</> flag had been specified.
+         </para>
+ <screen>
+ SELECT format('|%10s|', 'foo');
+ <lineannotation>Result: </><computeroutput>|       foo|</>
+ 
+ SELECT format('|%*s|', 10, 'foo');
+ <lineannotation>Result: </><computeroutput>|       foo|</>
+ 
+ SELECT format('|%*s|', -10, 'foo');
+ <lineannotation>Result: </><computeroutput>|foo       |</>
+ 
+ SELECT format('|%-*s|', 10, 'foo');
+ <lineannotation>Result: </><computeroutput>|foo       |</>
+ 
+ SELECT format('|%-*s|', -10, 'foo');
+ <lineannotation>Result: </><computeroutput>|foo       |</>
+ 
+ SELECT format('|%*2$s|', 'foo', 10, 'bar');
+ <lineannotation>Result: </><computeroutput>|       bar|</>
+ 
+ SELECT format('|%3$*2$s|', 'foo', 10, 'bar');
+ <lineannotation>Result: </><computeroutput>|       bar|</>
+ </screen>
+        </listitem>
+       </varlistentry>
+ 
+       <varlistentry>
+        <term><replaceable>type</replaceable> (required)</term>
+        <listitem>
+         <para>
+          The type of format conversion to use to produce the format
+          specifier's output.  The following types are supported:
+          <itemizedlist>
+           <listitem>
+            <para>
+             <literal>s</literal> formats the argument value as a simple
+             string.  A null value is treated as an empty string.
+            </para>
+           </listitem>
+           <listitem>
+            <para>
+             <literal>I</literal> escapes the value as an SQL identifier.  It
+             is an error for the value to be null.
+            </para>
+           </listitem>
+           <listitem>
+            <para>
+             <literal>L</literal> escapes the value as an SQL literal.  A null
+             value is displayed as the literal value <literal>NULL</>.
+            </para>
+           </listitem>
+          </itemizedlist>
+         </para>
+ <screen>
+ SELECT format('Hello %s', 'World');
+ <lineannotation>Result: </lineannotation><computeroutput>Hello World</computeroutput>
+ 
+ SELECT format('DROP TABLE %I', 'Foo bar');
+ <lineannotation>Result: </lineannotation><computeroutput>DROP TABLE "Foo bar"</computeroutput>
+ 
+ SELECT format('SELECT %L', E'O\'Reilly');
+ <lineannotation>Result: </lineannotation><computeroutput>SELECT 'O''Reilly'</computeroutput>
+ </screen>
+ 
+         <para>
+          The <literal>%I</> and <literal>%L</> format specifiers may be used
+          to safely construct dynamic SQL statements.  See
+          <xref linkend="plpgsql-quote-literal-example">.
+         </para>
+        </listitem>
+       </varlistentry>
+      </variablelist>
+     </para>
+ 
+     <para>
+      In addition to the format specifiers above, the special escape sequence
+      <literal>%%</> may be used to output a literal <literal>%</> character.
+     </para>
+    </sect2>
    </sect1>
  
  

*** a/doc/src/sgml/func.sgml
--- b/doc/src/sgml/func.sgml
***************
*** 1519,1539 ****
           <primary>format</primary>
          </indexterm>
          <literal><function>format</function>(<parameter>formatstr</parameter> <type>text</type>
!         [, <parameter>str</parameter> <type>"any"</type> [, ...] ])</literal>
         </entry>
         <entry><type>text</type></entry>
         <entry>
           Format arguments according to a format string.
!          This function is similar to the C function
!          <function>sprintf</>, but only the following conversion specifications
!          are recognized: <literal>%s</literal> interpolates the corresponding
!          argument as a string; <literal>%I</literal> escapes its argument as
!          an SQL identifier; <literal>%L</literal> escapes its argument as an
!          SQL literal; <literal>%%</literal> outputs a literal <literal>%</>.
!          A conversion can reference an explicit parameter position by preceding
!          the conversion specifier with <literal><replaceable>n</>$</>, where
!          <replaceable>n</replaceable> is the argument position.
!          See also <xref linkend="plpgsql-quote-literal-example">.
         </entry>
         <entry><literal>format('Hello %s, %1$s', 'World')</literal></entry>
         <entry><literal>Hello World, World</literal></entry>
--- 1519,1531 ----
           <primary>format</primary>
          </indexterm>
          <literal><function>format</function>(<parameter>formatstr</parameter> <type>text</type>
!         [, <parameter>formatarg</parameter> <type>"any"</type> [, ...] ])</literal>
         </entry>
         <entry><type>text</type></entry>
         <entry>
           Format arguments according to a format string.
!          This function is similar to the C function <function>sprintf</>.
!          See <xref linkend="functions-string-format">.
         </entry>
         <entry><literal>format('Hello %s, %1$s', 'World')</literal></entry>
         <entry><literal>Hello World, World</literal></entry>
***************
*** 2847,2852 ****
--- 2839,3024 ----
      </tgroup>
     </table>
  
+    <sect2 id="functions-string-format">
+     <title><function>format</function></title>
+ 
+     <indexterm>
+      <primary>format</primary>
+     </indexterm>
+ 
+     <para>
+      The function <function>format</> produces formatted output according to
+      a format string in a similar way to the C function <function>sprintf</>.
+     </para>
+ 
+     <para>
+ <synopsis>
+ format(<parameter>formatstr</> <type>text</> [, <parameter>formatarg</> <type>"any"</> [, ...] ])
+ </synopsis>
+      <replaceable>formatstr</> is a format string that specifies how the
+      result should be formatted.  Text in the format string is copied directly
+      to the result, except where <firstterm>format specifiers</> are used.
+      Format specifiers act as placeholders in the string, allowing subsequent
+      function arguments to be formatted and inserted into the result.
+     </para>
+ 
+     <para>
+      Format specifiers are introduced by a <literal>%</> character and take
+      the form
+ <synopsis>
+ %[<replaceable>parameter</>][<replaceable>flags</>][<replaceable>width</>]<replaceable>type</>
+ </synopsis>
+      <variablelist>
+       <varlistentry>
+        <term><replaceable>parameter</replaceable> (optional)</term>
+        <listitem>
+         <para>
+          An expression of the form <literal><replaceable>n</>$</> where
+          <replaceable>n</> is the index of the argument to use for the format
+          specifier's value.  An index of 1 means the first argument after
+          <replaceable>formatstr</>.  If the <replaceable>parameter</> field is
+          omitted, the default is to use the next argument.
+         </para>
+ <screen>
+ SELECT format('Testing %s, %s, %s', 'one', 'two', 'three');
+ <lineannotation>Result: </><computeroutput>Testing one, two, three</>
+ 
+ SELECT format('Testing %3$s, %2$s, %1$s', 'one', 'two', 'three');
+ <lineannotation>Result: </><computeroutput>Testing three, two, one</>
+ </screen>
+ 
+         <para>
+          Note that unlike the C function <function>sprintf</> defined in the
+          Single UNIX Specification, the <function>format</> function in
+          <productname>PostgreSQL</> allows format specifiers with and without
+          explicit <replaceable>parameter</> fields to be mixed in the same
+          format string.  A format specifier without a
+          <replaceable>parameter</> field always uses the next argument after
+          the last argument consumed.  In addition, the
+          <productname>PostgreSQL</> <function>format</> function does not
+          require all function arguments to be referred to in the format
+          string.
+         </para>
+ <screen>
+ SELECT format('Testing %3$s, %2$s, %s', 'one', 'two', 'three');
+ <lineannotation>Result: </><computeroutput>Testing three, two, three</>
+ </screen>
+        </listitem>
+       </varlistentry>
+ 
+       <varlistentry>
+        <term><replaceable>flags</replaceable> (optional)</term>
+        <listitem>
+         <para>
+          Additional options controlling how the format specifier's output is
+          formatted.  Currently the only supported flag is an minus sign
+          (<literal>-</>) which will cause the format specifier's output to be
+          left-aligned.  This has no effect unless the <replaceable>width</>
+          field is also specified.
+         </para>
+ <screen>
+ SELECT format('|%10s|%-10s|', 'foo', 'bar');
+ <lineannotation>Result: </><computeroutput>|       foo|bar       |</>
+ </screen>
+        </listitem>
+       </varlistentry>
+ 
+       <varlistentry>
+        <term><replaceable>width</replaceable> (optional)</term>
+        <listitem>
+         <para>
+          Specifies the <emphasis>minimum</> number of characters to use to
+          display the format specifier's output.  The width may be specified
+          using any of the following: a positive integer; an asterisk
+          (<literal>*</>) to use the next function argument as the width; or an
+          expression of the form <literal>*<replaceable>n</>$</> to use the
+          <replaceable>n</>th function argument as the width.
+         </para>
+ 
+         <para>
+          If the width comes from a function argument, that argument is
+          consumed <emphasis>before</> the argument that is used for the format
+          specifier's value.  If the width argument is negative, the result is
+          left aligned, as if the <literal>-</> flag had been specified.
+         </para>
+ <screen>
+ SELECT format('|%10s|', 'foo');
+ <lineannotation>Result: </><computeroutput>|       foo|</>
+ 
+ SELECT format('|%*s|', 10, 'foo');
+ <lineannotation>Result: </><computeroutput>|       foo|</>
+ 
+ SELECT format('|%*s|', -10, 'foo');
+ <lineannotation>Result: </><computeroutput>|foo       |</>
+ 
+ SELECT format('|%-*s|', 10, 'foo');
+ <lineannotation>Result: </><computeroutput>|foo       |</>
+ 
+ SELECT format('|%-*s|', -10, 'foo');
+ <lineannotation>Result: </><computeroutput>|foo       |</>
+ 
+ SELECT format('|%*2$s|', 'foo', 10, 'bar');
+ <lineannotation>Result: </><computeroutput>|       bar|</>
+ 
+ SELECT format('|%3$*2$s|', 'foo', 10, 'bar');
+ <lineannotation>Result: </><computeroutput>|       bar|</>
+ </screen>
+        </listitem>
+       </varlistentry>
+ 
+       <varlistentry>
+        <term><replaceable>type</replaceable> (required)</term>
+        <listitem>
+         <para>
+          The type of format conversion to use to produce the format
+          specifier's output.  The following types are supported:
+          <itemizedlist>
+           <listitem>
+            <para>
+             <literal>s</literal> formats the argument value as a simple
+             string.  A null value is treated as an empty string.
+            </para>
+           </listitem>
+           <listitem>
+            <para>
+             <literal>I</literal> escapes the value as an SQL identifier.  It
+             is an error for the value to be null.
+            </para>
+           </listitem>
+           <listitem>
+            <para>
+             <literal>L</literal> escapes the value as an SQL literal.  A null
+             value is displayed as the literal value <literal>NULL</>.
+            </para>
+           </listitem>
+          </itemizedlist>
+         </para>
+ <screen>
+ SELECT format('Hello %s', 'World');
+ <lineannotation>Result: </lineannotation><computeroutput>Hello World</computeroutput>
+ 
+ SELECT format('DROP TABLE %I', 'Foo bar');
+ <lineannotation>Result: </lineannotation><computeroutput>DROP TABLE "Foo bar"</computeroutput>
+ 
+ SELECT format('SELECT %L', E'O\'Reilly');
+ <lineannotation>Result: </lineannotation><computeroutput>SELECT 'O''Reilly'</computeroutput>
+ </screen>
+ 
+         <para>
+          The <literal>%I</> and <literal>%L</> format specifiers may be used
+          to safely construct dynamic SQL statements.  See
+          <xref linkend="plpgsql-quote-literal-example">.
+         </para>
+        </listitem>
+       </varlistentry>
+      </variablelist>
+     </para>
+ 
+     <para>
+      In addition to the format specifiers above, the special escape sequence
+      <literal>%%</> may be used to output a literal <literal>%</> character.
+     </para>
+    </sect2>
    </sect1>
  
  
*** a/src/backend/utils/adt/varlena.c
--- b/src/backend/utils/adt/varlena.c
***************
*** 78,84 **** static bytea *bytea_overlay(bytea *t1, bytea *t2, int sp, int sl);
  static StringInfo makeStringAggState(FunctionCallInfo fcinfo);
  static void text_format_string_conversion(StringInfo buf, char conversion,
  							  FmgrInfo *typOutputInfo,
! 							  Datum value, bool isNull);
  static Datum text_to_array_internal(PG_FUNCTION_ARGS);
  static text *array_to_text_internal(FunctionCallInfo fcinfo, ArrayType *v,
  					   const char *fldsep, const char *null_string);
--- 78,85 ----
  static StringInfo makeStringAggState(FunctionCallInfo fcinfo);
  static void text_format_string_conversion(StringInfo buf, char conversion,
  							  FmgrInfo *typOutputInfo,
! 							  Datum value, bool isNull,
! 							  int flags, bool use_width, int width);
  static Datum text_to_array_internal(PG_FUNCTION_ARGS);
  static text *array_to_text_internal(FunctionCallInfo fcinfo, ArrayType *v,
  					   const char *fldsep, const char *null_string);
***************
*** 3997,4002 **** text_reverse(PG_FUNCTION_ARGS)
--- 3998,4134 ----
  }
  
  /*
+  * Returns pointer of first non digit char
+  *
+  * When some digits are processed, then inum returns parsed number
+  * and is_valid is true, otherwise is_valid is false.
+  */
+ static const char *
+ text_format_parse_digits(const char *start_ptr, const char *end_ptr,
+ 				int	*inum,					/* OUT param */
+ 				bool	*is_valid)				/* OUT param */
+ {
+ 	const char *cp = start_ptr;
+ 
+ 	*is_valid = false;
+ 	*inum = 0;
+ 
+ 	/* continue, only when start_ptr is less than end_ptr */
+ 	while (cp < end_ptr)
+ 	{
+ 		if (*cp >= '0' && *cp <= '9')
+ 		{
+ 			int	newnum = *inum * 10 + (*cp - '0');
+ 
+ 			if (newnum / 10 != *inum) /* overflow? */
+ 				ereport(ERROR,
+ 						(errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
+ 						 errmsg("number is out of range")));
+ 			*inum = newnum;
+ 			*is_valid = true;
+ 			++cp;
+ 		}
+ 		else
+ 			break;
+ 	}
+ 
+ 	/* should not be after last char of format string */
+ 	if (cp >= end_ptr)
+ 		ereport(ERROR,
+ 				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+ 				 errmsg("unterminated conversion specifier")));
+ 
+ 	return cp;
+ }
+ 
+ #define TEXT_FORMAT_FLAG_MINUS	0x0001			/* is minus in format string? */
+ 
+ #define TEXT_FORMAT_NEXT_CHAR(ptr, end_ptr) \
+ do { \
+ 	if (++(ptr) >= (end_ptr)) \
+ 		ereport(ERROR, \
+ 				(errcode(ERRCODE_INVALID_PARAMETER_VALUE), \
+ 				 errmsg("unterminated conversion specifier"))); \
+ } while (0)
+ 
+ /*
+  * parse format specification
+  *             [parameter][flags][width]type
+  *
+  * -1 in int OUT parameters signalize so this attribut is missing,
+  * all values should be zero or greather than zero. Raise exeption
+  * when some parameter is out of range.
+  */
+ static const char *
+ text_format_parse_format(const char *start_ptr, const char *end_ptr,
+ 				int *parameter,						/* OUT param */
+ 				int *flags,						/* OUT param */
+ 				int *width,						/* OUT param */
+ 				bool *indirect_width,					/* OUT param */
+ 				int *indirect_width_parameter)				/* OUT param */
+ {
+ 	int	   inum;
+ 	bool	   is_valid;
+ 
+ 	/* set defaults to out parameters */
+ 	*parameter = -1;
+ 	*flags = 0;
+ 	*width = -1;
+ 	*indirect_width = false;
+ 	*indirect_width_parameter = -1;
+ 
+ 	/* try to identify first number */
+ 	start_ptr = text_format_parse_digits(start_ptr, end_ptr, &inum, &is_valid);
+ 	if (is_valid)
+ 	{
+ 		/* number on this position can be parameter number or the width */
+ 		if (*start_ptr != '$')
+ 		{
+ 			*width = inum;
+ 			return start_ptr;
+ 		}
+ 
+ 		*parameter = inum;
+ 		TEXT_FORMAT_NEXT_CHAR(start_ptr, end_ptr);
+ 	}
+ 
+ 	/* try to parse flags, only minus is supported now */
+ 	if (*start_ptr == '-')
+ 	{
+ 		*flags = *flags | TEXT_FORMAT_FLAG_MINUS;
+ 		TEXT_FORMAT_NEXT_CHAR(start_ptr, end_ptr);
+ 	}
+ 
+ 	/* try to parse indirect width */
+ 	if (*start_ptr == '*')
+ 	{
+ 		start_ptr = text_format_parse_digits(++start_ptr, end_ptr, &inum, &is_valid);
+ 		if (is_valid)
+ 		{
+ 			/* number in this position should be closed by $ */
+ 			if (*start_ptr != '$')
+ 				ereport(ERROR,
+ 						(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+ 						 errmsg("unexpected char \"%c\"", *start_ptr)));
+ 			TEXT_FORMAT_NEXT_CHAR(start_ptr, end_ptr);
+ 
+ 			*indirect_width_parameter = inum;
+ 		}
+ 		else
+ 			*indirect_width = true;
+ 
+ 		return start_ptr;
+ 	}
+ 
+ 	/* last possible nummber - width */
+ 	start_ptr = text_format_parse_digits(start_ptr, end_ptr, &inum, &is_valid);
+ 	if (is_valid)
+ 		*width = inum;
+ 
+ 	return start_ptr;
+ }
+ 
+ /*
   * Returns a formated string
   */
  Datum
***************
*** 4016,4021 **** text_format(PG_FUNCTION_ARGS)
--- 4148,4155 ----
  	Oid			element_type = InvalidOid;
  	Oid			prev_type = InvalidOid;
  	FmgrInfo	typoutputfinfo;
+ 	FmgrInfo		typoutputinfo_width;
+ 	Oid			prev_type_width = InvalidOid;
  
  	/* When format string is null, returns null */
  	if (PG_ARGISNULL(0))
***************
*** 4088,4093 **** text_format(PG_FUNCTION_ARGS)
--- 4222,4233 ----
  		Datum		value;
  		bool		isNull;
  		Oid			typid;
+ 		int parameter;
+ 		int flags;
+ 		int width;
+ 		bool indirect_width;
+ 		int indirect_width_parameter;
+ 		bool		use_width;
  
  		/*
  		 * If it's not the start of a conversion specifier, just copy it to
***************
*** 4099,4109 **** text_format(PG_FUNCTION_ARGS)
  			continue;
  		}
  
! 		/* Did we run off the end of the string? */
! 		if (++cp >= end_ptr)
! 			ereport(ERROR,
! 					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
! 					 errmsg("unterminated conversion specifier")));
  
  		/* Easy case: %% outputs a single % */
  		if (*cp == '%')
--- 4239,4246 ----
  			continue;
  		}
  
! 		/* go to next char */
! 		TEXT_FORMAT_NEXT_CHAR(cp, end_ptr);
  
  		/* Easy case: %% outputs a single % */
  		if (*cp == '%')
***************
*** 4112,4125 **** text_format(PG_FUNCTION_ARGS)
  			continue;
  		}
  
! 		/*
! 		 * If the user hasn't specified an argument position, we just advance
! 		 * to the next one.  If they have, we must parse it.
! 		 */
! 		if (*cp < '0' || *cp > '9')
  		{
! 			++arg;
! 			if (arg <= 0)		/* overflow? */
  			{
  				/*
  				 * Should not happen, as you can't pass billions of arguments
--- 4249,4264 ----
  			continue;
  		}
  
! 		cp = text_format_parse_format(cp, end_ptr,
! 								&parameter,
! 								&flags,
! 								&width,
! 								&indirect_width,
! 								&indirect_width_parameter);
! 
! 		if (indirect_width)
  		{
! 			if (++arg <= 0)		/* overflow? */
  			{
  				/*
  				 * Should not happen, as you can't pass billions of arguments
***************
*** 4129,4177 **** text_format(PG_FUNCTION_ARGS)
  						(errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
  						 errmsg("argument number is out of range")));
  			}
  		}
! 		else
  		{
! 			bool		unterminated = false;
! 
! 			/* Parse digit string. */
! 			arg = 0;
! 			do
! 			{
! 				int			newarg = arg * 10 + (*cp - '0');
! 
! 				if (newarg / 10 != arg) /* overflow? */
! 					ereport(ERROR,
! 							(errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
! 							 errmsg("argument number is out of range")));
! 				arg = newarg;
! 				++cp;
! 			} while (cp < end_ptr && *cp >= '0' && *cp <= '9');
  
! 			/*
! 			 * If we ran off the end, or if there's not a $ next, or if the $
! 			 * is the last character, the conversion specifier is improperly
! 			 * terminated.
! 			 */
! 			if (cp == end_ptr || *cp != '$')
! 				unterminated = true;
! 			else
  			{
! 				++cp;
! 				if (cp == end_ptr)
! 					unterminated = true;
! 			}
! 			if (unterminated)
! 				ereport(ERROR,
! 						(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
! 						 errmsg("unterminated conversion specifier")));
! 
! 			/* There's no argument 0. */
! 			if (arg == 0)
  				ereport(ERROR,
! 						(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
! 						 errmsg("conversion specifies argument 0, but arguments are numbered from 1")));
  		}
  
  		/* Not enough arguments?  Deduct 1 to avoid counting format string. */
  		if (arg > nargs - 1)
--- 4268,4301 ----
  						(errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
  						 errmsg("argument number is out of range")));
  			}
+ 			indirect_width_parameter = arg;
  		}
! 		else if (indirect_width_parameter != -1)
  		{
! 			/* be consistent, move ordered argument together with positional */
! 			arg = indirect_width_parameter;
! 		}
  
! 		if (parameter == -1)
! 		{
! 			if (++arg <= 0)		/* overflow? */
  			{
! 				/*
! 				 * Should not happen, as you can't pass billions of arguments
! 				 * to a function, but better safe than sorry.
! 				 */
  				ereport(ERROR,
! 						(errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
! 						 errmsg("argument number is out of range")));
! 			}
  		}
+ 		else
+ 			arg = parameter;
+ 
+ 		if (arg == 0)
+ 			ereport(ERROR,
+ 					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+ 					 errmsg("conversion specifies argument 0, but arguments are numbered from 1")));
  
  		/* Not enough arguments?  Deduct 1 to avoid counting format string. */
  		if (arg > nargs - 1)
***************
*** 4179,4184 **** text_format(PG_FUNCTION_ARGS)
--- 4303,4380 ----
  					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
  					 errmsg("too few arguments for format")));
  
+ 		if (indirect_width_parameter != -1)
+ 		{
+ 
+ 			if (indirect_width_parameter == 0)
+ 				ereport(ERROR,
+ 						(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+ 						 errmsg("conversion specifies argument 0, but arguments are numbered from 1")));
+ 
+ 			/* Not enough arguments?  Deduct 1 to avoid counting format string. */
+ 			if (indirect_width_parameter > nargs - 1)
+ 				ereport(ERROR,
+ 						(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+ 						 errmsg("too few arguments for format")));
+ 
+ 			/* get value of related parameter that holds width and coerce to int */
+ 			if (!funcvariadic)
+ 			{
+ 				value = PG_GETARG_DATUM(indirect_width_parameter);
+ 				isNull = PG_ARGISNULL(indirect_width_parameter);
+ 				typid = get_fn_expr_argtype(fcinfo->flinfo, indirect_width_parameter);
+ 			}
+ 			else
+ 			{
+ 				value = elements[indirect_width_parameter - 1];
+ 				isNull = nulls[indirect_width_parameter - 1];
+ 				typid = element_type;
+ 			}
+ 			if (!OidIsValid(typid))
+ 				elog(ERROR, "could not determine data type of format() input");
+ 
+ 			/*
+ 			 * we don't need to different between NULL and zero in this moment,
+ 			 * NULL means ignore this width - same as zero.
+ 			 */
+ 			if (isNull)
+ 			{
+ 				value = 0;
+ 				isNull = false;
+ 				typid = INT4OID;
+ 			}
+ 			else if (typid != INT4OID)
+ 			{
+ 				char			*str;
+ 
+ 				/* simple IO cast to int */
+ 				if (typid != prev_type_width)
+ 				{
+ 					Oid			typoutputfunc;
+ 					bool		typIsVarlena;
+ 
+ 					getTypeOutputInfo(typid, &typoutputfunc, &typIsVarlena);
+ 					fmgr_info(typoutputfunc, &typoutputinfo_width);
+ 					prev_type_width = typid;
+ 				}
+ 
+ 				/* Stringify. */
+ 				str = OutputFunctionCall(&typoutputinfo_width, value);
+ 
+ 				/* get int value */
+ 				width = pg_atoi(str, sizeof(int32), '\0');
+ 				pfree(str);
+ 			}
+ 			else
+ 				width = DatumGetInt32(value);
+ 
+ 			use_width = true;
+ 		}
+ 		else if (width != -1)
+ 			use_width = true;
+ 		else
+ 			use_width = false;
+ 
  		/* Get the value and type of the selected argument */
  		if (!funcvariadic)
  		{
***************
*** 4221,4227 **** text_format(PG_FUNCTION_ARGS)
  			case 'I':
  			case 'L':
  				text_format_string_conversion(&str, *cp, &typoutputfinfo,
! 											  value, isNull);
  				break;
  			default:
  				ereport(ERROR,
--- 4417,4424 ----
  			case 'I':
  			case 'L':
  				text_format_string_conversion(&str, *cp, &typoutputfinfo,
! 											  value, isNull,
! 											  flags, use_width, width);
  				break;
  			default:
  				ereport(ERROR,
***************
*** 4244,4254 **** text_format(PG_FUNCTION_ARGS)
  	PG_RETURN_TEXT_P(result);
  }
  
  /* Format a %s, %I, or %L conversion. */
  static void
  text_format_string_conversion(StringInfo buf, char conversion,
  							  FmgrInfo *typOutputInfo,
! 							  Datum value, bool isNull)
  {
  	char	   *str;
  
--- 4441,4497 ----
  	PG_RETURN_TEXT_P(result);
  }
  
+ /*
+  * Add spaces on begin or on end when it is necessary
+  */
+ static void
+ text_format_append_string(StringInfo buf, const char *str,
+ 					  int flags, bool use_width, int width)
+ {
+ 	bool		align_to_left;
+ 	int		len;
+ 
+ 	/* fast path */
+ 	if (!use_width)
+ 	{
+ 		appendStringInfoString(buf, str);
+ 		return;
+ 	}
+ 
+ 	if (width < 0)
+ 	{
+ 		width = -width;
+ 		align_to_left = true;
+ 	}
+ 	else if (flags & TEXT_FORMAT_FLAG_MINUS)
+ 	{
+ 		align_to_left = true;
+ 	}
+ 	else
+ 		align_to_left = false;
+ 
+ 	len = pg_mbstrlen(str);
+ 	if (align_to_left)
+ 	{
+ 		appendStringInfoString(buf, str);
+ 		if (len < width)
+ 			appendStringInfoSpaces(buf, width - len);
+ 	}
+ 	else
+ 	{
+ 		/* align_to_right */
+ 		if (len < width)
+ 			appendStringInfoSpaces(buf, width - len);
+ 		appendStringInfoString(buf, str);
+ 	}
+ }
+ 
  /* Format a %s, %I, or %L conversion. */
  static void
  text_format_string_conversion(StringInfo buf, char conversion,
  							  FmgrInfo *typOutputInfo,
! 							  Datum value, bool isNull,
! 							  int flags, bool use_width, int width)
  {
  	char	   *str;
  
***************
*** 4256,4262 **** text_format_string_conversion(StringInfo buf, char conversion,
  	if (isNull)
  	{
  		if (conversion == 'L')
! 			appendStringInfoString(buf, "NULL");
  		else if (conversion == 'I')
  			ereport(ERROR,
  					(errcode(ERRCODE_NULL_VALUE_NOT_ALLOWED),
--- 4499,4506 ----
  	if (isNull)
  	{
  		if (conversion == 'L')
! 			text_format_append_string(buf, "NULL",
! 							flags, use_width, width);
  		else if (conversion == 'I')
  			ereport(ERROR,
  					(errcode(ERRCODE_NULL_VALUE_NOT_ALLOWED),
***************
*** 4271,4288 **** text_format_string_conversion(StringInfo buf, char conversion,
  	if (conversion == 'I')
  	{
  		/* quote_identifier may or may not allocate a new string. */
! 		appendStringInfoString(buf, quote_identifier(str));
  	}
  	else if (conversion == 'L')
! 	{
! 		char	   *qstr = quote_literal_cstr(str);
  
! 		appendStringInfoString(buf, qstr);
  		/* quote_literal_cstr() always allocates a new string */
  		pfree(qstr);
  	}
  	else
! 		appendStringInfoString(buf, str);
  
  	/* Cleanup. */
  	pfree(str);
--- 4515,4534 ----
  	if (conversion == 'I')
  	{
  		/* quote_identifier may or may not allocate a new string. */
! 		text_format_append_string(buf, quote_identifier(str),
! 							flags, use_width, width);
  	}
  	else if (conversion == 'L')
! 	{		char	   *qstr = quote_literal_cstr(str);
  
! 		text_format_append_string(buf, qstr,
! 							flags, use_width, width);
  		/* quote_literal_cstr() always allocates a new string */
  		pfree(qstr);
  	}
  	else
! 		text_format_append_string(buf, str,
! 							flags, use_width, width);
  
  	/* Cleanup. */
  	pfree(str);
*** a/src/test/regress/expected/text.out
--- b/src/test/regress/expected/text.out
***************
*** 257,267 **** ERROR:  too few arguments for format
  select format('%1$s %13$s', 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12);
  ERROR:  too few arguments for format
  select format('%1s', 1);
! ERROR:  unterminated conversion specifier
  select format('%1$', 1);
  ERROR:  unterminated conversion specifier
  select format('%1$1', 1);
! ERROR:  unrecognized conversion specifier "1"
  -- check mix of positional and ordered placeholders
  select format('Hello %s %1$s %s', 'World', 'Hello again');
              format             
--- 257,271 ----
  select format('%1$s %13$s', 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12);
  ERROR:  too few arguments for format
  select format('%1s', 1);
!  format 
! --------
!  1
! (1 row)
! 
  select format('%1$', 1);
  ERROR:  unterminated conversion specifier
  select format('%1$1', 1);
! ERROR:  unterminated conversion specifier
  -- check mix of positional and ordered placeholders
  select format('Hello %s %1$s %s', 'World', 'Hello again');
              format             
***************
*** 328,330 **** from generate_series(1,200) g(i);
--- 332,387 ----
   1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,160,161,162,163,164,165,166,167,168,169,170,171,172,173,174,175,176,177,178,179,180,181,182,183,184,185,186,187,188,189,190,191,192,193,194,195,196,197,198,199,200
  (1 row)
  
+ -- left, right align
+ select format('>>%10s<<', 'Hello')
+ union all
+ select format('>>%-10s<<', 'Hello')
+ union all
+ select format('>>%1$10s<<', 'Hello')
+ union all
+ select format('>>%1$-10I<<', 'Hello')
+ union all
+ select format('>>%2$*1$L<<', 10, 'Hello')
+ union all
+ select format('>>%*s<<', 10, 'Hello');
+      format     
+ ----------------
+  >>     Hello<<
+  >>Hello     <<
+  >>     Hello<<
+  >>"Hello"   <<
+  >>   'Hello'<<
+  >>     Hello<<
+ (6 rows)
+ 
+ select format('>>%*1$s<<', 10, 'Hello');
+      format     
+ ----------------
+  >>     Hello<<
+ (1 row)
+ 
+ select format('>>%-s<<', 'Hello');
+   format   
+ -----------
+  >>Hello<<
+ (1 row)
+ 
+ -- NULL is not different to zero here
+ select format('>>%10L<<', NULL);
+      format     
+ ----------------
+  >>      NULL<<
+ (1 row)
+ 
+ select format('>>%2$*1$L<<', NULL, 'Hello');
+    format    
+ -------------
+  >>'Hello'<<
+ (1 row)
+ 
+ select format('>>%2$*1$L<<', 0, 'Hello');
+    format    
+ -------------
+  >>'Hello'<<
+ (1 row)
+ 
*** a/src/test/regress/sql/text.sql
--- b/src/test/regress/sql/text.sql
***************
*** 97,99 **** select format('Hello', variadic NULL);
--- 97,120 ----
  -- variadic argument allows simulating more than FUNC_MAX_ARGS parameters
  select format(string_agg('%s',','), variadic array_agg(i))
  from generate_series(1,200) g(i);
+ 
+ -- left, right align
+ select format('>>%10s<<', 'Hello')
+ union all
+ select format('>>%-10s<<', 'Hello')
+ union all
+ select format('>>%1$10s<<', 'Hello')
+ union all
+ select format('>>%1$-10I<<', 'Hello')
+ union all
+ select format('>>%2$*1$L<<', 10, 'Hello')
+ union all
+ select format('>>%*s<<', 10, 'Hello');
+ 
+ select format('>>%*1$s<<', 10, 'Hello');
+ select format('>>%-s<<', 'Hello');
+ 
+ -- NULL is not different to zero here
+ select format('>>%10L<<', NULL);
+ select format('>>%2$*1$L<<', NULL, 'Hello');
+ select format('>>%2$*1$L<<', 0, 'Hello');

*** a/doc/src/sgml/func.sgml
--- b/doc/src/sgml/func.sgml
***************
*** 1519,1539 ****
           <primary>format</primary>
          </indexterm>
          <literal><function>format</function>(<parameter>formatstr</parameter> <type>text</type>
!         [, <parameter>str</parameter> <type>"any"</type> [, ...] ])</literal>
         </entry>
         <entry><type>text</type></entry>
         <entry>
           Format arguments according to a format string.
!          This function is similar to the C function
!          <function>sprintf</>, but only the following conversion specifications
!          are recognized: <literal>%s</literal> interpolates the corresponding
!          argument as a string; <literal>%I</literal> escapes its argument as
!          an SQL identifier; <literal>%L</literal> escapes its argument as an
!          SQL literal; <literal>%%</literal> outputs a literal <literal>%</>.
!          A conversion can reference an explicit parameter position by preceding
!          the conversion specifier with <literal><replaceable>n</>$</>, where
!          <replaceable>n</replaceable> is the argument position.
!          See also <xref linkend="plpgsql-quote-literal-example">.
         </entry>
         <entry><literal>format('Hello %s, %1$s', 'World')</literal></entry>
         <entry><literal>Hello World, World</literal></entry>
--- 1519,1531 ----
           <primary>format</primary>
          </indexterm>
          <literal><function>format</function>(<parameter>formatstr</parameter> <type>text</type>
!         [, <parameter>formatarg</parameter> <type>"any"</type> [, ...] ])</literal>
         </entry>
         <entry><type>text</type></entry>
         <entry>
           Format arguments according to a format string.
!          This function is similar to the C function <function>sprintf</>.
!          See <xref linkend="functions-string-format">.
         </entry>
         <entry><literal>format('Hello %s, %1$s', 'World')</literal></entry>
         <entry><literal>Hello World, World</literal></entry>
***************
*** 2847,2852 ****
--- 2839,3024 ----
      </tgroup>
     </table>
  
+    <sect2 id="functions-string-format">
+     <title><function>format</function></title>
+ 
+     <indexterm>
+      <primary>format</primary>
+     </indexterm>
+ 
+     <para>
+      The function <function>format</> produces formatted output according to
+      a format string in a similar way to the C function <function>sprintf</>.
+     </para>
+ 
+     <para>
+ <synopsis>
+ format(<parameter>formatstr</> <type>text</> [, <parameter>formatarg</> <type>"any"</> [, ...] ])
+ </synopsis>
+      <replaceable>formatstr</> is a format string that specifies how the
+      result should be formatted.  Text in the format string is copied directly
+      to the result, except where <firstterm>format specifiers</> are used.
+      Format specifiers act as placeholders in the string, allowing subsequent
+      function arguments to be formatted and inserted into the result.
+     </para>
+ 
+     <para>
+      Format specifiers are introduced by a <literal>%</> character and take
+      the form
+ <synopsis>
+ %[<replaceable>parameter</>][<replaceable>flags</>][<replaceable>width</>]<replaceable>type</>
+ </synopsis>
+      <variablelist>
+       <varlistentry>
+        <term><replaceable>parameter</replaceable> (optional)</term>
+        <listitem>
+         <para>
+          An expression of the form <literal><replaceable>n</>$</> where
+          <replaceable>n</> is the index of the argument to use for the format
+          specifier's value.  An index of 1 means the first argument after
+          <replaceable>formatstr</>.  If the <replaceable>parameter</> field is
+          omitted, the default is to use the next argument.
+         </para>
+ <screen>
+ SELECT format('Testing %s, %s, %s', 'one', 'two', 'three');
+ <lineannotation>Result: </><computeroutput>Testing one, two, three</>
+ 
+ SELECT format('Testing %3$s, %2$s, %1$s', 'one', 'two', 'three');
+ <lineannotation>Result: </><computeroutput>Testing three, two, one</>
+ </screen>
+ 
+         <para>
+          Note that unlike the C function <function>sprintf</> defined in the
+          Single UNIX Specification, the <function>format</> function in
+          <productname>PostgreSQL</> allows format specifiers with and without
+          explicit <replaceable>parameter</> fields to be mixed in the same
+          format string.  A format specifier without a
+          <replaceable>parameter</> field always uses the next argument after
+          the last argument consumed.  In addition, the
+          <productname>PostgreSQL</> <function>format</> function does not
+          require all function arguments to be referred to in the format
+          string.
+         </para>
+ <screen>
+ SELECT format('Testing %3$s, %2$s, %s', 'one', 'two', 'three');
+ <lineannotation>Result: </><computeroutput>Testing three, two, three</>
+ </screen>
+        </listitem>
+       </varlistentry>
+ 
+       <varlistentry>
+        <term><replaceable>flags</replaceable> (optional)</term>
+        <listitem>
+         <para>
+          Additional options controlling how the format specifier's output is
+          formatted.  Currently the only supported flag is an minus sign
+          (<literal>-</>) which will cause the format specifier's output to be
+          left-aligned.  This has no effect unless the <replaceable>width</>
+          field is also specified.
+         </para>
+ <screen>
+ SELECT format('|%10s|%-10s|', 'foo', 'bar');
+ <lineannotation>Result: </><computeroutput>|       foo|bar       |</>
+ </screen>
+        </listitem>
+       </varlistentry>
+ 
+       <varlistentry>
+        <term><replaceable>width</replaceable> (optional)</term>
+        <listitem>
+         <para>
+          Specifies the <emphasis>minimum</> number of characters to use to
+          display the format specifier's output.  The width may be specified
+          using any of the following: a positive integer; an asterisk
+          (<literal>*</>) to use the next function argument as the width; or an
+          expression of the form <literal>*<replaceable>n</>$</> to use the
+          <replaceable>n</>th function argument as the width.
+         </para>
+ 
+         <para>
+          If the width comes from a function argument, that argument is
+          consumed <emphasis>before</> the argument that is used for the format
+          specifier's value.  If the width argument is negative, the result is
+          left aligned, as if the <literal>-</> flag had been specified.
+         </para>
+ <screen>
+ SELECT format('|%10s|', 'foo');
+ <lineannotation>Result: </><computeroutput>|       foo|</>
+ 
+ SELECT format('|%*s|', 10, 'foo');
+ <lineannotation>Result: </><computeroutput>|       foo|</>
+ 
+ SELECT format('|%*s|', -10, 'foo');
+ <lineannotation>Result: </><computeroutput>|foo       |</>
+ 
+ SELECT format('|%-*s|', 10, 'foo');
+ <lineannotation>Result: </><computeroutput>|foo       |</>
+ 
+ SELECT format('|%-*s|', -10, 'foo');
+ <lineannotation>Result: </><computeroutput>|foo       |</>
+ 
+ SELECT format('|%*2$s|', 'foo', 10, 'bar');
+ <lineannotation>Result: </><computeroutput>|       bar|</>
+ 
+ SELECT format('|%3$*2$s|', 'foo', 10, 'bar');
+ <lineannotation>Result: </><computeroutput>|       bar|</>
+ </screen>
+        </listitem>
+       </varlistentry>
+ 
+       <varlistentry>
+        <term><replaceable>type</replaceable> (required)</term>
+        <listitem>
+         <para>
+          The type of format conversion to use to produce the format
+          specifier's output.  The following types are supported:
+          <itemizedlist>
+           <listitem>
+            <para>
+             <literal>s</literal> formats the argument value as a simple
+             string.  A null value is treated as an empty string.
+            </para>
+           </listitem>
+           <listitem>
+            <para>
+             <literal>I</literal> escapes the value as an SQL identifier.  It
+             is an error for the value to be null.
+            </para>
+           </listitem>
+           <listitem>
+            <para>
+             <literal>L</literal> escapes the value as an SQL literal.  A null
+             value is displayed as the literal value <literal>NULL</>.
+            </para>
+           </listitem>
+          </itemizedlist>
+         </para>
+ <screen>
+ SELECT format('Hello %s', 'World');
+ <lineannotation>Result: </lineannotation><computeroutput>Hello World</computeroutput>
+ 
+ SELECT format('DROP TABLE %I', 'Foo bar');
+ <lineannotation>Result: </lineannotation><computeroutput>DROP TABLE "Foo bar"</computeroutput>
+ 
+ SELECT format('SELECT %L', E'O\'Reilly');
+ <lineannotation>Result: </lineannotation><computeroutput>SELECT 'O''Reilly'</computeroutput>
+ </screen>
+ 
+         <para>
+          The <literal>%I</> and <literal>%L</> format specifiers may be used
+          to safely construct dynamic SQL statements.  See
+          <xref linkend="plpgsql-quote-literal-example">.
+         </para>
+        </listitem>
+       </varlistentry>
+      </variablelist>
+     </para>
+ 
+     <para>
+      In addition to the format specifiers above, the special escape sequence
+      <literal>%%</> may be used to output a literal <literal>%</> character.
+     </para>
+    </sect2>
    </sect1>
  
  
*** a/src/backend/utils/adt/varlena.c
--- b/src/backend/utils/adt/varlena.c
***************
*** 78,84 **** static bytea *bytea_overlay(bytea *t1, bytea *t2, int sp, int sl);
  static StringInfo makeStringAggState(FunctionCallInfo fcinfo);
  static void text_format_string_conversion(StringInfo buf, char conversion,
  							  FmgrInfo *typOutputInfo,
! 							  Datum value, bool isNull);
  static Datum text_to_array_internal(PG_FUNCTION_ARGS);
  static text *array_to_text_internal(FunctionCallInfo fcinfo, ArrayType *v,
  					   const char *fldsep, const char *null_string);
--- 78,85 ----
  static StringInfo makeStringAggState(FunctionCallInfo fcinfo);
  static void text_format_string_conversion(StringInfo buf, char conversion,
  							  FmgrInfo *typOutputInfo,
! 							  Datum value, bool isNull,
! 							  int flags, bool use_width, int width);
  static Datum text_to_array_internal(PG_FUNCTION_ARGS);
  static text *array_to_text_internal(FunctionCallInfo fcinfo, ArrayType *v,
  					   const char *fldsep, const char *null_string);
***************
*** 3997,4002 **** text_reverse(PG_FUNCTION_ARGS)
--- 3998,4134 ----
  }
  
  /*
+  * Returns pointer of first non digit char
+  *
+  * When some digits are processed, then inum returns parsed number
+  * and is_valid is true, otherwise is_valid is false.
+  */
+ static const char *
+ text_format_parse_digits(const char *start_ptr, const char *end_ptr,
+ 				int	*inum,					/* OUT param */
+ 				bool	*is_valid)				/* OUT param */
+ {
+ 	const char *cp = start_ptr;
+ 
+ 	*is_valid = false;
+ 	*inum = 0;
+ 
+ 	/* continue, only when start_ptr is less than end_ptr */
+ 	while (cp < end_ptr)
+ 	{
+ 		if (*cp >= '0' && *cp <= '9')
+ 		{
+ 			int	newnum = *inum * 10 + (*cp - '0');
+ 
+ 			if (newnum / 10 != *inum) /* overflow? */
+ 				ereport(ERROR,
+ 						(errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
+ 						 errmsg("number is out of range")));
+ 			*inum = newnum;
+ 			*is_valid = true;
+ 			++cp;
+ 		}
+ 		else
+ 			break;
+ 	}
+ 
+ 	/* should not be after last char of format string */
+ 	if (cp >= end_ptr)
+ 		ereport(ERROR,
+ 				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+ 				 errmsg("unterminated conversion specifier")));
+ 
+ 	return cp;
+ }
+ 
+ #define TEXT_FORMAT_FLAG_MINUS	0x0001			/* is minus in format string? */
+ 
+ #define TEXT_FORMAT_NEXT_CHAR(ptr, end_ptr) \
+ do { \
+ 	if (++(ptr) >= (end_ptr)) \
+ 		ereport(ERROR, \
+ 				(errcode(ERRCODE_INVALID_PARAMETER_VALUE), \
+ 				 errmsg("unterminated conversion specifier"))); \
+ } while (0)
+ 
+ /*
+  * parse format specification
+  *             [parameter][flags][width]type
+  *
+  * -1 in int OUT parameters signalize so this attribut is missing,
+  * all values should be zero or greather than zero. Raise exeption
+  * when some parameter is out of range.
+  */
+ static const char *
+ text_format_parse_format(const char *start_ptr, const char *end_ptr,
+ 				int *parameter,						/* OUT param */
+ 				int *flags,						/* OUT param */
+ 				int *width,						/* OUT param */
+ 				bool *indirect_width,					/* OUT param */
+ 				int *indirect_width_parameter)				/* OUT param */
+ {
+ 	int	   inum;
+ 	bool	   is_valid;
+ 
+ 	/* set defaults to out parameters */
+ 	*parameter = -1;
+ 	*flags = 0;
+ 	*width = -1;
+ 	*indirect_width = false;
+ 	*indirect_width_parameter = -1;
+ 
+ 	/* try to identify first number */
+ 	start_ptr = text_format_parse_digits(start_ptr, end_ptr, &inum, &is_valid);
+ 	if (is_valid)
+ 	{
+ 		/* number on this position can be parameter number or the width */
+ 		if (*start_ptr != '$')
+ 		{
+ 			*width = inum;
+ 			return start_ptr;
+ 		}
+ 
+ 		*parameter = inum;
+ 		TEXT_FORMAT_NEXT_CHAR(start_ptr, end_ptr);
+ 	}
+ 
+ 	/* try to parse flags, only minus is supported now */
+ 	if (*start_ptr == '-')
+ 	{
+ 		*flags = *flags | TEXT_FORMAT_FLAG_MINUS;
+ 		TEXT_FORMAT_NEXT_CHAR(start_ptr, end_ptr);
+ 	}
+ 
+ 	/* try to parse indirect width */
+ 	if (*start_ptr == '*')
+ 	{
+ 		start_ptr = text_format_parse_digits(++start_ptr, end_ptr, &inum, &is_valid);
+ 		if (is_valid)
+ 		{
+ 			/* number in this position should be closed by $ */
+ 			if (*start_ptr != '$')
+ 				ereport(ERROR,
+ 						(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+ 						 errmsg("unexpected char \"%c\"", *start_ptr)));
+ 			TEXT_FORMAT_NEXT_CHAR(start_ptr, end_ptr);
+ 
+ 			*indirect_width_parameter = inum;
+ 		}
+ 		else
+ 			*indirect_width = true;
+ 
+ 		return start_ptr;
+ 	}
+ 
+ 	/* last possible nummber - width */
+ 	start_ptr = text_format_parse_digits(start_ptr, end_ptr, &inum, &is_valid);
+ 	if (is_valid)
+ 		*width = inum;
+ 
+ 	return start_ptr;
+ }
+ 
+ /*
   * Returns a formated string
   */
  Datum
***************
*** 4016,4021 **** text_format(PG_FUNCTION_ARGS)
--- 4148,4155 ----
  	Oid			element_type = InvalidOid;
  	Oid			prev_type = InvalidOid;
  	FmgrInfo	typoutputfinfo;
+ 	FmgrInfo		typoutputinfo_width;
+ 	Oid			prev_type_width = InvalidOid;
  
  	/* When format string is null, returns null */
  	if (PG_ARGISNULL(0))
***************
*** 4088,4093 **** text_format(PG_FUNCTION_ARGS)
--- 4222,4233 ----
  		Datum		value;
  		bool		isNull;
  		Oid			typid;
+ 		int parameter;
+ 		int flags;
+ 		int width;
+ 		bool indirect_width;
+ 		int indirect_width_parameter;
+ 		bool		use_width;
  
  		/*
  		 * If it's not the start of a conversion specifier, just copy it to
***************
*** 4099,4109 **** text_format(PG_FUNCTION_ARGS)
  			continue;
  		}
  
! 		/* Did we run off the end of the string? */
! 		if (++cp >= end_ptr)
! 			ereport(ERROR,
! 					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
! 					 errmsg("unterminated conversion specifier")));
  
  		/* Easy case: %% outputs a single % */
  		if (*cp == '%')
--- 4239,4246 ----
  			continue;
  		}
  
! 		/* go to next char */
! 		TEXT_FORMAT_NEXT_CHAR(cp, end_ptr);
  
  		/* Easy case: %% outputs a single % */
  		if (*cp == '%')
***************
*** 4112,4125 **** text_format(PG_FUNCTION_ARGS)
  			continue;
  		}
  
! 		/*
! 		 * If the user hasn't specified an argument position, we just advance
! 		 * to the next one.  If they have, we must parse it.
! 		 */
! 		if (*cp < '0' || *cp > '9')
  		{
! 			++arg;
! 			if (arg <= 0)		/* overflow? */
  			{
  				/*
  				 * Should not happen, as you can't pass billions of arguments
--- 4249,4264 ----
  			continue;
  		}
  
! 		cp = text_format_parse_format(cp, end_ptr,
! 								&parameter,
! 								&flags,
! 								&width,
! 								&indirect_width,
! 								&indirect_width_parameter);
! 
! 		if (indirect_width)
  		{
! 			if (++arg <= 0)		/* overflow? */
  			{
  				/*
  				 * Should not happen, as you can't pass billions of arguments
***************
*** 4129,4177 **** text_format(PG_FUNCTION_ARGS)
  						(errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
  						 errmsg("argument number is out of range")));
  			}
  		}
! 		else
  		{
! 			bool		unterminated = false;
! 
! 			/* Parse digit string. */
! 			arg = 0;
! 			do
! 			{
! 				int			newarg = arg * 10 + (*cp - '0');
! 
! 				if (newarg / 10 != arg) /* overflow? */
! 					ereport(ERROR,
! 							(errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
! 							 errmsg("argument number is out of range")));
! 				arg = newarg;
! 				++cp;
! 			} while (cp < end_ptr && *cp >= '0' && *cp <= '9');
  
! 			/*
! 			 * If we ran off the end, or if there's not a $ next, or if the $
! 			 * is the last character, the conversion specifier is improperly
! 			 * terminated.
! 			 */
! 			if (cp == end_ptr || *cp != '$')
! 				unterminated = true;
! 			else
  			{
! 				++cp;
! 				if (cp == end_ptr)
! 					unterminated = true;
! 			}
! 			if (unterminated)
! 				ereport(ERROR,
! 						(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
! 						 errmsg("unterminated conversion specifier")));
! 
! 			/* There's no argument 0. */
! 			if (arg == 0)
  				ereport(ERROR,
! 						(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
! 						 errmsg("conversion specifies argument 0, but arguments are numbered from 1")));
  		}
  
  		/* Not enough arguments?  Deduct 1 to avoid counting format string. */
  		if (arg > nargs - 1)
--- 4268,4301 ----
  						(errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
  						 errmsg("argument number is out of range")));
  			}
+ 			indirect_width_parameter = arg;
  		}
! 		else if (indirect_width_parameter != -1)
  		{
! 			/* be consistent, move ordered argument together with positional */
! 			arg = indirect_width_parameter;
! 		}
  
! 		if (parameter == -1)
! 		{
! 			if (++arg <= 0)		/* overflow? */
  			{
! 				/*
! 				 * Should not happen, as you can't pass billions of arguments
! 				 * to a function, but better safe than sorry.
! 				 */
  				ereport(ERROR,
! 						(errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
! 						 errmsg("argument number is out of range")));
! 			}
  		}
+ 		else
+ 			arg = parameter;
+ 
+ 		if (arg == 0)
+ 			ereport(ERROR,
+ 					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+ 					 errmsg("conversion specifies argument 0, but arguments are numbered from 1")));
  
  		/* Not enough arguments?  Deduct 1 to avoid counting format string. */
  		if (arg > nargs - 1)
***************
*** 4179,4184 **** text_format(PG_FUNCTION_ARGS)
--- 4303,4380 ----
  					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
  					 errmsg("too few arguments for format")));
  
+ 		if (indirect_width_parameter != -1)
+ 		{
+ 
+ 			if (indirect_width_parameter == 0)
+ 				ereport(ERROR,
+ 						(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+ 						 errmsg("conversion specifies argument 0, but arguments are numbered from 1")));
+ 
+ 			/* Not enough arguments?  Deduct 1 to avoid counting format string. */
+ 			if (indirect_width_parameter > nargs - 1)
+ 				ereport(ERROR,
+ 						(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+ 						 errmsg("too few arguments for format")));
+ 
+ 			/* get value of related parameter that holds width and coerce to int */
+ 			if (!funcvariadic)
+ 			{
+ 				value = PG_GETARG_DATUM(indirect_width_parameter);
+ 				isNull = PG_ARGISNULL(indirect_width_parameter);
+ 				typid = get_fn_expr_argtype(fcinfo->flinfo, indirect_width_parameter);
+ 			}
+ 			else
+ 			{
+ 				value = elements[indirect_width_parameter - 1];
+ 				isNull = nulls[indirect_width_parameter - 1];
+ 				typid = element_type;
+ 			}
+ 			if (!OidIsValid(typid))
+ 				elog(ERROR, "could not determine data type of format() input");
+ 
+ 			/*
+ 			 * we don't need to different between NULL and zero in this moment,
+ 			 * NULL means ignore this width - same as zero.
+ 			 */
+ 			if (isNull)
+ 			{
+ 				value = 0;
+ 				isNull = false;
+ 				typid = INT4OID;
+ 			}
+ 			else if (typid != INT4OID)
+ 			{
+ 				char			*str;
+ 
+ 				/* simple IO cast to int */
+ 				if (typid != prev_type_width)
+ 				{
+ 					Oid			typoutputfunc;
+ 					bool		typIsVarlena;
+ 
+ 					getTypeOutputInfo(typid, &typoutputfunc, &typIsVarlena);
+ 					fmgr_info(typoutputfunc, &typoutputinfo_width);
+ 					prev_type_width = typid;
+ 				}
+ 
+ 				/* Stringify. */
+ 				str = OutputFunctionCall(&typoutputinfo_width, value);
+ 
+ 				/* get int value */
+ 				width = pg_atoi(str, sizeof(int32), '\0');
+ 				pfree(str);
+ 			}
+ 			else
+ 				width = DatumGetInt32(value);
+ 
+ 			use_width = true;
+ 		}
+ 		else if (width != -1)
+ 			use_width = true;
+ 		else
+ 			use_width = false;
+ 
  		/* Get the value and type of the selected argument */
  		if (!funcvariadic)
  		{
***************
*** 4221,4227 **** text_format(PG_FUNCTION_ARGS)
  			case 'I':
  			case 'L':
  				text_format_string_conversion(&str, *cp, &typoutputfinfo,
! 											  value, isNull);
  				break;
  			default:
  				ereport(ERROR,
--- 4417,4424 ----
  			case 'I':
  			case 'L':
  				text_format_string_conversion(&str, *cp, &typoutputfinfo,
! 											  value, isNull,
! 											  flags, use_width, width);
  				break;
  			default:
  				ereport(ERROR,
***************
*** 4244,4288 **** text_format(PG_FUNCTION_ARGS)
  	PG_RETURN_TEXT_P(result);
  }
  
  /* Format a %s, %I, or %L conversion. */
  static void
  text_format_string_conversion(StringInfo buf, char conversion,
  							  FmgrInfo *typOutputInfo,
! 							  Datum value, bool isNull)
  {
  	char	   *str;
  
- 	/* Handle NULL arguments before trying to stringify the value. */
  	if (isNull)
  	{
! 		if (conversion == 'L')
! 			appendStringInfoString(buf, "NULL");
  		else if (conversion == 'I')
  			ereport(ERROR,
  					(errcode(ERRCODE_NULL_VALUE_NOT_ALLOWED),
  			errmsg("null values cannot be formatted as an SQL identifier")));
  		return;
  	}
  
- 	/* Stringify. */
  	str = OutputFunctionCall(typOutputInfo, value);
  
  	/* Escape. */
  	if (conversion == 'I')
  	{
  		/* quote_identifier may or may not allocate a new string. */
! 		appendStringInfoString(buf, quote_identifier(str));
  	}
  	else if (conversion == 'L')
! 	{
! 		char	   *qstr = quote_literal_cstr(str);
  
! 		appendStringInfoString(buf, qstr);
  		/* quote_literal_cstr() always allocates a new string */
  		pfree(qstr);
  	}
  	else
! 		appendStringInfoString(buf, str);
  
  	/* Cleanup. */
  	pfree(str);
--- 4441,4536 ----
  	PG_RETURN_TEXT_P(result);
  }
  
+ /*
+  * Add spaces on begin or on end when it is necessary
+  */
+ static void
+ text_format_append_string(StringInfo buf, const char *str,
+ 					  int flags, bool use_width, int width)
+ {
+ 	bool		align_to_left;
+ 	int		len;
+ 
+ 	/* fast path */
+ 	if (!use_width)
+ 	{
+ 		appendStringInfoString(buf, str);
+ 		return;
+ 	}
+ 
+ 	if (width < 0)
+ 	{
+ 		width = -width;
+ 		align_to_left = true;
+ 	}
+ 	else if (flags & TEXT_FORMAT_FLAG_MINUS)
+ 	{
+ 		align_to_left = true;
+ 	}
+ 	else
+ 		align_to_left = false;
+ 
+ 	len = pg_mbstrlen(str);
+ 	if (align_to_left)
+ 	{
+ 		appendStringInfoString(buf, str);
+ 		if (len < width)
+ 			appendStringInfoSpaces(buf, width - len);
+ 	}
+ 	else
+ 	{
+ 		/* align_to_right */
+ 		if (len < width)
+ 			appendStringInfoSpaces(buf, width - len);
+ 		appendStringInfoString(buf, str);
+ 	}
+ }
+ 
  /* Format a %s, %I, or %L conversion. */
  static void
  text_format_string_conversion(StringInfo buf, char conversion,
  							  FmgrInfo *typOutputInfo,
! 							  Datum value, bool isNull,
! 							  int flags, bool use_width, int width)
  {
  	char	   *str;
  
  	if (isNull)
  	{
! 		if (conversion == 's')
! 			text_format_append_string(buf, "",
! 								flags, use_width, width);
! 		else if (conversion == 'L')
! 			text_format_append_string(buf, "NULL",
! 								flags, use_width, width);
  		else if (conversion == 'I')
  			ereport(ERROR,
  					(errcode(ERRCODE_NULL_VALUE_NOT_ALLOWED),
  			errmsg("null values cannot be formatted as an SQL identifier")));
+ 
  		return;
  	}
  
  	str = OutputFunctionCall(typOutputInfo, value);
  
  	/* Escape. */
  	if (conversion == 'I')
  	{
  		/* quote_identifier may or may not allocate a new string. */
! 		text_format_append_string(buf, quote_identifier(str),
! 							flags, use_width, width);
  	}
  	else if (conversion == 'L')
! 	{		char	   *qstr = quote_literal_cstr(str);
  
! 		text_format_append_string(buf, qstr,
! 							flags, use_width, width);
  		/* quote_literal_cstr() always allocates a new string */
  		pfree(qstr);
  	}
  	else
! 		text_format_append_string(buf, str,
! 							flags, use_width, width);
  
  	/* Cleanup. */
  	pfree(str);
*** a/src/test/regress/expected/text.out
--- b/src/test/regress/expected/text.out
***************
*** 257,267 **** ERROR:  too few arguments for format
  select format('%1$s %13$s', 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12);
  ERROR:  too few arguments for format
  select format('%1s', 1);
! ERROR:  unterminated conversion specifier
  select format('%1$', 1);
  ERROR:  unterminated conversion specifier
  select format('%1$1', 1);
! ERROR:  unrecognized conversion specifier "1"
  -- check mix of positional and ordered placeholders
  select format('Hello %s %1$s %s', 'World', 'Hello again');
              format             
--- 257,271 ----
  select format('%1$s %13$s', 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12);
  ERROR:  too few arguments for format
  select format('%1s', 1);
!  format 
! --------
!  1
! (1 row)
! 
  select format('%1$', 1);
  ERROR:  unterminated conversion specifier
  select format('%1$1', 1);
! ERROR:  unterminated conversion specifier
  -- check mix of positional and ordered placeholders
  select format('Hello %s %1$s %s', 'World', 'Hello again');
              format             
***************
*** 328,330 **** from generate_series(1,200) g(i);
--- 332,405 ----
   1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,160,161,162,163,164,165,166,167,168,169,170,171,172,173,174,175,176,177,178,179,180,181,182,183,184,185,186,187,188,189,190,191,192,193,194,195,196,197,198,199,200
  (1 row)
  
+ -- left, right align
+ select format('>>%10s<<', 'Hello')
+ union all
+ select format('>>%10s<<', NULL)
+ union all
+ select format('>>%10s<<', '')
+ union all
+ select format('>>%-10s<<', '')
+ union all
+ select format('>>%-10s<<', 'Hello')
+ union all
+ select format('>>%-10s<<', NULL)
+ union all
+ select format('>>%1$10s<<', 'Hello')
+ union all
+ select format('>>%1$-10I<<', 'Hello')
+ union all
+ select format('>>%2$*1$L<<', 10, 'Hello')
+ union all
+ select format('>>%2$*1$L<<', 10, NULL)
+ union all
+ select format('>>%2$*1$L<<', -10, NULL)
+ union all
+ select format('>>%*s<<', 10, 'Hello');
+      format     
+ ----------------
+  >>     Hello<<
+  >>          <<
+  >>          <<
+  >>          <<
+  >>Hello     <<
+  >>          <<
+  >>     Hello<<
+  >>"Hello"   <<
+  >>   'Hello'<<
+  >>      NULL<<
+  >>NULL      <<
+  >>     Hello<<
+ (12 rows)
+ 
+ select format('>>%*1$s<<', 10, 'Hello');
+      format     
+ ----------------
+  >>     Hello<<
+ (1 row)
+ 
+ select format('>>%-s<<', 'Hello');
+   format   
+ -----------
+  >>Hello<<
+ (1 row)
+ 
+ -- NULL is not different to zero here
+ select format('>>%10L<<', NULL);
+      format     
+ ----------------
+  >>      NULL<<
+ (1 row)
+ 
+ select format('>>%2$*1$L<<', NULL, 'Hello');
+    format    
+ -------------
+  >>'Hello'<<
+ (1 row)
+ 
+ select format('>>%2$*1$L<<', 0, 'Hello');
+    format    
+ -------------
+  >>'Hello'<<
+ (1 row)
+ 
*** a/src/test/regress/sql/text.sql
--- b/src/test/regress/sql/text.sql
***************
*** 97,99 **** select format('Hello', variadic NULL);
--- 97,132 ----
  -- variadic argument allows simulating more than FUNC_MAX_ARGS parameters
  select format(string_agg('%s',','), variadic array_agg(i))
  from generate_series(1,200) g(i);
+ 
+ -- left, right align
+ select format('>>%10s<<', 'Hello')
+ union all
+ select format('>>%10s<<', NULL)
+ union all
+ select format('>>%10s<<', '')
+ union all
+ select format('>>%-10s<<', '')
+ union all
+ select format('>>%-10s<<', 'Hello')
+ union all
+ select format('>>%-10s<<', NULL)
+ union all
+ select format('>>%1$10s<<', 'Hello')
+ union all
+ select format('>>%1$-10I<<', 'Hello')
+ union all
+ select format('>>%2$*1$L<<', 10, 'Hello')
+ union all
+ select format('>>%2$*1$L<<', 10, NULL)
+ union all
+ select format('>>%2$*1$L<<', -10, NULL)
+ union all
+ select format('>>%*s<<', 10, 'Hello');
+ 
+ select format('>>%*1$s<<', 10, 'Hello');
+ select format('>>%-s<<', 'Hello');
+ 
+ -- NULL is not different to zero here
+ select format('>>%10L<<', NULL);
+ select format('>>%2$*1$L<<', NULL, 'Hello');
+ select format('>>%2$*1$L<<', 0, 'Hello');

*** a/doc/src/sgml/func.sgml
--- b/doc/src/sgml/func.sgml
***************
*** 1519,1539 ****
           <primary>format</primary>
          </indexterm>
          <literal><function>format</function>(<parameter>formatstr</parameter> <type>text</type>
!         [, <parameter>str</parameter> <type>"any"</type> [, ...] ])</literal>
         </entry>
         <entry><type>text</type></entry>
         <entry>
           Format arguments according to a format string.
!          This function is similar to the C function
!          <function>sprintf</>, but only the following conversion specifications
!          are recognized: <literal>%s</literal> interpolates the corresponding
!          argument as a string; <literal>%I</literal> escapes its argument as
!          an SQL identifier; <literal>%L</literal> escapes its argument as an
!          SQL literal; <literal>%%</literal> outputs a literal <literal>%</>.
!          A conversion can reference an explicit parameter position by preceding
!          the conversion specifier with <literal><replaceable>n</>$</>, where
!          <replaceable>n</replaceable> is the argument position.
!          See also <xref linkend="plpgsql-quote-literal-example">.
         </entry>
         <entry><literal>format('Hello %s, %1$s', 'World')</literal></entry>
         <entry><literal>Hello World, World</literal></entry>
--- 1519,1531 ----
           <primary>format</primary>
          </indexterm>
          <literal><function>format</function>(<parameter>formatstr</parameter> <type>text</type>
!         [, <parameter>formatarg</parameter> <type>"any"</type> [, ...] ])</literal>
         </entry>
         <entry><type>text</type></entry>
         <entry>
           Format arguments according to a format string.
!          This function is similar to the C function <function>sprintf</>.
!          See <xref linkend="functions-string-format">.
         </entry>
         <entry><literal>format('Hello %s, %1$s', 'World')</literal></entry>
         <entry><literal>Hello World, World</literal></entry>
***************
*** 2847,2852 ****
--- 2839,3024 ----
      </tgroup>
     </table>
  
+    <sect2 id="functions-string-format">
+     <title><function>format</function></title>
+ 
+     <indexterm>
+      <primary>format</primary>
+     </indexterm>
+ 
+     <para>
+      The function <function>format</> produces formatted output according to
+      a format string in a similar way to the C function <function>sprintf</>.
+     </para>
+ 
+     <para>
+ <synopsis>
+ format(<parameter>formatstr</> <type>text</> [, <parameter>formatarg</> <type>"any"</> [, ...] ])
+ </synopsis>
+      <replaceable>formatstr</> is a format string that specifies how the
+      result should be formatted.  Text in the format string is copied directly
+      to the result, except where <firstterm>format specifiers</> are used.
+      Format specifiers act as placeholders in the string, allowing subsequent
+      function arguments to be formatted and inserted into the result.
+     </para>
+ 
+     <para>
+      Format specifiers are introduced by a <literal>%</> character and take
+      the form
+ <synopsis>
+ %[<replaceable>parameter</>][<replaceable>flags</>][<replaceable>width</>]<replaceable>type</>
+ </synopsis>
+      <variablelist>
+       <varlistentry>
+        <term><replaceable>parameter</replaceable> (optional)</term>
+        <listitem>
+         <para>
+          An expression of the form <literal><replaceable>n</>$</> where
+          <replaceable>n</> is the index of the argument to use for the format
+          specifier's value.  An index of 1 means the first argument after
+          <replaceable>formatstr</>.  If the <replaceable>parameter</> field is
+          omitted, the default is to use the next argument.
+         </para>
+ <screen>
+ SELECT format('Testing %s, %s, %s', 'one', 'two', 'three');
+ <lineannotation>Result: </><computeroutput>Testing one, two, three</>
+ 
+ SELECT format('Testing %3$s, %2$s, %1$s', 'one', 'two', 'three');
+ <lineannotation>Result: </><computeroutput>Testing three, two, one</>
+ </screen>
+ 
+         <para>
+          Note that unlike the C function <function>sprintf</> defined in the
+          Single UNIX Specification, the <function>format</> function in
+          <productname>PostgreSQL</> allows format specifiers with and without
+          explicit <replaceable>parameter</> fields to be mixed in the same
+          format string.  A format specifier without a
+          <replaceable>parameter</> field always uses the next argument after
+          the last argument consumed.  In addition, the
+          <productname>PostgreSQL</> <function>format</> function does not
+          require all function arguments to be referred to in the format
+          string.
+         </para>
+ <screen>
+ SELECT format('Testing %3$s, %2$s, %s', 'one', 'two', 'three');
+ <lineannotation>Result: </><computeroutput>Testing three, two, three</>
+ </screen>
+        </listitem>
+       </varlistentry>
+ 
+       <varlistentry>
+        <term><replaceable>flags</replaceable> (optional)</term>
+        <listitem>
+         <para>
+          Additional options controlling how the format specifier's output is
+          formatted.  Currently the only supported flag is an minus sign
+          (<literal>-</>) which will cause the format specifier's output to be
+          left-aligned.  This has no effect unless the <replaceable>width</>
+          field is also specified.
+         </para>
+ <screen>
+ SELECT format('|%10s|%-10s|', 'foo', 'bar');
+ <lineannotation>Result: </><computeroutput>|       foo|bar       |</>
+ </screen>
+        </listitem>
+       </varlistentry>
+ 
+       <varlistentry>
+        <term><replaceable>width</replaceable> (optional)</term>
+        <listitem>
+         <para>
+          Specifies the <emphasis>minimum</> number of characters to use to
+          display the format specifier's output.  The width may be specified
+          using any of the following: a positive integer; an asterisk
+          (<literal>*</>) to use the next function argument as the width; or an
+          expression of the form <literal>*<replaceable>n</>$</> to use the
+          <replaceable>n</>th function argument as the width.
+         </para>
+ 
+         <para>
+          If the width comes from a function argument, that argument is
+          consumed <emphasis>before</> the argument that is used for the format
+          specifier's value.  If the width argument is negative, the result is
+          left aligned, as if the <literal>-</> flag had been specified.
+         </para>
+ <screen>
+ SELECT format('|%10s|', 'foo');
+ <lineannotation>Result: </><computeroutput>|       foo|</>
+ 
+ SELECT format('|%*s|', 10, 'foo');
+ <lineannotation>Result: </><computeroutput>|       foo|</>
+ 
+ SELECT format('|%*s|', -10, 'foo');
+ <lineannotation>Result: </><computeroutput>|foo       |</>
+ 
+ SELECT format('|%-*s|', 10, 'foo');
+ <lineannotation>Result: </><computeroutput>|foo       |</>
+ 
+ SELECT format('|%-*s|', -10, 'foo');
+ <lineannotation>Result: </><computeroutput>|foo       |</>
+ 
+ SELECT format('|%*2$s|', 'foo', 10, 'bar');
+ <lineannotation>Result: </><computeroutput>|       bar|</>
+ 
+ SELECT format('|%3$*2$s|', 'foo', 10, 'bar');
+ <lineannotation>Result: </><computeroutput>|       bar|</>
+ </screen>
+        </listitem>
+       </varlistentry>
+ 
+       <varlistentry>
+        <term><replaceable>type</replaceable> (required)</term>
+        <listitem>
+         <para>
+          The type of format conversion to use to produce the format
+          specifier's output.  The following types are supported:
+          <itemizedlist>
+           <listitem>
+            <para>
+             <literal>s</literal> formats the argument value as a simple
+             string.  A null value is treated as an empty string.
+            </para>
+           </listitem>
+           <listitem>
+            <para>
+             <literal>I</literal> escapes the value as an SQL identifier.  It
+             is an error for the value to be null.
+            </para>
+           </listitem>
+           <listitem>
+            <para>
+             <literal>L</literal> escapes the value as an SQL literal.  A null
+             value is displayed as the literal value <literal>NULL</>.
+            </para>
+           </listitem>
+          </itemizedlist>
+         </para>
+ <screen>
+ SELECT format('Hello %s', 'World');
+ <lineannotation>Result: </lineannotation><computeroutput>Hello World</computeroutput>
+ 
+ SELECT format('DROP TABLE %I', 'Foo bar');
+ <lineannotation>Result: </lineannotation><computeroutput>DROP TABLE "Foo bar"</computeroutput>
+ 
+ SELECT format('SELECT %L', E'O\'Reilly');
+ <lineannotation>Result: </lineannotation><computeroutput>SELECT 'O''Reilly'</computeroutput>
+ </screen>
+ 
+         <para>
+          The <literal>%I</> and <literal>%L</> format specifiers may be used
+          to safely construct dynamic SQL statements.  See
+          <xref linkend="plpgsql-quote-literal-example">.
+         </para>
+        </listitem>
+       </varlistentry>
+      </variablelist>
+     </para>
+ 
+     <para>
+      In addition to the format specifiers above, the special escape sequence
+      <literal>%%</> may be used to output a literal <literal>%</> character.
+     </para>
+    </sect2>
    </sect1>
  
  
*** a/src/backend/utils/adt/varlena.c
--- b/src/backend/utils/adt/varlena.c
***************
*** 78,84 **** static bytea *bytea_overlay(bytea *t1, bytea *t2, int sp, int sl);
  static StringInfo makeStringAggState(FunctionCallInfo fcinfo);
  static void text_format_string_conversion(StringInfo buf, char conversion,
  							  FmgrInfo *typOutputInfo,
! 							  Datum value, bool isNull);
  static Datum text_to_array_internal(PG_FUNCTION_ARGS);
  static text *array_to_text_internal(FunctionCallInfo fcinfo, ArrayType *v,
  					   const char *fldsep, const char *null_string);
--- 78,85 ----
  static StringInfo makeStringAggState(FunctionCallInfo fcinfo);
  static void text_format_string_conversion(StringInfo buf, char conversion,
  							  FmgrInfo *typOutputInfo,
! 							  Datum value, bool isNull,
! 							  int flags, int width);
  static Datum text_to_array_internal(PG_FUNCTION_ARGS);
  static text *array_to_text_internal(FunctionCallInfo fcinfo, ArrayType *v,
  					   const char *fldsep, const char *null_string);
***************
*** 3996,4001 **** text_reverse(PG_FUNCTION_ARGS)
--- 3997,4133 ----
  	PG_RETURN_TEXT_P(result);
  }
  
+ #define FORWARD_PARSE_POINT(ptr) \
+ do { \
+ 	if (++(ptr) >= (end_ptr)) \
+ 		ereport(ERROR, \
+ 				(errcode(ERRCODE_INVALID_PARAMETER_VALUE), \
+ 				 errmsg("unterminated conversion specifier"))); \
+ } while (0)
+ 
+ /*
+  * Parse congiguous digits into decimal number.
+  *
+  * Returns true if some digits could be parsed and *ptr moved to the next
+  * character to be parsed. The value is returned into *value.
+  */
+ static bool
+ text_format_parse_digits(const char **ptr, const char *end_ptr, int *value)
+ {
+ 	const char *cp = *ptr;
+ 	int wval = 0;
+ 	bool found;
+ 
+ 	/*
+ 	 * continue, only when start_ptr is less than end_ptr.
+ 	 * Overrun of cp is checked in FORWARD_PARSE_POINT.
+ 	 */
+ 	while (*cp >= '0' && *cp <= '9')
+ 	{
+ 		int	newnum = wval * 10 + (*cp - '0');
+ 
+ 		if (newnum / 10 != wval) /* overflow? */
+ 			ereport(ERROR,
+ 					(errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
+ 					 errmsg("number is out of range")));
+ 		wval = newnum;
+ 		FORWARD_PARSE_POINT(cp);
+ 	}
+ 
+ 	found = (cp > *ptr);
+ 	*value = wval;
+ 	*ptr = cp;
+ 
+ 	return found;
+ }
+ 
+ #define TEXT_FORMAT_FLAG_MINUS	0x0001			/* is minus in format string? */
+ 
+ #define SAMESIGN(a,b)	(((a) < 0) == ((b) < 0))
+ 
+ /*
+  * parse format specification
+  *             [argpos][flags][width]type
+  *
+  * Return values are,
+  *   static const char * : Address to be parsed next.
+  *   valarg   : argument position for value to be printed. -1 means missing.
+  *   widtharg : argument position for width. Zero means that argument position
+  *              is not specified and -1 means missing.
+  *   flags    : flags
+  *   width    : the value for direct width specification, zero means that width
+  *              is not specified.
+  */
+ static const char *
+ text_format_parse_format(const char *start_ptr, const char *end_ptr,
+ 						 int *valarg, int *widtharg, int *flags, int *width)
+ {
+ 	const char *cp = start_ptr;
+ 	int	   n;
+ 
+ 	/* set defaults to out parameters */
+ 	*valarg =  -1;
+ 	*widtharg = -1;
+ 	*flags = 0;
+ 	*width = 0;
+ 
+ 	/* try to identify first number */
+ 	if (text_format_parse_digits(&cp, end_ptr, &n))
+ 	{
+ 		if (*cp != '$')
+ 		{
+ 			*width = n;    /* The number should be width */
+ 			return cp;
+ 		}
+ 		/* Explicit 0 for argument index is immediately refused */
+ 		if (n == 0)
+ 			ereport(ERROR,
+ 					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+ 					 errmsg("conversion specifies argument 0, but arguments are numbered from 1")));
+ 		*valarg = n;   /* The number was argument position  */
+ 		FORWARD_PARSE_POINT(cp);
+ 	}
+ 
+ 	/* Check for flags, only minus is supported now. */
+ 	while (*cp == '-')
+ 	{
+ 		*flags = *flags | TEXT_FORMAT_FLAG_MINUS;
+ 		FORWARD_PARSE_POINT(cp);
+ 	}
+ 
+ 	/* try to parse indirect width */
+ 	if (*cp == '*')
+ 	{
+ 		FORWARD_PARSE_POINT(cp);
+ 
+ 		if (text_format_parse_digits(&cp, end_ptr, &n)){
+ 			/* number in this position should be closed by $ */
+ 			if (*cp != '$')
+ 				ereport(ERROR,
+ 						(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+ 						 errmsg("unexpected char \"%c\".",*cp)));
+ 			FORWARD_PARSE_POINT(cp);
+ 
+ 			/* Explicit 0 for argument index is immediately refused */
+ 			if (n == 0)
+ 				ereport(ERROR,
+ 						(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+ 						 errmsg("conversion specifies argument 0, but arguments are numbered from 1")));
+ 			*widtharg = n;
+ 		}
+ 		else
+ 			*widtharg = 0;  /* 0 means argument position is not specified */
+ 
+ 		return cp;
+ 	}
+ 
+ 	/* last possible number - width */
+ 	if (text_format_parse_digits(&cp, end_ptr, &n))
+ 		*width = n;
+ 
+ 	return cp;
+ }
+ 
  /*
   * Returns a formated string
   */
***************
*** 4016,4021 **** text_format(PG_FUNCTION_ARGS)
--- 4148,4155 ----
  	Oid			element_type = InvalidOid;
  	Oid			prev_type = InvalidOid;
  	FmgrInfo	typoutputfinfo;
+ 	FmgrInfo	typoutputinfo_width;
+ 	Oid			prev_type_width = InvalidOid;
  
  	/* When format string is null, returns null */
  	if (PG_ARGISNULL(0))
***************
*** 4077,4083 **** text_format(PG_FUNCTION_ARGS)
  	}
  
  	/* Setup for main loop. */
! 	fmt = PG_GETARG_TEXT_PP(0);
  	start_ptr = VARDATA_ANY(fmt);
  	end_ptr = start_ptr + VARSIZE_ANY_EXHDR(fmt);
  	initStringInfo(&str);
--- 4211,4217 ----
  	}
  
  	/* Setup for main loop. */
! 	fmt = PG_GETARG_TEXT_PP(arg++);
  	start_ptr = VARDATA_ANY(fmt);
  	end_ptr = start_ptr + VARSIZE_ANY_EXHDR(fmt);
  	initStringInfo(&str);
***************
*** 4085,4093 **** text_format(PG_FUNCTION_ARGS)
  	/* Scan format string, looking for conversion specifiers. */
  	for (cp = start_ptr; cp < end_ptr; cp++)
  	{
! 		Datum		value;
! 		bool		isNull;
! 		Oid			typid;
  
  		/*
  		 * If it's not the start of a conversion specifier, just copy it to
--- 4219,4231 ----
  	/* Scan format string, looking for conversion specifiers. */
  	for (cp = start_ptr; cp < end_ptr; cp++)
  	{
! 		Datum	value;
! 		bool	isNull;
! 		Oid		typid;
! 		int 	valarg;
! 		int		widtharg;
! 		int 	flags;
! 		int 	width;
  
  		/*
  		 * If it's not the start of a conversion specifier, just copy it to
***************
*** 4099,4109 **** text_format(PG_FUNCTION_ARGS)
  			continue;
  		}
  
! 		/* Did we run off the end of the string? */
! 		if (++cp >= end_ptr)
! 			ereport(ERROR,
! 					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
! 					 errmsg("unterminated conversion specifier")));
  
  		/* Easy case: %% outputs a single % */
  		if (*cp == '%')
--- 4237,4243 ----
  			continue;
  		}
  
! 		FORWARD_PARSE_POINT(cp);
  
  		/* Easy case: %% outputs a single % */
  		if (*cp == '%')
***************
*** 4112,4184 **** text_format(PG_FUNCTION_ARGS)
  			continue;
  		}
  
! 		/*
! 		 * If the user hasn't specified an argument position, we just advance
! 		 * to the next one.  If they have, we must parse it.
! 		 */
! 		if (*cp < '0' || *cp > '9')
  		{
! 			++arg;
! 			if (arg <= 0)		/* overflow? */
! 			{
! 				/*
! 				 * Should not happen, as you can't pass billions of arguments
! 				 * to a function, but better safe than sorry.
! 				 */
  				ereport(ERROR,
! 						(errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
! 						 errmsg("argument number is out of range")));
! 			}
! 		}
! 		else
! 		{
! 			bool		unterminated = false;
  
! 			/* Parse digit string. */
! 			arg = 0;
! 			do
  			{
! 				int			newarg = arg * 10 + (*cp - '0');
  
! 				if (newarg / 10 != arg) /* overflow? */
! 					ereport(ERROR,
! 							(errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
! 							 errmsg("argument number is out of range")));
! 				arg = newarg;
! 				++cp;
! 			} while (cp < end_ptr && *cp >= '0' && *cp <= '9');
  
  			/*
! 			 * If we ran off the end, or if there's not a $ next, or if the $
! 			 * is the last character, the conversion specifier is improperly
! 			 * terminated.
  			 */
! 			if (cp == end_ptr || *cp != '$')
! 				unterminated = true;
  			else
  			{
! 				++cp;
! 				if (cp == end_ptr)
! 					unterminated = true;
  			}
! 			if (unterminated)
! 				ereport(ERROR,
! 						(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
! 						 errmsg("unterminated conversion specifier")));
  
! 			/* There's no argument 0. */
! 			if (arg == 0)
  				ereport(ERROR,
! 						(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
! 						 errmsg("conversion specifies argument 0, but arguments are numbered from 1")));
  		}
  
! 		/* Not enough arguments?  Deduct 1 to avoid counting format string. */
! 		if (arg > nargs - 1)
  			ereport(ERROR,
  					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
  					 errmsg("too few arguments for format")));
! 
  		/* Get the value and type of the selected argument */
  		if (!funcvariadic)
  		{
--- 4246,4338 ----
  			continue;
  		}
  
! 		cp = text_format_parse_format(cp, end_ptr,
! 							  &valarg, &widtharg, &flags, &width);
! 
! 		if (widtharg >= 0)
  		{
! 			if (widtharg > 0)
! 				/* be consistent, move ordered argument together with
! 				 * positional */
! 				arg = widtharg;
! 
! 			if (arg >= nargs)
  				ereport(ERROR,
! 						(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
! 						 errmsg("too few arguments for format")));
  
! 			if (!funcvariadic)
  			{
! 				value = PG_GETARG_DATUM(arg);
! 				isNull = PG_ARGISNULL(arg);
! 				typid = get_fn_expr_argtype(fcinfo->flinfo, arg);
! 			}
! 			else
! 			{
! 				value = elements[arg - 1];
! 				isNull = nulls[arg - 1];
! 				typid = element_type;
! 			}
! 			if (!OidIsValid(typid))
! 				elog(ERROR, "could not determine data type of format() input");
  
! 			arg++;
  
  			/*
! 			 * we don't need to different between NULL and zero in this moment,
! 			 * NULL means ignore this width - same as zero.
  			 */
! 			if (isNull)
! 				width = 0;
! 			else if (typid == INT4OID)
! 				width = DatumGetInt32(value);
! 			else if (typid == INT2OID)
! 				width = DatumGetInt16(value);
  			else
  			{
! 				char			*str;
! 
! 				/* simple IO cast to int */
! 				if (typid != prev_type_width)
! 				{
! 					Oid			typoutputfunc;
! 					bool		typIsVarlena;
! 
! 					getTypeOutputInfo(typid, &typoutputfunc, &typIsVarlena);
! 					fmgr_info(typoutputfunc, &typoutputinfo_width);
! 					prev_type_width = typid;
! 				}
! 
! 				/* Stringify. */
! 				str = OutputFunctionCall(&typoutputinfo_width, value);
! 
! 				/* get int value */
! 				width = pg_atoi(str, sizeof(int32), '\0');
! 				pfree(str);
  			}
! 		}
  
! 		/* Overflow check */
! 		if (width != 0)
! 		{
! 			int32 _width = -width;
! 
! 			if (SAMESIGN(width, _width))
  				ereport(ERROR,
! 						(errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
! 						 errmsg("number is out of range")));
  		}
  
! 		if (valarg >= 0)
! 			/* be consistent, move ordered argument together with
! 			 * positional */
! 			arg = valarg;
! 			
! 		if (arg >= nargs)
  			ereport(ERROR,
  					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
  					 errmsg("too few arguments for format")));
! 		
  		/* Get the value and type of the selected argument */
  		if (!funcvariadic)
  		{
***************
*** 4195,4200 **** text_format(PG_FUNCTION_ARGS)
--- 4349,4356 ----
  		if (!OidIsValid(typid))
  			elog(ERROR, "could not determine data type of format() input");
  
+ 		arg++;
+ 
  		/*
  		 * Get the appropriate typOutput function, reusing previous one if
  		 * same type as previous argument.  That's particularly useful in the
***************
*** 4221,4227 **** text_format(PG_FUNCTION_ARGS)
  			case 'I':
  			case 'L':
  				text_format_string_conversion(&str, *cp, &typoutputfinfo,
! 											  value, isNull);
  				break;
  			default:
  				ereport(ERROR,
--- 4377,4384 ----
  			case 'I':
  			case 'L':
  				text_format_string_conversion(&str, *cp, &typoutputfinfo,
! 											  value, isNull,
! 											  flags, width);
  				break;
  			default:
  				ereport(ERROR,
***************
*** 4244,4288 **** text_format(PG_FUNCTION_ARGS)
  	PG_RETURN_TEXT_P(result);
  }
  
  /* Format a %s, %I, or %L conversion. */
  static void
  text_format_string_conversion(StringInfo buf, char conversion,
  							  FmgrInfo *typOutputInfo,
! 							  Datum value, bool isNull)
  {
  	char	   *str;
  
- 	/* Handle NULL arguments before trying to stringify the value. */
  	if (isNull)
  	{
! 		if (conversion == 'L')
! 			appendStringInfoString(buf, "NULL");
  		else if (conversion == 'I')
  			ereport(ERROR,
  					(errcode(ERRCODE_NULL_VALUE_NOT_ALLOWED),
  			errmsg("null values cannot be formatted as an SQL identifier")));
  		return;
  	}
  
- 	/* Stringify. */
  	str = OutputFunctionCall(typOutputInfo, value);
  
  	/* Escape. */
  	if (conversion == 'I')
  	{
  		/* quote_identifier may or may not allocate a new string. */
! 		appendStringInfoString(buf, quote_identifier(str));
  	}
  	else if (conversion == 'L')
! 	{
! 		char	   *qstr = quote_literal_cstr(str);
  
! 		appendStringInfoString(buf, qstr);
  		/* quote_literal_cstr() always allocates a new string */
  		pfree(qstr);
  	}
  	else
! 		appendStringInfoString(buf, str);
  
  	/* Cleanup. */
  	pfree(str);
--- 4401,4490 ----
  	PG_RETURN_TEXT_P(result);
  }
  
+ /*
+  * Add spaces on begin or on end when it is necessary
+  */
+ static void
+ text_format_append_string(StringInfo buf, const char *str,
+ 					  int flags, int width)
+ {
+ 	bool		align_to_left = false;
+ 	int		len;
+ 
+ 	/* fast path */
+ 	if (width == 0)
+ 	{
+ 		appendStringInfoString(buf, str);
+ 		return;
+ 	}
+ 	else if (width < 0 || (flags & TEXT_FORMAT_FLAG_MINUS))
+ 	{
+ 		align_to_left = true;
+ 		if (width < 0)
+ 			width = -width;
+ 	}
+ 
+ 	len = pg_mbstrlen(str);
+ 	if (align_to_left)
+ 	{
+ 		appendStringInfoString(buf, str);
+ 		if (len < width)
+ 			appendStringInfoSpaces(buf, width - len);
+ 	}
+ 	else
+ 	{
+ 		/* align_to_right */
+ 		if (len < width)
+ 			appendStringInfoSpaces(buf, width - len);
+ 		appendStringInfoString(buf, str);
+ 	}
+ }
+ 
  /* Format a %s, %I, or %L conversion. */
  static void
  text_format_string_conversion(StringInfo buf, char conversion,
  							  FmgrInfo *typOutputInfo,
! 							  Datum value, bool isNull,
! 							  int flags, int width)
  {
  	char	   *str;
  
  	if (isNull)
  	{
! 		if (conversion == 's')
! 			text_format_append_string(buf, "",
! 								flags, width);
! 		else if (conversion == 'L')
! 			text_format_append_string(buf, "NULL",
! 								flags, width);
  		else if (conversion == 'I')
  			ereport(ERROR,
  					(errcode(ERRCODE_NULL_VALUE_NOT_ALLOWED),
  			errmsg("null values cannot be formatted as an SQL identifier")));
+ 
  		return;
  	}
  
  	str = OutputFunctionCall(typOutputInfo, value);
  
  	/* Escape. */
  	if (conversion == 'I')
  	{
  		/* quote_identifier may or may not allocate a new string. */
! 		text_format_append_string(buf, quote_identifier(str),
! 							flags, width);
  	}
  	else if (conversion == 'L')
! 	{		char	   *qstr = quote_literal_cstr(str);
  
! 		text_format_append_string(buf, qstr,
! 							flags, width);
  		/* quote_literal_cstr() always allocates a new string */
  		pfree(qstr);
  	}
  	else
! 		text_format_append_string(buf, str,
! 							flags, width);
  
  	/* Cleanup. */
  	pfree(str);
*** a/src/test/regress/expected/text.out
--- b/src/test/regress/expected/text.out
***************
*** 256,267 **** select format('%1$s %4$s', 1, 2, 3);
  ERROR:  too few arguments for format
  select format('%1$s %13$s', 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12);
  ERROR:  too few arguments for format
  select format('%1s', 1);
! ERROR:  unterminated conversion specifier
  select format('%1$', 1);
  ERROR:  unterminated conversion specifier
  select format('%1$1', 1);
! ERROR:  unrecognized conversion specifier "1"
  -- check mix of positional and ordered placeholders
  select format('Hello %s %1$s %s', 'World', 'Hello again');
              format             
--- 256,275 ----
  ERROR:  too few arguments for format
  select format('%1$s %13$s', 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12);
  ERROR:  too few arguments for format
+ select format('%0$s', 'Hello');
+ ERROR:  conversion specifies argument 0, but arguments are numbered from 1
+ select format('%*0$s', 'Hello');
+ ERROR:  conversion specifies argument 0, but arguments are numbered from 1
  select format('%1s', 1);
!  format 
! --------
!  1
! (1 row)
! 
  select format('%1$', 1);
  ERROR:  unterminated conversion specifier
  select format('%1$1', 1);
! ERROR:  unterminated conversion specifier
  -- check mix of positional and ordered placeholders
  select format('Hello %s %1$s %s', 'World', 'Hello again');
              format             
***************
*** 328,330 **** from generate_series(1,200) g(i);
--- 336,409 ----
   1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,160,161,162,163,164,165,166,167,168,169,170,171,172,173,174,175,176,177,178,179,180,181,182,183,184,185,186,187,188,189,190,191,192,193,194,195,196,197,198,199,200
  (1 row)
  
+ -- left, right align
+ select format('>>%10s<<', 'Hello')
+ union all
+ select format('>>%10s<<', NULL)
+ union all
+ select format('>>%10s<<', '')
+ union all
+ select format('>>%-10s<<', '')
+ union all
+ select format('>>%-10s<<', 'Hello')
+ union all
+ select format('>>%-10s<<', NULL)
+ union all
+ select format('>>%1$10s<<', 'Hello')
+ union all
+ select format('>>%1$-10I<<', 'Hello')
+ union all
+ select format('>>%2$*1$L<<', 10, 'Hello')
+ union all
+ select format('>>%2$*1$L<<', 10, NULL)
+ union all
+ select format('>>%2$*1$L<<', -10, NULL)
+ union all
+ select format('>>%*s<<', 10, 'Hello');
+      format     
+ ----------------
+  >>     Hello<<
+  >>          <<
+  >>          <<
+  >>          <<
+  >>Hello     <<
+  >>          <<
+  >>     Hello<<
+  >>"Hello"   <<
+  >>   'Hello'<<
+  >>      NULL<<
+  >>NULL      <<
+  >>     Hello<<
+ (12 rows)
+ 
+ select format('>>%*1$s<<', 10, 'Hello');
+      format     
+ ----------------
+  >>     Hello<<
+ (1 row)
+ 
+ select format('>>%-s<<', 'Hello');
+   format   
+ -----------
+  >>Hello<<
+ (1 row)
+ 
+ -- NULL is not different to zero here
+ select format('>>%10L<<', NULL);
+      format     
+ ----------------
+  >>      NULL<<
+ (1 row)
+ 
+ select format('>>%2$*1$L<<', NULL, 'Hello');
+    format    
+ -------------
+  >>'Hello'<<
+ (1 row)
+ 
+ select format('>>%2$*1$L<<', 0, 'Hello');
+    format    
+ -------------
+  >>'Hello'<<
+ (1 row)
+ 
*** a/src/test/regress/sql/text.sql
--- b/src/test/regress/sql/text.sql
***************
*** 78,83 **** select format('%1$s %12$s', 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12);
--- 78,85 ----
  -- should fail
  select format('%1$s %4$s', 1, 2, 3);
  select format('%1$s %13$s', 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12);
+ select format('%0$s', 'Hello');
+ select format('%*0$s', 'Hello');
  select format('%1s', 1);
  select format('%1$', 1);
  select format('%1$1', 1);
***************
*** 97,99 **** select format('Hello', variadic NULL);
--- 99,134 ----
  -- variadic argument allows simulating more than FUNC_MAX_ARGS parameters
  select format(string_agg('%s',','), variadic array_agg(i))
  from generate_series(1,200) g(i);
+ 
+ -- left, right align
+ select format('>>%10s<<', 'Hello')
+ union all
+ select format('>>%10s<<', NULL)
+ union all
+ select format('>>%10s<<', '')
+ union all
+ select format('>>%-10s<<', '')
+ union all
+ select format('>>%-10s<<', 'Hello')
+ union all
+ select format('>>%-10s<<', NULL)
+ union all
+ select format('>>%1$10s<<', 'Hello')
+ union all
+ select format('>>%1$-10I<<', 'Hello')
+ union all
+ select format('>>%2$*1$L<<', 10, 'Hello')
+ union all
+ select format('>>%2$*1$L<<', 10, NULL)
+ union all
+ select format('>>%2$*1$L<<', -10, NULL)
+ union all
+ select format('>>%*s<<', 10, 'Hello');
+ 
+ select format('>>%*1$s<<', 10, 'Hello');
+ select format('>>%-s<<', 'Hello');
+ 
+ -- NULL is not different to zero here
+ select format('>>%10L<<', NULL);
+ select format('>>%2$*1$L<<', NULL, 'Hello');
+ select format('>>%2$*1$L<<', 0, 'Hello');

diff --git a/doc/src/sgml/func.sgml b/doc/src/sgml/func.sgml
index 9b7e967..b2d2ed6 100644
--- a/doc/src/sgml/func.sgml
+++ b/doc/src/sgml/func.sgml
@@ -1519,21 +1519,13 @@
          <primary>format</primary>
         </indexterm>
         <literal><function>format</function>(<parameter>formatstr</parameter> <type>text</type>
-        [, <parameter>str</parameter> <type>"any"</type> [, ...] ])</literal>
+        [, <parameter>formatarg</parameter> <type>"any"</type> [, ...] ])</literal>
        </entry>
        <entry><type>text</type></entry>
        <entry>
          Format arguments according to a format string.
-         This function is similar to the C function
-         <function>sprintf</>, but only the following conversion specifications
-         are recognized: <literal>%s</literal> interpolates the corresponding
-         argument as a string; <literal>%I</literal> escapes its argument as
-         an SQL identifier; <literal>%L</literal> escapes its argument as an
-         SQL literal; <literal>%%</literal> outputs a literal <literal>%</>.
-         A conversion can reference an explicit parameter position by preceding
-         the conversion specifier with <literal><replaceable>n</>$</>, where
-         <replaceable>n</replaceable> is the argument position.
-         See also <xref linkend="plpgsql-quote-literal-example">.
+         This function is similar to the C function <function>sprintf</>.
+         See <xref linkend="functions-string-format">.
        </entry>
        <entry><literal>format('Hello %s, %1$s', 'World')</literal></entry>
        <entry><literal>Hello World, World</literal></entry>
@@ -2847,6 +2839,186 @@
     </tgroup>
    </table>
 
+   <sect2 id="functions-string-format">
+    <title><function>format</function></title>
+
+    <indexterm>
+     <primary>format</primary>
+    </indexterm>
+
+    <para>
+     The function <function>format</> produces formatted output according to
+     a format string in a similar way to the C function <function>sprintf</>.
+    </para>
+
+    <para>
+<synopsis>
+format(<parameter>formatstr</> <type>text</> [, <parameter>formatarg</> <type>"any"</> [, ...] ])
+</synopsis>
+     <replaceable>formatstr</> is a format string that specifies how the
+     result should be formatted.  Text in the format string is copied directly
+     to the result, except where <firstterm>format specifiers</> are used.
+     Format specifiers act as placeholders in the string, allowing subsequent
+     function arguments to be formatted and inserted into the result.
+    </para>
+
+    <para>
+     Format specifiers are introduced by a <literal>%</> character and take
+     the form
+<synopsis>
+%[<replaceable>parameter</>][<replaceable>flags</>][<replaceable>width</>]<replaceable>type</>
+</synopsis>
+     <variablelist>
+      <varlistentry>
+       <term><replaceable>parameter</replaceable> (optional)</term>
+       <listitem>
+        <para>
+         An expression of the form <literal><replaceable>n</>$</> where
+         <replaceable>n</> is the index of the argument to use for the format
+         specifier's value.  An index of 1 means the first argument after
+         <replaceable>formatstr</>.  If the <replaceable>parameter</> field is
+         omitted, the default is to use the next argument.
+        </para>
+<screen>
+SELECT format('Testing %s, %s, %s', 'one', 'two', 'three');
+<lineannotation>Result: </><computeroutput>Testing one, two, three</>
+
+SELECT format('Testing %3$s, %2$s, %1$s', 'one', 'two', 'three');
+<lineannotation>Result: </><computeroutput>Testing three, two, one</>
+</screen>
+
+        <para>
+         Note that unlike the C function <function>sprintf</> defined in the
+         Single UNIX Specification, the <function>format</> function in
+         <productname>PostgreSQL</> allows format specifiers with and without
+         explicit <replaceable>parameter</> fields to be mixed in the same
+         format string.  A format specifier without a
+         <replaceable>parameter</> field always uses the next argument after
+         the last argument consumed.  In addition, the
+         <productname>PostgreSQL</> <function>format</> function does not
+         require all function arguments to be referred to in the format
+         string.
+        </para>
+<screen>
+SELECT format('Testing %3$s, %2$s, %s', 'one', 'two', 'three');
+<lineannotation>Result: </><computeroutput>Testing three, two, three</>
+</screen>
+       </listitem>
+      </varlistentry>
+
+      <varlistentry>
+       <term><replaceable>flags</replaceable> (optional)</term>
+       <listitem>
+        <para>
+         Additional options controlling how the format specifier's output is
+         formatted.  Currently the only supported flag is an minus sign
+         (<literal>-</>) which will cause the format specifier's output to be
+         left-aligned.  This has no effect unless the <replaceable>width</>
+         field is also specified.
+        </para>
+<screen>
+SELECT format('|%10s|%-10s|', 'foo', 'bar');
+<lineannotation>Result: </><computeroutput>|       foo|bar       |</>
+</screen>
+       </listitem>
+      </varlistentry>
+
+      <varlistentry>
+       <term><replaceable>width</replaceable> (optional)</term>
+       <listitem>
+        <para>
+         Specifies the <emphasis>minimum</> number of characters to use to
+         display the format specifier's output.  The width may be specified
+         using any of the following: a positive integer; an asterisk
+         (<literal>*</>) to use the next function argument as the width; or an
+         expression of the form <literal>*<replaceable>n</>$</> to use the
+         <replaceable>n</>th function argument as the width.
+        </para>
+
+        <para>
+         If the width comes from a function argument, that argument is
+         consumed <emphasis>before</> the argument that is used for the format
+         specifier's value.  If the width argument is negative, the result is
+         left aligned, as if the <literal>-</> flag had been specified.
+        </para>
+<screen>
+SELECT format('|%10s|', 'foo');
+<lineannotation>Result: </><computeroutput>|       foo|</>
+
+SELECT format('|%*s|', 10, 'foo');
+<lineannotation>Result: </><computeroutput>|       foo|</>
+
+SELECT format('|%*s|', -10, 'foo');
+<lineannotation>Result: </><computeroutput>|foo       |</>
+
+SELECT format('|%-*s|', 10, 'foo');
+<lineannotation>Result: </><computeroutput>|foo       |</>
+
+SELECT format('|%-*s|', -10, 'foo');
+<lineannotation>Result: </><computeroutput>|foo       |</>
+
+SELECT format('|%*2$s|', 'foo', 10, 'bar');
+<lineannotation>Result: </><computeroutput>|       bar|</>
+
+SELECT format('|%3$*2$s|', 'foo', 10, 'bar');
+<lineannotation>Result: </><computeroutput>|       bar|</>
+</screen>
+       </listitem>
+      </varlistentry>
+
+      <varlistentry>
+       <term><replaceable>type</replaceable> (required)</term>
+       <listitem>
+        <para>
+         The type of format conversion to use to produce the format
+         specifier's output.  The following types are supported:
+         <itemizedlist>
+          <listitem>
+           <para>
+            <literal>s</literal> formats the argument value as a simple
+            string.  A null value is treated as an empty string.
+           </para>
+          </listitem>
+          <listitem>
+           <para>
+            <literal>I</literal> escapes the value as an SQL identifier.  It
+            is an error for the value to be null.
+           </para>
+          </listitem>
+          <listitem>
+           <para>
+            <literal>L</literal> escapes the value as an SQL literal.  A null
+            value is displayed as the literal value <literal>NULL</>.
+           </para>
+          </listitem>
+         </itemizedlist>
+        </para>
+<screen>
+SELECT format('Hello %s', 'World');
+<lineannotation>Result: </lineannotation><computeroutput>Hello World</computeroutput>
+
+SELECT format('DROP TABLE %I', 'Foo bar');
+<lineannotation>Result: </lineannotation><computeroutput>DROP TABLE "Foo bar"</computeroutput>
+
+SELECT format('SELECT %L', E'O\'Reilly');
+<lineannotation>Result: </lineannotation><computeroutput>SELECT 'O''Reilly'</computeroutput>
+</screen>
+
+        <para>
+         The <literal>%I</> and <literal>%L</> format specifiers may be used
+         to safely construct dynamic SQL statements.  See
+         <xref linkend="plpgsql-quote-literal-example">.
+        </para>
+       </listitem>
+      </varlistentry>
+     </variablelist>
+    </para>
+
+    <para>
+     In addition to the format specifiers above, the special escape sequence
+     <literal>%%</> may be used to output a literal <literal>%</> character.
+    </para>
+   </sect2>
   </sect1>
 
 
diff --git a/src/backend/utils/adt/varlena.c b/src/backend/utils/adt/varlena.c
index e69b7dd..19b8049 100644
--- a/src/backend/utils/adt/varlena.c
+++ b/src/backend/utils/adt/varlena.c
@@ -78,7 +78,8 @@ static bytea *bytea_overlay(bytea *t1, bytea *t2, int sp, int sl);
 static StringInfo makeStringAggState(FunctionCallInfo fcinfo);
 static void text_format_string_conversion(StringInfo buf, char conversion,
 							  FmgrInfo *typOutputInfo,
-							  Datum value, bool isNull);
+							  Datum value, bool isNull,
+							  int flags, int width);
 static Datum text_to_array_internal(PG_FUNCTION_ARGS);
 static text *array_to_text_internal(FunctionCallInfo fcinfo, ArrayType *v,
 					   const char *fldsep, const char *null_string);
@@ -3996,6 +3997,135 @@ text_reverse(PG_FUNCTION_ARGS)
 	PG_RETURN_TEXT_P(result);
 }
 
+#define FORWARD_PARSE_POINT(ptr) \
+do { \
+	if (++(ptr) >= (end_ptr)) \
+		ereport(ERROR, \
+				(errcode(ERRCODE_INVALID_PARAMETER_VALUE), \
+				 errmsg("unterminated conversion specifier"))); \
+} while (0)
+
+/*
+ * Parse congiguous digits into decimal number.
+ *
+ * Returns true if some digits could be parsed and *ptr moved to the next
+ * character to be parsed. The value is returned into *value.
+ */
+static bool
+text_format_parse_digits(const char **ptr, const char *end_ptr, int *value)
+{
+	const char *cp = *ptr;
+	int wval = 0;
+	bool found;
+
+	/*
+	 * continue, only when start_ptr is less than end_ptr.
+	 * Overrun of cp is checked in FORWARD_PARSE_POINT.
+	 */
+	while (*cp >= '0' && *cp <= '9')
+	{
+		int	newnum = wval * 10 + (*cp - '0');
+
+		if (newnum / 10 != wval) /* overflow? */
+			ereport(ERROR,
+					(errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
+					 errmsg("number is out of range")));
+		wval = newnum;
+		FORWARD_PARSE_POINT(cp);
+	}
+
+	found = (cp > *ptr);
+	*value = wval;
+	*ptr = cp;
+
+	return found;
+}
+
+#define TEXT_FORMAT_FLAG_MINUS	0x0001			/* is minus in format string? */
+
+/*
+ * parse format specification
+ *             [argpos][flags][width]type
+ *
+ * Return values are,
+ *   static const char * : Address to be parsed next.
+ *   valarg   : argument position for value to be printed. -1 means missing.
+ *   widtharg : argument position for width. Zero means that argument position
+ *              is not specified and -1 means missing.
+ *   flags    : flags
+ *   width    : the value for direct width specification, zero means that width
+ *              is not specified.
+ */
+static const char *
+text_format_parse_format(const char *start_ptr, const char *end_ptr,
+						 int *valarg, int *widtharg, int *flags, int *width)
+{
+	const char *cp = start_ptr;
+	int	   n;
+
+	/* set defaults to out parameters */
+	*valarg =  -1;
+	*widtharg = -1;
+	*flags = 0;
+	*width = 0;
+
+	/* try to identify first number */
+	if (text_format_parse_digits(&cp, end_ptr, &n))
+	{
+		if (*cp != '$')
+		{
+			*width = n;    /* The number should be width */
+			return cp;
+		}
+		/* Explicit 0 for argument index is immediately refused */
+		if (n == 0)
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+					 errmsg("conversion specifies argument 0, but arguments are numbered from 1")));
+		*valarg = n;   /* The number was argument position  */
+		FORWARD_PARSE_POINT(cp);
+	}
+
+	/* Check for flags, only minus is supported now. */
+	while (*cp == '-')
+	{
+		*flags = *flags | TEXT_FORMAT_FLAG_MINUS;
+		FORWARD_PARSE_POINT(cp);
+	}
+
+	/* try to parse indirect width */
+	if (*cp == '*')
+	{
+		FORWARD_PARSE_POINT(cp);
+
+		if (text_format_parse_digits(&cp, end_ptr, &n)){
+			/* number in this position should be closed by $ */
+			if (*cp != '$')
+				ereport(ERROR,
+						(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+						 errmsg("unexpected char \"%c\".",*cp)));
+			FORWARD_PARSE_POINT(cp);
+
+			/* Explicit 0 for argument index is immediately refused */
+			if (n == 0)
+				ereport(ERROR,
+						(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+						 errmsg("conversion specifies argument 0, but arguments are numbered from 1")));
+			*widtharg = n;
+		}
+		else
+			*widtharg = 0;  /* 0 means argument position is not specified */
+
+		return cp;
+	}
+
+	/* last possible number - width */
+	if (text_format_parse_digits(&cp, end_ptr, &n))
+		*width = n;
+
+	return cp;
+}
+
 /*
  * Returns a formated string
  */
@@ -4016,6 +4146,8 @@ text_format(PG_FUNCTION_ARGS)
 	Oid			element_type = InvalidOid;
 	Oid			prev_type = InvalidOid;
 	FmgrInfo	typoutputfinfo;
+	FmgrInfo	typoutputinfo_width;
+	Oid			prev_type_width = InvalidOid;
 
 	/* When format string is null, returns null */
 	if (PG_ARGISNULL(0))
@@ -4077,7 +4209,7 @@ text_format(PG_FUNCTION_ARGS)
 	}
 
 	/* Setup for main loop. */
-	fmt = PG_GETARG_TEXT_PP(0);
+	fmt = PG_GETARG_TEXT_PP(arg++);
 	start_ptr = VARDATA_ANY(fmt);
 	end_ptr = start_ptr + VARSIZE_ANY_EXHDR(fmt);
 	initStringInfo(&str);
@@ -4088,6 +4220,10 @@ text_format(PG_FUNCTION_ARGS)
 		Datum		value;
 		bool		isNull;
 		Oid			typid;
+		int 		valarg;
+		int			widtharg;
+		int 		flags;
+		int 		width;
 
 		/*
 		 * If it's not the start of a conversion specifier, just copy it to
@@ -4099,11 +4235,7 @@ text_format(PG_FUNCTION_ARGS)
 			continue;
 		}
 
-		/* Did we run off the end of the string? */
-		if (++cp >= end_ptr)
-			ereport(ERROR,
-					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
-					 errmsg("unterminated conversion specifier")));
+		FORWARD_PARSE_POINT(cp);
 
 		/* Easy case: %% outputs a single % */
 		if (*cp == '%')
@@ -4112,69 +4244,84 @@ text_format(PG_FUNCTION_ARGS)
 			continue;
 		}
 
-		/*
-		 * If the user hasn't specified an argument position, we just advance
-		 * to the next one.  If they have, we must parse it.
-		 */
-		if (*cp < '0' || *cp > '9')
+		cp = text_format_parse_format(cp, end_ptr,
+							  &valarg, &widtharg, &flags, &width);
+
+		if (widtharg >= 0)
 		{
-			++arg;
-			if (arg <= 0)		/* overflow? */
-			{
-				/*
-				 * Should not happen, as you can't pass billions of arguments
-				 * to a function, but better safe than sorry.
-				 */
+			if (widtharg > 0)
+				/* be consistent, move ordered argument together with
+				 * positional */
+				arg = widtharg;
+
+			if (arg >= nargs)
 				ereport(ERROR,
-						(errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
-						 errmsg("argument number is out of range")));
-			}
-		}
-		else
-		{
-			bool		unterminated = false;
+						(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+						 errmsg("too few arguments for format")));
 
-			/* Parse digit string. */
-			arg = 0;
-			do
+			if (!funcvariadic)
 			{
-				int			newarg = arg * 10 + (*cp - '0');
+				value = PG_GETARG_DATUM(arg);
+				isNull = PG_ARGISNULL(arg);
+				typid = get_fn_expr_argtype(fcinfo->flinfo, arg);
+			}
+			else
+			{
+				value = elements[arg - 1];
+				isNull = nulls[arg - 1];
+				typid = element_type;
+			}
+			if (!OidIsValid(typid))
+				elog(ERROR, "could not determine data type of format() input");
 
-				if (newarg / 10 != arg) /* overflow? */
-					ereport(ERROR,
-							(errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
-							 errmsg("argument number is out of range")));
-				arg = newarg;
-				++cp;
-			} while (cp < end_ptr && *cp >= '0' && *cp <= '9');
+			arg++;
 
 			/*
-			 * If we ran off the end, or if there's not a $ next, or if the $
-			 * is the last character, the conversion specifier is improperly
-			 * terminated.
+			 * we don't need to different between NULL and zero in this moment,
+			 * NULL means ignore this width - same as zero.
 			 */
-			if (cp == end_ptr || *cp != '$')
-				unterminated = true;
+			if (isNull)
+				width = 0;
+			else if (typid == INT4OID)
+				width = DatumGetInt32(value);
+			else if (typid == INT2OID)
+				width = DatumGetInt16(value);
 			else
 			{
-				++cp;
-				if (cp == end_ptr)
-					unterminated = true;
-			}
-			if (unterminated)
-				ereport(ERROR,
-						(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
-						 errmsg("unterminated conversion specifier")));
+				char			*str;
 
-			/* There's no argument 0. */
-			if (arg == 0)
-				ereport(ERROR,
-						(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
-						 errmsg("conversion specifies argument 0, but arguments are numbered from 1")));
+				/* simple IO cast to int */
+				if (typid != prev_type_width)
+				{
+					Oid			typoutputfunc;
+					bool		typIsVarlena;
+
+					getTypeOutputInfo(typid, &typoutputfunc, &typIsVarlena);
+					fmgr_info(typoutputfunc, &typoutputinfo_width);
+					prev_type_width = typid;
+				}
+
+				/* Stringify. */
+				str = OutputFunctionCall(&typoutputinfo_width, value);
+
+				/* get int value */
+				width = pg_atoi(str, sizeof(int32), '\0');
+				pfree(str);
+			}
 		}
 
-		/* Not enough arguments?  Deduct 1 to avoid counting format string. */
-		if (arg > nargs - 1)
+		/* We calculate -width later but -INT_MIN is undefined for int. */
+		if (width <= INT_MIN)
+			ereport(ERROR,
+					(errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
+					 errmsg("number is out of range")));
+
+		if (valarg >= 0)
+			/* be consistent, move ordered argument together with
+			 * positional */
+			arg = valarg;
+			
+		if (arg >= nargs)
 			ereport(ERROR,
 					(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
 					 errmsg("too few arguments for format")));
@@ -4195,6 +4342,8 @@ text_format(PG_FUNCTION_ARGS)
 		if (!OidIsValid(typid))
 			elog(ERROR, "could not determine data type of format() input");
 
+		arg++;
+
 		/*
 		 * Get the appropriate typOutput function, reusing previous one if
 		 * same type as previous argument.  That's particularly useful in the
@@ -4221,7 +4370,7 @@ text_format(PG_FUNCTION_ARGS)
 			case 'I':
 			case 'L':
 				text_format_string_conversion(&str, *cp, &typoutputfinfo,
-											  value, isNull);
+											  value, isNull, flags, width);
 				break;
 			default:
 				ereport(ERROR,
@@ -4244,23 +4393,65 @@ text_format(PG_FUNCTION_ARGS)
 	PG_RETURN_TEXT_P(result);
 }
 
+/*
+ * Add spaces on begin or on end when it is necessary
+ */
+static void
+text_format_append_string(StringInfo buf, const char *str,
+					  int flags, int width)
+{
+	bool		align_to_left = false;
+	int		len;
+
+	/* fast path */
+	if (width == 0)
+	{
+		appendStringInfoString(buf, str);
+		return;
+	}
+	else if (width < 0 || (flags & TEXT_FORMAT_FLAG_MINUS))
+	{
+		align_to_left = true;
+		if (width < 0)
+			width = -width;
+	}
+
+	len = pg_mbstrlen(str);
+	if (align_to_left)
+	{
+		appendStringInfoString(buf, str);
+		if (len < width)
+			appendStringInfoSpaces(buf, width - len);
+	}
+	else
+	{
+		/* align_to_right */
+		if (len < width)
+			appendStringInfoSpaces(buf, width - len);
+		appendStringInfoString(buf, str);
+	}
+}
+
 /* Format a %s, %I, or %L conversion. */
 static void
 text_format_string_conversion(StringInfo buf, char conversion,
 							  FmgrInfo *typOutputInfo,
-							  Datum value, bool isNull)
+							  Datum value, bool isNull,
+							  int flags, int width)
 {
 	char	   *str;
 
-	/* Handle NULL arguments before trying to stringify the value. */
 	if (isNull)
 	{
-		if (conversion == 'L')
-			appendStringInfoString(buf, "NULL");
+		if (conversion == 's')
+			text_format_append_string(buf, "", flags, width);
+		else if (conversion == 'L')
+			text_format_append_string(buf, "NULL", flags, width);
 		else if (conversion == 'I')
 			ereport(ERROR,
 					(errcode(ERRCODE_NULL_VALUE_NOT_ALLOWED),
 			errmsg("null values cannot be formatted as an SQL identifier")));
+
 		return;
 	}
 
@@ -4271,18 +4462,18 @@ text_format_string_conversion(StringInfo buf, char conversion,
 	if (conversion == 'I')
 	{
 		/* quote_identifier may or may not allocate a new string. */
-		appendStringInfoString(buf, quote_identifier(str));
+		text_format_append_string(buf, quote_identifier(str), flags, width);
 	}
 	else if (conversion == 'L')
 	{
 		char	   *qstr = quote_literal_cstr(str);
 
-		appendStringInfoString(buf, qstr);
+		text_format_append_string(buf, qstr, flags, width);
 		/* quote_literal_cstr() always allocates a new string */
 		pfree(qstr);
 	}
 	else
-		appendStringInfoString(buf, str);
+		text_format_append_string(buf, str, flags, width);
 
 	/* Cleanup. */
 	pfree(str);
diff --git a/src/test/regress/expected/text.out b/src/test/regress/expected/text.out
index b756583..e05a1e5 100644
--- a/src/test/regress/expected/text.out
+++ b/src/test/regress/expected/text.out
@@ -256,12 +256,20 @@ select format('%1$s %4$s', 1, 2, 3);
 ERROR:  too few arguments for format
 select format('%1$s %13$s', 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12);
 ERROR:  too few arguments for format
+select format('%0$s', 'Hello');
+ERROR:  conversion specifies argument 0, but arguments are numbered from 1
+select format('%*0$s', 'Hello');
+ERROR:  conversion specifies argument 0, but arguments are numbered from 1
 select format('%1s', 1);
-ERROR:  unterminated conversion specifier
+ format 
+--------
+ 1
+(1 row)
+
 select format('%1$', 1);
 ERROR:  unterminated conversion specifier
 select format('%1$1', 1);
-ERROR:  unrecognized conversion specifier "1"
+ERROR:  unterminated conversion specifier
 -- check mix of positional and ordered placeholders
 select format('Hello %s %1$s %s', 'World', 'Hello again');
             format             
@@ -328,3 +336,74 @@ from generate_series(1,200) g(i);
  1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,160,161,162,163,164,165,166,167,168,169,170,171,172,173,174,175,176,177,178,179,180,181,182,183,184,185,186,187,188,189,190,191,192,193,194,195,196,197,198,199,200
 (1 row)
 
+-- left, right align
+select format('>>%10s<<', 'Hello')
+union all
+select format('>>%10s<<', NULL)
+union all
+select format('>>%10s<<', '')
+union all
+select format('>>%-10s<<', '')
+union all
+select format('>>%-10s<<', 'Hello')
+union all
+select format('>>%-10s<<', NULL)
+union all
+select format('>>%1$10s<<', 'Hello')
+union all
+select format('>>%1$-10I<<', 'Hello')
+union all
+select format('>>%2$*1$L<<', 10, 'Hello')
+union all
+select format('>>%2$*1$L<<', 10, NULL)
+union all
+select format('>>%2$*1$L<<', -10, NULL)
+union all
+select format('>>%*s<<', 10, 'Hello');
+     format     
+----------------
+ >>     Hello<<
+ >>          <<
+ >>          <<
+ >>          <<
+ >>Hello     <<
+ >>          <<
+ >>     Hello<<
+ >>"Hello"   <<
+ >>   'Hello'<<
+ >>      NULL<<
+ >>NULL      <<
+ >>     Hello<<
+(12 rows)
+
+select format('>>%*1$s<<', 10, 'Hello');
+     format     
+----------------
+ >>     Hello<<
+(1 row)
+
+select format('>>%-s<<', 'Hello');
+  format   
+-----------
+ >>Hello<<
+(1 row)
+
+-- NULL is not different to zero here
+select format('>>%10L<<', NULL);
+     format     
+----------------
+ >>      NULL<<
+(1 row)
+
+select format('>>%2$*1$L<<', NULL, 'Hello');
+   format    
+-------------
+ >>'Hello'<<
+(1 row)
+
+select format('>>%2$*1$L<<', 0, 'Hello');
+   format    
+-------------
+ >>'Hello'<<
+(1 row)
+
diff --git a/src/test/regress/sql/text.sql b/src/test/regress/sql/text.sql
index a96e9f7..1c68754 100644
--- a/src/test/regress/sql/text.sql
+++ b/src/test/regress/sql/text.sql
@@ -78,6 +78,8 @@ select format('%1$s %12$s', 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12);
 -- should fail
 select format('%1$s %4$s', 1, 2, 3);
 select format('%1$s %13$s', 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12);
+select format('%0$s', 'Hello');
+select format('%*0$s', 'Hello');
 select format('%1s', 1);
 select format('%1$', 1);
 select format('%1$1', 1);
@@ -97,3 +99,36 @@ select format('Hello', variadic NULL);
 -- variadic argument allows simulating more than FUNC_MAX_ARGS parameters
 select format(string_agg('%s',','), variadic array_agg(i))
 from generate_series(1,200) g(i);
+
+-- left, right align
+select format('>>%10s<<', 'Hello')
+union all
+select format('>>%10s<<', NULL)
+union all
+select format('>>%10s<<', '')
+union all
+select format('>>%-10s<<', '')
+union all
+select format('>>%-10s<<', 'Hello')
+union all
+select format('>>%-10s<<', NULL)
+union all
+select format('>>%1$10s<<', 'Hello')
+union all
+select format('>>%1$-10I<<', 'Hello')
+union all
+select format('>>%2$*1$L<<', 10, 'Hello')
+union all
+select format('>>%2$*1$L<<', 10, NULL)
+union all
+select format('>>%2$*1$L<<', -10, NULL)
+union all
+select format('>>%*s<<', 10, 'Hello');
+
+select format('>>%*1$s<<', 10, 'Hello');
+select format('>>%-s<<', 'Hello');
+
+-- NULL is not different to zero here
+select format('>>%10L<<', NULL);
+select format('>>%2$*1$L<<', NULL, 'Hello');
+select format('>>%2$*1$L<<', 0, 'Hello');