Set up a geodatabase in PostgreSQL on Windows

Available with Standard or Advanced license.

How you set up a geodatabase depends on situations at your site. Follow the instructions for the scenarios that apply for you.

• You are the PostgreSQL and geodatabase administrator.
• The PostgreSQL administrator creates the database; the geodatabase administrator creates the geodatabase.

Note that this topic applies to PostgreSQL installations on a Windows server. If you have PostgreSQL installed on a Linux server, see Set up a geodatabase in PostgreSQL on Linux.

You are the PostgreSQL and geodatabase administrator

If you perform the role of both the database administrator and geodatabase administrator and, therefore, know the password for both login roles, you can use the Create Enterprise Geodatabase geoprocessing tool or Python script to create a geodatabase in PostgreSQL.

The Create Enterprise Geodatabase tool makes it easy to set up a geodatabase because it creates the database objects and grants required privileges for you. To achieve this, specific default settings are used. The following describes what the Create Enterprise Geodatabase tool does and the settings it uses:

• It creates a database using the PostgreSQL default template (template1).

  If you need to create the database using a different template—for example, if you want to use the postgis template—you must create the database before running this tool. Then you can run the Create Enterprise Geodatabase tool or script and specify the name of your precreated database.

• It creates an sde login role in the database cluster and grants it superuser status.

  The sde user must be a superuser to create the geodatabase.

• It creates an sde schema in the database.

  The geodatabase system tables, views, functions, and procedures are stored in the sde schema.

• It sets the sde user as the owner of the sde schema and grants usage on the sde schema to the public role.

  Login roles that will use the geodatabase must be able to access the sde schema. Since geodatabase login roles likely do not exist yet, this tool grants usage to public. After the geodatabase is created, you can tighten security on your geodatabase by revoking usage on the sde schema from public and granting usage only to those login groups and roles that need access to the geodatabase.

• It creates a geodatabase.

First, you must install PostgreSQL and configure the database cluster.

Set up PostgreSQL

Follow these steps to set up a PostgreSQL database cluster to store a geodatabase on a Windows server:

1. Obtain and install a supported release of PostgreSQL and configure the database cluster.

   You can download PostgreSQL installations from My Esri. If you use this installation, no specific nondefault settings are needed to use PostgreSQL with ArcGIS. Just be sure to change the locale and location settings if you want to use those other than the default. Alternatively, you can obtain the PostgreSQL installation yourself.

   See the documentation on the PostgreSQL website for instructions on installing and configuring PostgreSQL.

2. Configure the database cluster to accept connections.

   This includes altering the pg_hba.conf file to allow the database cluster to accept remote connections.

3. Install the ArcGIS client from which you will create the geodatabase.

   Typically, you would create a geodatabase from either ArcGIS for Server or ArcGIS for Desktop (Standard or Advanced). These clients are usually installed on machines separate from the PostgreSQL database cluster, but they don't have to be. Note that, though you can install ArcGIS for Server on the same machine as PostgreSQL, it is not recommended, because database management systems are memory-intensive applications and would contend with ArcGIS Server for resources.

4. If you will be using ArcGIS for Desktop to create the geodatabase, download the PostgreSQL libpq client libraries from My Esri and place them in the ArcGIS Desktop bin directory. See Connect to PostgreSQL for more information.
5. Create a tablespace in the database cluster in which to store your database. If you do not create a tablespace, the pg_default tablespace will be used.

Next, install and configure an ArcGIS client.

Configure an ArcGIS client

You can run a Python script from ArcGIS for Desktop (Standard or Advanced), ArcGIS Engine Runtime with the Geodatabase Update extension, or ArcGIS for Server to create a geodatabase. If you want to run the Create Enterprise Geodatabase geoprocessing tool instead of a script, use ArcGIS for Desktop.

Note:

You need an ArcGIS Server keycodes file to authorize your geodatabase in the next section. Even if you do not run a Python script from an ArcGIS Server machine to create the geodatabase, you must install and authorize ArcGIS Server to get the keycodes file.

