<!--
$PostgreSQL: pgsql/doc/src/sgml/ref/create_user.sgml,v 1.41 2008/11/14 10:22:46 petere Exp $
PostgreSQL documentation
-->

<refentry id="SQL-CREATEUSER">
 <refmeta>
  <refentrytitle id="sql-createuser-title">CREATE USER</refentrytitle>
  <manvolnum>7</manvolnum>
  <refmiscinfo>SQL - Language Statements</refmiscinfo>
 </refmeta>

 <refnamediv>
  <refname>CREATE USER</refname>
  <refpurpose>define a new database role</refpurpose>
 </refnamediv>

 <indexterm zone="sql-createuser">
  <primary>CREATE USER</primary>
 </indexterm>

 <refsynopsisdiv>
<synopsis>
CREATE USER <replaceable class="PARAMETER">name</replaceable> [ [ WITH ] <replaceable class="PARAMETER">option</replaceable> [ ... ] ]

where <replaceable class="PARAMETER">option</replaceable> can be:
    
      SUPERUSER | NOSUPERUSER
    | CREATEDB | NOCREATEDB
    | CREATEROLE | NOCREATEROLE
    | CREATEUSER | NOCREATEUSER
    | INHERIT | NOINHERIT
    | LOGIN | NOLOGIN
    | CONNECTION LIMIT <replaceable class="PARAMETER">connlimit</replaceable>
    | [ ENCRYPTED | UNENCRYPTED ] PASSWORD '<replaceable class="PARAMETER">password</replaceable>'
    | VALID UNTIL '<replaceable class="PARAMETER">timestamp</replaceable>' 
    | IN ROLE <replaceable class="PARAMETER">rolename</replaceable> [, ...]
    | IN GROUP <replaceable class="PARAMETER">rolename</replaceable> [, ...]
    | ROLE <replaceable class="PARAMETER">rolename</replaceable> [, ...]
    | ADMIN <replaceable class="PARAMETER">rolename</replaceable> [, ...]
    | USER <replaceable class="PARAMETER">rolename</replaceable> [, ...]
    | SYSID <replaceable class="PARAMETER">uid</replaceable> 
    | RESOURCE QUEUE <replaceable class="PARAMETER">queuename</replaceable>
</synopsis>
 </refsynopsisdiv>

 <refsect1>
  <title>Description</title>

  <para>
   <command>CREATE USER</command> is now an alias for
   <xref linkend="sql-createrole" endterm="sql-createrole-title">.
   The only difference is that when the command is spelled
   <command>CREATE USER</command>, <literal>LOGIN</> is assumed
   by default, whereas <literal>NOLOGIN</> is assumed when
   the command is spelled
   <command>CREATE ROLE</command>.
  </para>
 </refsect1>
 
 <refsect1>
  <title>Compatibility</title>
  
  <para>
   The <command>CREATE USER</command> statement is a
   <productname>PostgreSQL</productname> extension.  The SQL standard
   leaves the definition of users to the implementation.
  </para>
 </refsect1>

 <refsect1>
  <title>See Also</title>

  <simplelist type="inline">
   <member><xref linkend="sql-createrole" endterm="sql-createrole-title"></member>
  </simplelist>
 </refsect1>
</refentry>