Install the ArcGIS client from which you will create the geodatabase. Typically, you create a geodatabase from either ArcGIS for Server or ArcGIS for Desktop (Standard or Advanced).

Now that ArcGIS is installed, you have access to the st_geometry.dll file, which must be placed on the PostgreSQL server.

Place the st_geometry.dll file

You must place the st_geometry.dll file in the PostgreSQL lib directory before you can create a geodatabase.

The st_geometry.dll files are installed with ArcGIS clients. The following table lists where in the ArcGIS client installation directory to find each version of the st_geometry.dll file. You must use the st_geometry.dll file specific to the version of PostgreSQL you are using. If you do not place the correct st_geometry library in the PostgreSQL lib directory, you will not be able to create a geodatabase.

PostgreSQL version	ArcGIS client installation directory
PostgreSQL 9.1	DatabaseSupport\PostgreSQL\9.1\Windows64
PostgreSQL 9.2	DatabaseSupport\PostgreSQL\9.2\Windows64
PostgreSQL 9.3	DatabaseSupport\PostgreSQL\9.3\Windows64

Note:

The st_geometry.dll requires the Microsoft Visual C++ 2008 SP1 Redistributable Package (x64). If this package is not present on the PostgreSQL server, download it from the Microsoft site and install it.

Copy the st_geometry.dll file from the ArcGIS DatabaseSupport directory to the PostgreSQL lib directory.

Your database cluster and ArcGIS client are now ready for you to create a geodatabase.

Create a geodatabase

You can either run the Create Enterprise Geodatabase tool from ArcGIS for Desktop, or run a Python script from an ArcGIS for Desktop, ArcGIS for Server, or ArcGIS Engine client to create a geodatabase.

Run the Create Enterprise Geodatabase tool

You can run the Create Enterprise Geodatabase tool from ArcGIS for Desktop (Standard or Advanced) to create a database and geodatabase in the PostgreSQL database cluster.

1. Start ArcMap or ArcCatalog.
2. Open the Create Enterprise Geodatabase tool.

   You can search for or browse to this tool, which is located in the Geodatabase Administration toolset of the Data Management toolbox.

3. Choose PostgreSQL from the Database Platform drop-down list.
4. Type the name of the PostgreSQL server in the Instance text box.
5. In the Database text box, type the name of the database you want to create to contain your geodatabase.

   Note:

   Type the database name in lowercase; upper- and mixed-case object names are not supported for geodatabases in PostgreSQL. If you type a database name in upper or mixed case, ArcGIS converts it to lower case.

6. You must connect to the database cluster as the postgres superuser to create the database and other objects; therefore, the Database Administrator text box defaults to postgres. If your postgres superuser has a different name, type that name in the Database Administrator text box.
7. Type the password for the postgres superuser in the Database Administrator Password text box.
The geodatabase administrator must be named sde in PostgreSQL; therefore, the Geodatabase Administrator text box is prepopulated with sde.
8. Type a password for the geodatabase administrator user (sde) in the Geodatabase Administrator Password text box.

   If the sde user already exists in the database cluster, type the existing user's password and an sde schema is created in the database. If the user does not already exist, a user named sde with the password you specify is created in the database cluster and a corresponding schema is created in the database. Usage is granted on the sde schema to the public group role.

   Tip:

   If you want to make the schema more secure after the geodatabase is created, you can revoke usage from the public group role, create a new group role, grant usage on the sde schema to that role, then grant the group role to all login roles that need to access the geodatabase.

9. If you have a preconfigured tablespace you want to use as the default tablespace for the database, type its name in the Tablespace Name text box.

   This tool does not create a tablespace; you must either specify an existing tablespace or leave this text box blank. If you do not specify a tablespace, the database is created in pg_default.

10. To specify an Authorization File, browse to and choose the keycodes file that was created when you authorized ArcGIS for Server Enterprise.

    This file is written to \\Program Files\ESRI\License<release#>\sysgen folder on Windows servers and /arcgis/server/framework/runtime/.wine/drive_c/Program Files/ESRI/License<release#>/sysgen on Linux. If you have not already done so, authorize ArcGIS for Server now to create this file.

11. Click OK to run the tool.

    A log file for the geodatabase creation (GDBCreateGeodatabase<#>.log) is written to the directory specified for your %TEMP% variable on the computer where the tool is run.

You now have a geodatabase in PostgreSQL.

Next, you can create a user who can load data into the geodatabase.

Run a Python script from an ArcGIS client machine

You can copy, save, and run the script provided here to create a geodatabase from an ArcGIS for Desktop (Standard or Advanced), ArcGIS for Server, or ArcGIS Runtime client (with the Geodatabase Update extension).

1. Create a text file on the ArcGIS client machine and copy the following script into the file.

   """
   Name: create_enterprise_gdb.py
   Description: Provide connection information to a DBMS instance and create an enterprise geodatabase.
   Type  create_enterprise_gdb.py -h or create_enterprise_gdb.py --help for usage
   """
   
   # Import system modules
   import arcpy
   import os
   import optparse
   import sys
   
   
   # Define usage and version
   parser = optparse.OptionParser(usage = "usage: %prog [Options]", version="%prog 1.0 for " + arcpy.GetInstallInfo()['Version'] )
   
   #Define help and options
   parser.add_option ("--DBMS", dest="Database_type", type="choice", choices=['SQLSERVER', 'ORACLE', 'POSTGRESQL', ''], default="", help="Type of enterprise DBMS:  SQLSERVER, ORACLE, or POSTGRESQL.")                   
   parser.add_option ("-i", dest="Instance", type="string", default="", help="DBMS instance name")
   parser.add_option ("-D", dest="Database", type="string", default="none", help="Database name:  Do not specify for Oracle")
   parser.add_option ("--auth", dest="Account_authentication", type ="choice", choices=['DATABASE_AUTH', 'OPERATING_SYSTEM_AUTH'], default='DATABASE_AUTH', help="Authentication type options (case-sensitive):  DATABASE_AUTH, OPERATING_SYSTEM_AUTH.  Default=DATABASE_AUTH")
   parser.add_option ("-U", dest="Dbms_admin", type="string", default="", help="DBMS administrator user")
   parser.add_option ("-P", dest="Dbms_admin_pwd", type="string", default="", help="DBMS administrator password")
   parser.add_option ("--schema", dest="Schema_type", type="choice", choices=['SDE_SCHEMA', 'DBO_SCHEMA'], default="SDE_SCHEMA", help="Schema type  applies to geodatabases in SQL Server only. Type SDE_SCHEMA to create geodatabase in SDE schema or type DBO_SCHEMA to create geodatabase in DBO schema. Default=SDE_SCHEMA")
   parser.add_option ("-u", dest="Gdb_admin", type="string", default="", help="Geodatabase administrator user name; Must always be sde for PostgreSQL, sde-schema geodatabases in SQL Server, and master sde geodatabase in Oracle")
   parser.add_option ("-p", dest="Gdb_admin_pwd", type="string", default="", help="Geodatabase administrator password")
   parser.add_option ("-t", dest="Tablespace", type="string", default="", help="Tablespace name; For PostgreSQL, type name of existing tablespace in which to store database. If no tablespace name specified, pg_default is used. For Oracle, type name of existing tablespace, or, if tablespace with specified name does not exist, it will be created and set as the default tablespace for the sde user. If no tablespace name is specified, SDE_TBS tablespace is created and set as sde user default. Tablespace name not supported for SQL Server.")
   parser.add_option ("-l", dest="Authorization_file", type="string", default="", help="Full path and name of authorization file; file created when ArcGIS for Server Enterprise authorized, and stored in \\Program Files\ESRI\License<release#>\sysgen on Windows or /arcgis/server/framework/runtime/.wine/drive_c/Program Files/ESRI/License<release#>/sysgen on Linux")
   # Check if value entered for option
   try:
   	(options, args) = parser.parse_args()
   
   	
   	#Check if no system arguments (options) entered
   	if len(sys.argv) == 1:
   		print("%s: error: %s\n" % (sys.argv[0], "No command options given"))
   		parser.print_help()
   		sys.exit(3)
   
   	#Usage parameters for spatial database connection
   	database_type = options.Database_type.upper()
   	instance = options.Instance
   	database = options.Database.lower()	
   	account_authentication = options.Account_authentication.upper()
   	dbms_admin = options.Dbms_admin
   	dbms_admin_pwd = options.Dbms_admin_pwd
   	schema_type = options.Schema_type.upper()
   	gdb_admin = options.Gdb_admin
   	gdb_admin_pwd = options.Gdb_admin_pwd	
   	tablespace = options.Tablespace
   	license = options.Authorization_file
   	
   	
   	if (database_type == "SQLSERVER"):
   		database_type = "SQL_SERVER"
   	
   	if( database_type ==""):	
   		print(" \n%s: error: \n%s\n" % (sys.argv[0], "DBMS type (--DBMS) must be specified."))
   		parser.print_help()
   		sys.exit(3)		
   		
   	if (license == ""):
   		print(" \n%s: error: \n%s\n" % (sys.argv[0], "Authorization file (-l) must be specified."))
   		parser.print_help()
   		sys.exit(3)			
   	
   	if(database_type == "SQL_SERVER"):
   		if(schema_type == "SDE_SCHEMA" and gdb_admin.lower() != "sde"):
   			print("\n%s: error: %s\n" % (sys.argv[0], "To create SDE schema on SQL Server, geodatabase administrator must be SDE."))
   			sys.exit(3)
   		if (schema_type == "DBO_SCHEMA" and gdb_admin != ""):
   			print("\nWarning: %s\n" % ("Ignoring geodatabase administrator specified when creating DBO schema..."))
   		if( account_authentication == "DATABASE_AUTH" and dbms_admin == ""):
   			print("\n%s: error: %s\n" % (sys.argv[0], "DBMS administrator must be specified with database authentication"))
   			sys.exit(3)
   		if( account_authentication == "OPERATING_SYSTEM_AUTH" and dbms_admin != ""):
   			print("\nWarning: %s\n" % ("Ignoring DBMS administrator specified when using operating system authentication..."))
   	else:
   		if (schema_type == "DBO_SCHEMA"):
   			print("\nWarning: %s %s, %s\n" % ("Only SDE schema is supported on", database_type, "switching to SDE schema..." ))
   			
   		if( gdb_admin.lower() == ""):
   			print("\n%s: error: %s\n" % (sys.argv[0], "Geodatabase administrator must be specified."))
   			sys.exit(3)
   
   		if( gdb_admin.lower() != "sde"):
   			if (database_type == "ORACLE"):
   				print("\nGeodatabase admin user is not SDE, creating user schema geodatabase on Oracle...\n")
   			else:
   				print("\n%s: error: %s for %s.\n" % (sys.argv[0], "Geodatabase administrator must be SDE", database_type))
   				sys.exit(3)
   			
   		if( dbms_admin == ""):
   			print("\n%s: error: %s\n" % (sys.argv[0], "DBMS administrator must be specified!"))
   			sys.exit(3)
   
   		if (account_authentication == "OPERATING_SYSTEM_AUTH"):
   			print("Warning: %s %s, %s\n" % ("Only database authentication is supported on", database_type, "switching to database authentication..." ))
   
   	# Get the current product license
   	product_license=arcpy.ProductInfo()
   	
   	
   	# Checks required license level
   	if product_license.upper() == "ARCVIEW" or product_license.upper() == 'ENGINE':
   		print("\n" + product_license + " license found!" + " Creating an enterprise geodatabase requires an ArcGIS for Desktop Standard or Advanced, ArcGIS Engine with the Geodatabase Update extension, or ArcGIS for Server license.")
   		sys.exit("Re-authorize ArcGIS before creating enterprise geodatabase.")
   	else:
   		print("\n" + product_license + " license available!  Continuing to create...")
   		arcpy.AddMessage("+++++++++")
   	
   	
   	try:
   		print("Creating enterprise geodatabase...\n")
   		arcpy.CreateEnterpriseGeodatabase_management(database_platform=database_type,instance_name=instance, database_name=database, account_authentication=account_authentication, database_admin=dbms_admin, database_admin_password=dbms_admin_pwd, sde_schema=schema_type, gdb_admin_name=gdb_admin, gdb_admin_password=gdb_admin_pwd, tablespace_name=tablespace, authorization_file=license)
   		for i in range(arcpy.GetMessageCount()):
   			arcpy.AddReturnMessage(i)
   		arcpy.AddMessage("+++++++++\n")
   	except:
   		for i in range(arcpy.GetMessageCount()):
   			arcpy.AddReturnMessage(i)
   			
   #Check if no value entered for option	
   except SystemExit as e:
   	if e.code == 2:
   		parser.usage = ""
   		print("\n")
   		parser.print_help()   
   		parser.exit(2)
   

2. Save the file with a .py extension.
3. Run the script, providing options and information specific to your site.

   In the following example run from a Windows machine, the file create_gdb.py is run for a database cluster named pgprod as postgres superuser with password N0pe3king!. It creates a database named entgdb in an existing tablespace named gis and creates the sde login role with password Tgdbst@rtsh3r3. A keycodes file in the default ArcGIS Server location is specified to authorize the geodatabase.

   create_gdb.py --DBMS POSTGRESQL -i pgprod -D entgdb --auth DATABASE_AUTH 
   -U postgres -P N0pe3king! -u sde -p Tgdbst@rtsh3r3 -t gis -l \\Program Files\ESRI\License10.3\sysgen\keycodes
   

   In this example, the same script is run from a Linux machine:

   ./create_gdb.py --DBMS POSTGRESQL -i pgprod -D entgdb --auth DATABASE_AUTH 
   -U postgres -P N0pe3king! -u sde -p Tgdbst@rtsh3r3 -t gis -l /usr/arcgis/server/framework/runtime/.wine/drive_c/Program Files/ESRI/License10.3/sysgen/keycodes
   

   Tip:

   Type -h or --help at the command prompt to get syntax help.

You now have a geodatabase in PostgreSQL.

Next, you can create a user who can load data into the geodatabase.

The PostgreSQL administrator creates the database; the geodatabase administrator creates the geodatabase

If the person creating the geodatabase does not have access to the database administrator's (the postgres superuser) password, the database administrator can set up the database, and then the geodatabase administrator can connect to it with the sde login role and create a geodatabase in the database using the Enable Enterprise Geodatabase geoprocessing tool or Python script.

The Enable Enterprise Geodatabase tool takes a database connection file as input and creates the geodatabase system tables, views, functions, and procedures in the sde schema. The database administrator must set up the following in the PostgreSQL database cluster before the tool can be run:

• A login role named sde that has superuser status
• A database
• An sde schema in the database, owned by the sde login role
• The st_geometry library must be in the PostgreSQL installation directory

Note that all database object names must use lowercase characters only.

Follow the instructions to set up a geodatabase for the operating system where PostgreSQL is installed.

Set up PostgreSQL

First, the database administrator must prepare PostgreSQL to store a geodatabase.

The following instructions are for the database administrator to set up the PostgreSQL database cluster on a Windows server. Note that all database object names (the database, schema, and login roles) must use lowercase characters only.

1. Obtain and install a supported release of PostgreSQL and configure the database cluster.

   You can download PostgreSQL installations from My Esri. If you use this installation, no specific nondefault settings are needed to use PostgreSQL with ArcGIS. Just be sure to change the locale and location settings if you want to use those other than the default. Alternatively, you can obtain the PostgreSQL installation yourself.

   See the documentation on the PostgreSQL website for instructions on installing and configuring PostgreSQL.

2. Configure the database cluster to accept connections.

   This includes altering the pg_hba.conf file to allow the database cluster to accept remote connections.

3. Optionally, you can create a tablespace in the database cluster in which to store your database.
4. Create a login role named sde and grant it superuser status.

   Tip:

   If the geodatabase administrator will not be removing database connections, you can revoke the superuser status from the sde role after the geodatabase is created, but you must regrant it when it is time to upgrade the geodatabase.

5. Create the database that will store the geodatabase.
6. Create a schema named sde in the database and give the sde login role authority on the schema.
7. You must also place the st_geometry.dll file in the PostgreSQL lib directory. This file is installed with ArcGIS clients. Ask the geodatabase administrator to provide you with the correct file for your PostgreSQL installation once he or she has installed the ArcGIS client.

   Note:

   The st_geometry.dll requires the Microsoft Visual C++ 2008 SP1 Redistributable Package (x64). If this package is not present on the PostgreSQL server, download it from the Microsoft site and install it.

8. Provide the geodatabase administrator with database connection information.

   The geodatabase administrator needs to know the database cluster name, database name, and the password for the sde login role.

Now that a database exists, the geodatabase administrator can prepare an ArcGIS client and create a geodatabase.

Configure an ArcGIS client

The geodatabase administrator should follow these steps to prepare the ArcGIS client to create a geodatabase:

1. Install the ArcGIS client from which you will create the geodatabase.

   Typically, you would create a geodatabase from either ArcGIS for Server or ArcGIS for Desktop (Standard or Advanced).

2. Once the ArcGIS client is installed, you can access the st_geometry.so file the database administrator needs to finish setting up the database cluster. Provide the database administrator with the correct file.

   The following table lists where in the ArcGIS client installation directory to find each version of the st_geometry.dll file. You must use the st_geometry.dll file specific to the version of PostgreSQL you are using. If you do not place the correct st_geometry library in the PostgreSQL lib directory, you will not be able to create a geodatabase.

   PostgreSQL version	ArcGIS client installation directory
   PostgreSQL 9.1	DatabaseSupport\PostgreSQL\9.1\Windows64
   PostgreSQL 9.2	DatabaseSupport\PostgreSQL\9.2\Windows64
   PostgreSQL 9.3	DatabaseSupport\PostgreSQL\9.3\Windows64

3. If you will be using ArcGIS for Desktop to create the geodatabase, download the PostgreSQL libpq client libraries from My Esri and place them in the ArcGIS Desktop bin directory. See Connect to PostgreSQL for more information.

Your ArcGIS client is ready to connect to the database and create a geodatabase.

Create a geodatabase

The geodatabase administrator can run either the Enable Enterprise Geodatabase tool from ArcGIS for Desktop (Standard or Advanced), or a Python script from an ArcGIS for Desktop, ArcGIS for Server, or ArcGIS Engine client to create a geodatabase in the existing database.

Run the Enable Enterprise Geodatabase tool

You can run the Enable Enterprise Geodatabase tool from ArcGIS for Desktop to create a geodatabase in a PostgreSQL database.

1. Start ArcMap or ArcCatalog.
2. Connect to the PostgreSQL database from the Catalog tree, using the sde login role.

   Be sure to save the user's password on the Database Connection dialog box.

3. Right-click the database connection and click Enable Geodatabase.

   The Enable Enterprise Geodatabase tool opens, and the Input Database Connection field is populated with the connection file name and location.

4. Browse to the ArcGIS for Server authorization file that was created when you authorized ArcGIS for Server and add it to the Authorization File text box.

   When you use the wizard to authorize ArcGIS for Server, a keycodes file is written to the server where the software is installed. If you authorized ArcGIS for Server on a Linux box, the keycodes file was created in /arcgis/server/framework/runtime/.wine/drive_c/Program Files/ESRI/License<release>/sysgen. If you authorized on a Windows server, the file was created in Program Files\ESRI\License<release>\sysgen. If you have not already done so, authorize ArcGIS for Server to create this file.

5. Click OK to run the tool.

A geodatabase is created in the database.

A log file for the geodatabase creation (GDBCreateGeodatabase<#>.log) is written to the directory specified for your %TEMP% variable on the computer where the tool is run. If you have any problems running the tool, check this log file to troubleshoot the problem.

Next, you can create a user who can load data into the geodatabase.

Run a Python script from an ArcGIS Server Windows machine

If you want to create the geodatabase by running a script from an ArcGIS for Server, ArcGIS for Desktop, or ArcGIS Runtime installation on a Windows machine, you can use the script provided here.

Follow these steps to run a Python script for geodatabase creation in PostgreSQL:

1. Create a text file on the ArcGIS client machine and copy the following script into the file.

   """
   Name: enable_enterprise_gdb.py
   Description: Provide connection information to an enterprise database
   and enable enterprise geodatabase.
   Type enable_enterprise_gdb.py -h or enable_enterprise_gdb.py --help for usage
   Author: Esri
   """
   
   # Import system modules
   import arcpy, os, optparse, sys
   
   
   # Define usage and version
   parser = optparse.OptionParser(usage = "usage: %prog [Options]", version="%prog 1.0 for " + arcpy.GetInstallInfo()['Version'] )
   
   #Define help and options
   parser.add_option ("--DBMS", dest="Database_type", type="choice", choices=['SQLSERVER', 'ORACLE', 'POSTGRESQL', 'DB2','INFORMIX','DB2ZOS', ''], default="", help="Type of enterprise DBMS:  SQLSERVER, ORACLE, POSTGRESQL, DB2, INFORMIX, or DB2ZOS.")
   parser.add_option ("-i", dest="Instance", type="string", default="", help="DBMS instance name")
   parser.add_option ("--auth", dest="account_authentication", type ="choice", choices=['DATABASE_AUTH', 'OPERATING_SYSTEM_AUTH'], default='DATABASE_AUTH', help="Authentication type options (case-sensitive):  DATABASE_AUTH, OPERATING_SYSTEM_AUTH.  Default=DATABASE_AUTH")
   parser.add_option ("-u", dest="User", type="string", default="", help="Geodatabase administrator user name")
   parser.add_option ("-p", dest="Password", type="string", default="", help="Geodatabase  administrator password")
   parser.add_option ("-D", dest="Database", type="string", default="none", help="Database name:  Not required for Oracle")
   parser.add_option ("-l", dest="Authorization_file", type="string", default="", help="Full path and name of authorization file")
   
   
   # Check if value entered for option
   try:
   	(options, args) = parser.parse_args()
   
   	
   #Check if no system arguments (options) entered
   	if len(sys.argv) == 1:
   		print "%s: error: %s\n" % (sys.argv[0], "No command options given")
   		parser.print_help()
   		sys.exit(3)
   	
   
   	#Usage parameters for spatial database connection
   	database_type = options.Database_type.upper()
   	instance = options.Instance
   	account_authentication = options.account_authentication.upper()
   	username = options.User.lower() 
   	password = options.Password	
   	database = options.Database.lower()
   	license = options.Authorization_file
   
   
   	if( database_type ==""):	
   		print " \n%s: error: \n%s\n" % (sys.argv[0], "DBMS type (--DBMS) must be specified.")
   		parser.print_help()
   		sys.exit(3)		
   		
   	if (license == ""):
   		print " \n%s: error: \n%s\n" % (sys.argv[0], "Authorization file (-l) must be specified.")
   		parser.print_help()
   		sys.exit(3)
   
   	if (database_type == "SQLSERVER"):
   		database_type = "SQL_SERVER"
   		
   	# Get the current product license
   	product_license=arcpy.ProductInfo()
   	
   	if (license == ""):
   		print " \n%s: error: %s\n" % (sys.argv[0], "Authorization file (-l) must be specified.")
   		parser.print_help()
   		sys.exit(3)
   	
   	# Checks required license level
   	if product_license.upper() == "ARCVIEW" or product_license.upper() == 'ENGINE':
   		print "\n" + product_license + " license found!" + "  Enabling enterprise geodatabase functionality requires an ArcGIS for Desktop Standard or Advanced, ArcGIS Engine with the Geodatabase Update extension, or ArcGIS for Server license."
   		sys.exit("Re-authorize ArcGIS before enabling an enterprise geodatabase.")
   	else:
   		print "\n" + product_license + " license available!  Continuing to enable..."
   		arcpy.AddMessage("+++++++++")
   	
   	# Local variables
   	instance_temp = instance.replace("\\","_")
   	instance_temp = instance_temp.replace("/","_")
   	instance_temp = instance_temp.replace(":","_")
   	Conn_File_NameT = instance_temp + "_" + database + "_" + username    
   	
   	if os.environ.get("TEMP") == None:
   		temp = "c:\\temp"	
   	else:
   		temp = os.environ.get("TEMP")
   	
   	if os.environ.get("TMP") == None:
   		temp = "/usr/tmp"		
   	else:
   		temp = os.environ.get("TMP")  
   	
   
   	Connection_File_Name = Conn_File_NameT + ".sde"
   	Connection_File_Name_full_path = temp + os.sep + Conn_File_NameT + ".sde"
   	
   	# Check for the .sde file and delete it if present
   	arcpy.env.overwriteOutput=True
   	if os.path.exists(Connection_File_Name_full_path):
   		os.remove(Connection_File_Name_full_path)
   	
   	print "\nCreating Database Connection File...\n"	
   	# Process: Create Database Connection File...
   	# Usage:  out_file_location, out_file_name, DBMS_TYPE, instnace, database, account_authentication, username, password, save_username_password(must be true)
   	arcpy.CreateDatabaseConnection_management(out_folder_path=temp, out_name=Connection_File_Name, database_platform=database_type, instance=instance, database=database, account_authentication=account_authentication, username=username, password=password, save_user_pass="TRUE")
           for i in range(arcpy.GetMessageCount()):
   		if "000565" in arcpy.GetMessage(i):   #Check if database connection was successful
   			arcpy.AddReturnMessage(i)
   			arcpy.AddMessage("\n+++++++++")
   			arcpy.AddMessage("Exiting!!")
   			arcpy.AddMessage("+++++++++\n")
   			sys.exit(3)            
   		else:
   			arcpy.AddReturnMessage(i)
   			arcpy.AddMessage("+++++++++\n")
   	
   	
   	# Process: Enable geodatabase...
   	try:
   		print "Enabling Enterprise Geodatabase...\n"
   		arcpy.EnableEnterpriseGeodatabase_management(input_database=Connection_File_Name_full_path, authorization_file=license)
   		for i in range(arcpy.GetMessageCount()):
   			arcpy.AddReturnMessage(i)
   		arcpy.AddMessage("+++++++++\n")
   	except:
   		for i in range(arcpy.GetMessageCount()):
   			arcpy.AddReturnMessage(i)
   			
   	if os.path.exists(Connection_File_Name_full_path):
   		os.remove(Connection_File_Name_full_path)
   			
   #Check if no value entered for option	
   except SystemExit as e:
   	if e.code == 2:
   		parser.usage = ""
   		print "\n"
   		parser.print_help() 
   		parser.exit(2)
   

2. Save the file with a .py extension.
3. Run the script, providing options and information specific to your site.

   In the following example, the file enable_gdb.py is run for database spdata on database cluster pgprod. The connection is made as the sde login with password Tgdbst@rtsh3r3. A keycodes file in the default ArcGIS Server location is specified to authorize the geodatabase.

   enable_gdb.py --DBMS POSTGRESQL -i pgprod --auth DATABASE_AUTH 
   -u sde -p Tgdbst@rtsh3r3 -D spdata -l \\Program Files\ESRI\License10.3\sysgen\keycodes
   

   Tip:

   Type -h or --help at the command prompt to get syntax help.

You now have a geodatabase in PostgreSQL.

Next, you can create a user who can load data into the geodatabase.