Erstellen einer Geodatabase in SQL Server—Hilfe

Mit der Standard- oder Advanced-Lizenz verfügbar.

Voraussetzungen
Sie sind der SQL Server- und Geodatabase-Administrator.
Der SQL Server-Administrator erstellt die Datenbank, der Geodatabase-Administrator erstellt die Geodatabase

Um eine Geodatabase in einer Microsoft SQL Server-Datenbank zu erstellen, führen Sie auf einem ArcGIS-Client ein Geoverarbeitungswerkzeug oder ein Python-Skript aus. Lesen Sie zuerst die Voraussetzungen, folgen Sie dann den für Ihre Situation relevanten Anweisungen.

Voraussetzungen

Um eine SQL Server-Geodatabase zu erstellen, gehen Sie wie folgt vor:

Prüfen Sie, ob die gewünschten ArcGIS-, SQL Server- und Betriebssystemkombinationen kompatibel sind.
Laden Sie den SQL Server-ODBC-Client herunter, der zum Herstellen einer Verbindung mit der Version von SQL Server erforderlich ist, die Sie zum Speichern der Geodatabase verwenden möchten.
Rufen Sie eine ArcGIS Server-Keycode-Datei ab, und legen Sie sie an einem Speicherort ab, auf den Sie über den ArcGIS-Client zugreifen können, den Sie zum Erstellen der Geodatabase verwenden möchten.
Bestimmen Sie, wer die Geodatabase erstellen soll. Dies hat Einfluss darauf, wer die Datenbank erstellt. Legen Sie zudem fest, mit welchem Werkzeug Sie die Geodatabase erstellen möchten. Befolgen Sie die Anweisungen, die für Ihre Situation gelten:
- Sie sind der SQL Server- und Geodatabase-Administrator.
- Der SQL Server-Administrator erstellt die Datenbank, der Geodatabase-Administrator erstellt die Geodatabase.

Sie sind der SQL Server- und Geodatabase-Administrator.

Wenn Sie sowohl Datenbank-Administrator als auch Geodatabase-Administrator sind und deshalb das Kennwort für beide Anmeldenamen kennen, können Sie mit dem Geoverarbeitungswerkzeug oder Python-Skript Enterprise-Geodatabase erstellen eine Geodatabase in einer SQL Server-Datenbank erstellen.

Mit dem Werkzeug Enterprise-Geodatabase erstellen ist die Einrichtung einer Geodatabase völlig unkompliziert, da damit die Datenbankobjekte erstellt und die erforderlichen Berechtigungen für Sie gewährt werden. Dazu werden die folgenden Standardeinstellungen verwendet und die folgenden Datenbankobjekte erstellt:

Die Datenbanktabellen (MDF und LDF) werden im SQL Server-Standardverzeichnis auf dem Server erstellt.
Dabei werden die SQL Server-Datenbankoptionen "READ_COMMITTED_SNAPSHOT" und "ALLOW_SNAPSHOT_ISOLATION" auf "ON" eingestellt.
Die Größe entspricht der standardmäßigen Größe für Datenbankdateien, die Sie für die SQL Server-Modelldatenbank definiert haben, bzw. 500 MB für die MDF-Datei und 125 MB für die LDF-Datei, je nachdem, welcher Wert größer ist.
Wenn Sie in einem Schema namens "sde" eine Geodatabase erstellen, erzeugt das Werkzeug in der SQL Server-Instanz eine Anmeldung "sde" mit Datenbankauthentifizierung und in der Datenbank einen Benutzer "sde", der der Anmeldung "sde" zugeordnet wird. Außerdem erstellt das Werkzeug ein Schema "sde" in der Datenbank und gewährt SDE-Benutzerberechtigungen zum Erstellen von Geodatabases und zum Beenden von Verbindungen mit der SQL Server-Instanz.
Die Geodatabase-Objekte werden innerhalb der SQL Server-Instanz erstellt.

Bevor Sie das Werkzeug oder Skript zum Erstellen einer Geodatabase ausführen, müssen Sie eine SQL Server-Instanz installieren und konfigurieren.

Installieren und Konfigurieren von SQL Server

Bevor Sie eine Geodatabase erstellen, muss SQL Server installiert und die Instanz konfiguriert werden. Die spezifische Konfiguration der Instanz hängt von den individuellen Anforderungen Ihrer Organisation ab. Beachten Sie jedoch, dass für die SQL Server-Instanz eine Sortierung verwendet werden muss, bei der nicht zwischen Groß- und Kleinschreibung unterschieden wird.

Sie müssen nach der Installation von SQL Server (durch Sie oder die IT-Abteilung) das Annehmen von Remote-Verbindungen in der SQL Server-Instanz konfigurieren. Standardmäßig sind Remote-Verbindungen nicht aktiviert.

Informationen zur Installation und Konfiguration von Microsoft finden Sie in der SQL Server-Dokumentation.

Installieren Sie nach der Installation und Konfiguration von SQL Server die ArcGIS- und SQL Server-Clients.

Installieren von Clients

Sie können ArcGIS Desktop (Desktop Standard oder Desktop Advanced), ArcGIS Engine mit der Erweiterung "Geodatabase" oder ArcGIS Server (Enterprise Edition) installieren und ein Python-Skript über eine dieser Anwendungen ausführen, um eine Geodatabase zu erstellen. Wenn Sie das Geoverarbeitungswerkzeug Enterprise-Geodatabase erstellen anstelle eines Skripts ausführen möchten, installieren Sie ArcGIS Desktop.

In den meisten Fällen wird der ArcGIS-Client auf einem anderen Computer als SQL Server installiert. Deshalb muss auf dem ArcGIS-Client-Computer ein unterstützter SQL Server Client installiert sein, damit eine Verbindung mit der Datenbank hergestellt werden kann. Lesen Sie die ArcGIS-Systemanforderungen für SQL Server, um festzustellen, welche SQL Server-Clientversion Sie installieren sollten, um die Verbindung zur verwendeten SQL Server-Version herzustellen.

Um eine Verbindung zu SQL Server auf einem Microsoft Windows-Computer herzustellen, können Sie den SQL Server-Client von My Esri oder über das Microsoft Download Center herunterladen. Um eine Verbindung zu SQL Server auf einem Linux-Computer herzustellen, laden Sie die SQL Server-Clientdateien aus dem Microsoft Download Center herunter. Befolgen Sie die Anweisungen von Microsoft für die Installation des SQL Server Client auf Ihrem Client-Computer.

Führen Sie die folgenden Schritte aus, um den Client zu installieren und zu konfigurieren, den Sie zum Erstellen der Geodatabase benötigen. Wenn Sie nicht berechtigt sind, Software zu installieren, müssen Sie diese Schritte von der IT-Abteilung durchführen lassen.

Installieren Sie den ArcGIS-Client, den Sie für die Erstellung der Geodatabase verwenden möchten.

Befolgen Sie die Anleitungen, die in den Installationsanweisungen der Software bereitgestellt werden.
Installieren Sie einen SQL Server Client auf dem ArcGIS-Client-Computer.

Wenn Sie den SQL Server Client auf einem 64-Bit-Betriebssystem installieren, verwenden Sie die ausführbare Datei für 64-Bit SQL Server Client. Diese ausführbare Datei installiert sowohl den 32- als auch den 64-Bit-Client und ermöglicht somit die Verwendung mit 32- und 64-Bit-Anwendungen wie ArcMap und 64-Bit-ArcGIS-Anwendungen wie ArcGIS Server oder ArcGIS Pro. Wenn Sie SQL Server Client mit 32 Bit auf einem 64-Bit-Betriebssystem ausführen, schlägt die Installation fehl.

Jetzt können Sie eine Geodatabase erstellen.

Eine Geodatabase erstellen

Sie können entweder das Werkzeug Enterprise-Geodatabase erstellen von ArcGIS Desktop (Standard oder Advanced) oder ein Python-Skript von einem ArcGIS Desktop (Standard oder Advanced)-, ArcGIS Server- oder ArcGIS Engine-Client ausführen, um eine Datenbank und Geodatabase zu erstellen.

Ausführen des Werkzeugs "Enterprise-Geodatabase erstellen"

Wenn Sie Zugriff auf ArcGIS Desktop haben, können Sie ein Geoverarbeitungswerkzeug ausführen, um die Geodatabase zu erstellen.

Führen Sie die folgenden Schritte aus, um eine Geodatabase mithilfe des Werkzeugs Enterprise-Geodatabase erstellen in ArcMap zu erstellen.

Starten Sie ArcMap oder ArcCatalog.
Öffnen Sie das Werkzeug Enterprise-Geodatabase erstellen.

Sie können dieses Werkzeug suchen oder zu diesem Werkzeug navigieren, das sich in der Toolbox "Data Management" im Toolset "Geodatabase-Verwaltung" befindet.
Wählen Sie aus der Dropdown-Liste Datenbankplattform den Eintrag SQL Server aus.
Geben Sie im Textfeld Instanz den Namen der SQL Server-Instanz ein, mit der Sie eine Verbindung herstellen möchten.
Geben Sie im Textfeld Datenbank den Namen der Datenbank ein, in der die Geodatabase gespeichert werden soll.

Sollte noch keine Datenbank mit diesem Namen in der SQL Server-Instanz vorhanden sein, wird sie erstellt. Ist sie vorhanden, wird die von Ihnen angegebene Datenbank zum Speichern der Geodatabase verwendet.
Stellen Sie eine Verbindung mit SQL Server als Systemadministrator her. Verwenden Sie entweder die Betriebssystemauthentifizierung, die Mitglied der festgelegten Serverrolle "sysadmin" in SQL Server ist, oder durch die Eingabe eines Datenbankbenutzernamens und -kennworts für einen sysadmin-Benutzer.
- Um sich mit einer sysadmin-Betriebssystemauthentifizierung anmelden zu können, müssen Sie Betriebssystemauthentifizierung aktivieren. Sie müssen mit dem richtigen Anmeldenamen bei Windows angemeldet sein, um diese Option zu verwenden.
- Um sich als sysadmin anzumelden, geben Sie den Benutzernamen "sysadmin" in das Textfeld Datenbankadministrator und das entsprechende Kennwort in das Textfeld Datenbankadministratorkennwort ein.
Wählen Sie das Schema aus, das die Geodatabase enthält.
- Wenn Sie einen Benutzer mit dem Namen "sde" als Geodatabase-Administrator auswählen und die Geodatabase im Schema des SDE-Benutzers speichern möchten, aktivieren Sie die Option SDE-Schema.
- Wenn Sie den DBO-Benutzer als Geodatabase-Administrator auswählen und die Geodatabase in einem DBO-Schema speichern möchten, deaktivieren Sie die Option SDE-Schema.
Weitere Informationen zum Speichern der Geodatabase im Schema "sde" oder "dbo" finden Sie unter Ein Vergleich von Windows- und Datenbankauthentifizierung in SQL Server.

Wenn Sie ein SDE-Schema auswählen, enthält das Textfeld Geodatabase-Administrator bereits den Namen "sde". Wenn kein Benutzer mit diesem Namen vorhanden ist, erstellt das Werkzeug diesen Benutzer und das entsprechende Schema und weist dem Benutzer die zum Erstellen einer Geodatabase erforderlichen Berechtigungen zu.

Wenn Sie die Datenbankauthentifizierung und ein DBO-Schema zum Speichern der Geodatabase verwenden, geben Sie den Namen des DBO-Benutzers der SQL Server-Instanz in das Textfeld Geodatabase-Administrator ein.

Wenn Sie mithilfe der Betriebssystemauthentifizierung eine Verbindung mit der Datenbank herstellen, muss der aktuelle Anmeldename Bestandteil der festgelegten Serverrolle "sysadmin" in der SQL Server-Instanz sein, um eine DBO-Schema-Geodatabase erstellen zu können.

Geben Sie ein Kennwort für den Geodatabase-Administrator in das Textfeld Geodatabase-Administratorkennwort ein.

Wenn der von Ihnen angegebene Geodatabase-Administrator in der Datenbank vorhanden ist, müssen Sie das richtige Kennwort für den vorhandenen Benutzer eingeben. Das Kennwort kann mit diesem Werkzeug geändert werden.
Um eine Autorisierungsdatei anzugeben, wechseln Sie zu der Schlüsselcodedatei, die bei der Autorisierung von ArcGIS Server (Enterprise Edition) erstellt wurde, und wählen Sie diese aus.

Diese Datei befindet sich im Ordner \\Program Files\ESRI\License<release#>\sysgen unter Windows und im Ordner /arcgis/server/framework/runtime/.wine/drive_c/Program Files/ESRI/License<release#>/sysgen unter Linux. Kopieren Sie die Schlüsselcodedatei an einen Speicherort, auf den Sie mit dem Werkzeug Enterprise-Geodatabase erstellen zugreifen können. Autorisieren Sie ArcGIS Server jetzt, um diese Datei zu erstellen, sofern Sie dies nicht bereits getan haben.
Klicken Sie auf OK, um das Werkzeug auszuführen.

Im SQL Server-Standardverzeichnis werden eine Datenbank und Protokolldateien erstellt, sofern Sie keine vorhandene Datenbank angegeben haben. Es wird eine Geodatabase in der Datenbank erstellt. Wenn Sie eine SDE-Schema-Geodatabase ausgewählt haben, werden eine Anmeldung "sde" mit Datenbankauthentifizierung, ein Datenbankbenutzer und ein Schema erstellt.

Meldungen im Zusammenhang mit der Geodatabase-Erstellung werden in der Datei sde_setup.log gespeichert, die in dem Verzeichnis erstellt wurde, das für die Variable "%TEMP%" auf dem Computer angegeben wurde, auf dem das Werkzeug ausgeführt wird. Falls Sie Probleme beim Erstellen einer Geodatabase haben, überprüfen Sie diese Datei, um das Problem zu beheben.

Als Nächstes können Sie einen Benutzer erstellen, der Daten in die Geodatabase laden kann.

Ausführen eines Python-Skripts

Sie können das hier verfügbare Skript kopieren, speichern und ausführen, um eine Geodatabase über ArcGIS Desktop (Standard oder Advanced), ArcGIS Server (Standard oder Advanced) oder ArcGIS Engine (mit der Erweiterung "Geodatabase") zu erstellen.

Erstellen Sie eine Textdatei auf einem ArcGIS-Client-Computer, und kopieren Sie das folgende Skript in die Datei.

"""
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=['SQL_SERVER', 'ORACLE', 'POSTGRESQL', ''], default="", help="Type of enterprise DBMS:  SQL_SERVER, 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 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 ==""):	
		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 Desktop Standard or Advanced, ArcGIS Engine with the Geodatabase Update extension, or ArcGIS 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)

Speichern Sie die Datei mit der Erweiterung .py.
Führen Sie das Skript aus, indem Sie für Ihre Site spezifische Optionen und Informationen bereitstellen.
Im folgenden Beispiel wird die Datei "create_gdb.py" ausgeführt, um die Datenbank "entgdb" in der SQL Server-Instanz "porthos\gisprod" zu erstellen. Das Werkzeug wird über die Datenbankauthentifizierung als Benutzer "sa" ausgeführt, und es wird eine Geodatabase im Benutzerschema "sde" erstellt. Im Standardverzeichnis von ArcGIS Server wird eine Schlüsselcodedatei angegeben, um die Geodatabase zu autorisieren.
```
create_gdb.py --DBMS SQL_SERVER -i porthos\gisprod -D entgdb --auth DATABASE_AUTH 
-U sa -P N0pe3king! --schema SDE_SCHEMA -u sde -p Tgdbst@rtsh3r3 -l '\\Program Files\ESRI\License\sysgen\keycodes'
```
In diesem Beispiel wird dasselbe Skript ausgeführt, wobei eine Anmeldung beim Client-Computer mit einem Anmeldenamen, der Mitglied der festgelegten sysadmin-Serverrolle ist, für die Erstellung einer Geodatabase im DBO-Schema besteht:
```
create_gdb.py --DBMS SQL_SERVER -i porthos\gisprod -D entgdb --auth OPERATING_SYSTEM_AUTH 
--schema DBO_SCHEMA -l '\\Program Files\ESRI\License\sysgen\keycodes'
```
Tipp:
Type -h or --help at the command prompt to get syntax help.

Sie verfügen nun über eine Geodatabase in SQL Server.

Meldungen im Zusammenhang mit der Geodatabase-Erstellung werden in der Datei sde_setup.log gespeichert, die in dem Verzeichnis erstellt wurde, das für die Variable "%TEMP%" auf dem Computer angegeben wurde, auf dem das Skript ausgeführt wird. Falls Sie Probleme beim Erstellen einer Geodatabase haben, überprüfen Sie diese Datei, um das Problem zu beheben.

Als Nächstes können Sie einen Benutzer erstellen, der Daten in die Geodatabase laden kann.

Der SQL Server-Administrator erstellt die Datenbank, der Geodatabase-Administrator erstellt die Geodatabase

Wenn die Person, die die Geodatabase erstellt, keinen Zugriff auf das Kennwort des Datenbankadministrators hat, kann der Datenbank-Administrator die Datenbank erstellen und den Anmeldenamen, den Benutzer und das Schema des Geodatabase-Administrators erstellen. Wenn die Geodatabase im SDE-Schema gespeichert werden soll, erstellt der Datenbank-Administrator einen SDE-Anmeldenamen und -benutzer und ein SDE-Schema. Wenn die Geodatabase im DBO-Schema gespeichert werden soll, erstellt der Datenbank-Administrator eine Anmeldung und einen Benutzer und weist den Benutzer dem Besitzer der Datenbank zu. Weitere Informationen zu den Speicheroptionen für Geodatabases finden Sie unter Ein Vergleich von Windows- und Datenbankauthentifizierung in SQL Server.

Der Geodatabase-Administrator kann als Geodatabase-Administrator eine Verbindung mit der Datenbank herstellen und mit dem Geoverarbeitungswerkzeug Enterprise Geodatabase aktivieren oder einem Python-Skript eine Geodatabase erstellen.

Das Werkzeug Enterprise-Geodatabase aktivieren verwendet eine Datenbankverbindungsdatei als Eingabe und erstellt die Geodatabase-Systemtabellen, -sichten, -funktionen und -prozeduren.

Installieren und Konfigurieren von SQL Server

Bevor der Geodatabase-Administrator eine Geodatabase erstellen kann, muss der SQL Server-Administrator folgende Aktionen ausführen:

Installieren und konfigurieren Sie die SQL Server-Instanz. Die spezifische Konfiguration der Instanz hängt von den individuellen Anforderungen Ihrer Organisation ab. Überprüfen Sie die ArcGIS-Systemanforderungen, bevor Sie fortfahren, um sicherzustellen, dass die gewünschten Datenbankmanagementsystem-, ArcGIS- und Hardwarekombinationen unterstützt werden. Stellen Sie nach der Installation von SQL Server sicher, die Akzeptanz von Remote-Verbindungen in der SQL Server-Instanz zu konfigurieren. Standardmäßig sind Remote-Verbindungen nicht aktiviert. Informationen zur Installation und Konfiguration von Microsoft finden Sie in der SQL Server-Dokumentation.
Erstellen Sie eine Datenbank.
Stellen Sie die SQL Server-Datenbankoptionen "READ_COMMITTED_SNAPSHOT" und "ALLOW_SNAPSHOT_ISOLATION" auf "ON" ein. Wenn der SQL Server-Administrator diese Optionen nicht auf "ON" einstellt, dem Geodatabase-Administrator jedoch ALTER-Berechtigungen in der Datenbank erteilt, ändert das Werkzeug Enterprise-Geodatabase aktivieren diese Einstellungen in der Datenbank, wenn es ausgeführt wird. Wenn der SQL Server-Administrator diese Optionen nicht festlegt und der Geodatabase-Administrator nicht über ausreichende Berechtigungen verfügt, um diese zu ändern, kann die Geodatabase nicht erstellt werden.
Fügen Sie einen Anmeldenamen hinzu, der einem Datenbankbenutzer mit dem Namen "sde" oder einem Datenbankbenutzer, der Datenbankbesitzer ist, zugeordnet wird, oder erstellen Sie einen solchen Anmeldenamen.
Erstellen Sie bei Verwendung einer SDE-Schema-Geodatabase ein Schema mit dem Namen "sde" in der Datenbank. Legen Sie dieses als Standardschema des Benutzers "sde" fest.
Wenn Sie eine SDE-Schema-Geodatabase verwenden, muss der Benutzer "sde" mindestens die folgenden Berechtigungen haben: CREATE FUNCTION, CREATE PROCEDURE, CREATE TABLE und CREATE VIEW. Weitere Berechtigungen finden Sie unter Berechtigungen für Geodatabases in SQL Server.

Installieren von Clients

Der Geodatabase-Administrator kann ArcGIS Desktop (Desktop Standard oder Desktop Advanced), ArcGIS Engine mit der Erweiterung "Geodatabase" oder ArcGIS Server installieren, um eine Geodatabase durch Ausführung eines Python-Skripts zu erstellen. Wenn Sie das Geoverarbeitungswerkzeug Enterprise-Geodatabase aktivieren anstelle eines Skripts ausführen möchten, installieren Sie ArcGIS Desktop.

Installieren Sie den ArcGIS-Client, den Sie für die Erstellung der Geodatabase verwenden möchten.

Befolgen Sie die Anleitungen, die in den Installationsanweisungen der Software bereitgestellt werden.
Installieren Sie einen SQL Server Client auf dem ArcGIS-Client-Computer.

Wenn Sie den SQL Server Client auf einem 64-Bit-Betriebssystem installieren, verwenden Sie die ausführbare Datei für den 64-Bit SQL Server Client. Diese ausführbare Datei installiert sowohl den 32- als auch den 64-Bit-Client und ermöglicht somit die Verwendung mit 32- und 64-Bit-Anwendungen wie ArcMap und 64-Bit-ArcGIS-Anwendungen wie ArcGIS Server oder ArcGIS Pro. Wenn Sie den 32-Bit-SQL Server-Client auf einem 64-Bit-Betriebssystem ausführen, schlägt die Ausführung fehl.

Der ArcGIS-Client ist bereit und kann eine Verbindung zur Datenbank herstellen und eine Geodatabase erstellen. Verwenden Sie hierzu eine der Methoden, die im nächsten Abschnitt beschrieben werden.

Eine Geodatabase erstellen

Der Geodatabase-Administrator kann das Werkzeug Enterprise-Geodatabase aktivieren von ArcGIS Desktop (Standard oder Advanced) oder ein Python-Skript von einem ArcGIS Desktop (Standard oder Advanced)-, ArcGIS Server- oder ArcGIS Engine-Client (mit der Erweiterung "Geodatabase Update") ausführen, um eine Geodatabase in der vorhandenen Datenbank zu erstellen.

Ausführen des Werkzeugs "Enterprise-Geodatabase aktivieren"

Sie können das Werkzeug Enterprise-Geodatabase aktivieren von ArcGIS Desktop ausführen, um eine Geodatabase in einer SQL Server-Datenbank zu erstellen.

Führen Sie die folgenden Schritte aus, um eine Geodatabase mithilfe des Werkzeugs Enterprise-Geodatabase aktivieren in ArcMap zu erstellen:

Starten Sie ArcMap oder ArcCatalog.
Stellen Sie vom Kataloginhaltsverzeichnis als Geodatabase-Administrator eine Verbindung mit der SQL Server-Datenbank her.

Vergessen Sie nicht, das Kennwort des Benutzers im Dialogfeld Datenbankverbindung zu speichern.
Klicken Sie mit der rechten Maustaste auf die Datenbankverbindung und wählen Sie Geodatabase aktivieren.

Das Werkzeug Enterprise-Geodatabase aktivieren wird geöffnet, und im Textfeld Eingabe-Datenbankverbindung wird der Name und Speicherort der Verbindungsdatei eingefügt.
Navigieren Sie zu der ArcGIS Server-Autorisierungsdatei, die bei der Autorisierung von ArcGIS Server erstellt wurde, und geben Sie sie im Feld Autorisierungsdatei an.

Wenn Sie zum Autorisieren von ArcGIS Server den Assistenten verwenden, wird eine Schlüsselcodedatei auf dem Server erzeugt, auf dem die Software installiert ist. Die Schlüsselcodedatei wird im Ordner Program Files\ESRI\License<release>\sysgen auf Windows-Servern und im Verzeichnis /arcgis/server/framework/runtime/.wine/drive_c/Program Files/ESRI/License<release#>/sysgen auf Linux-Servern erstellt. Kopieren Sie die Schlüsselcodedatei an einen Speicherort, auf den Sie mit dem Werkzeug Enterprise-Geodatabase aktivieren zugreifen können. Autorisieren Sie ggf. ArcGIS Server, um diese Datei zu erstellen.
Klicken Sie auf OK, um das Werkzeug auszuführen.

Es wird eine Geodatabase in der Datenbank erstellt.

Als Nächstes kann der Datenbankadministrator einen Benutzer erstellen, der Daten in die Geodatabase laden kann.

Ausführen eines Python-Skripts

Wenn Sie die Geodatabase durch das Ausführen eines Skripts von einer ArcGIS Server-, ArcGIS Desktop (Standard oder Advanced)- oder ArcGIS Engine-Installation (mit der Erweiterung "Geodatabase") auf einem Windows-Computer erstellen möchten, können Sie das hier verfügbare Skript dazu verwenden.

Führen Sie die folgenden Schritte aus, um ein Python-Skript zum Erstellen einer Geodatabase in einer vorhandenen SQL Server-Datenbank zu erstellen:

Erstellen Sie eine Textdatei auf einem ArcGIS-Client-Computer, und kopieren Sie das folgende Skript in die Datei.

"""
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
"""

# 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=['SQL_SERVER', 'ORACLE', 'POSTGRESQL', 'DB2','INFORMIX','DB2ZOS', ''], default="", help="Type of enterprise DBMS:  SQL_SERVER, 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)

		
	# 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 Desktop Standard or Advanced, ArcGIS Engine with the Geodatabase Update extension, or ArcGIS 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)

Speichern Sie die Datei mit der Erweiterung .py.
Führen Sie das Skript aus, indem Sie für Ihre Site spezifische Optionen und Informationen bereitstellen.
Im folgenden Beispiel wird die Datei enable_gdb.py für die Datenbank "spdata" auf der Instanz "ssprod" ausgeführt. Die Verbindung wird als SDE-Anmeldung mit dem Kennwort "Tgdbst@rtsh3r3" hergestellt. Im Standardverzeichnis von ArcGIS Server wird eine Schlüsselcodedatei angegeben, um die Geodatabase zu autorisieren.
```
enable_gdb.py --DBMS SQL_SERVER -i ssprod --auth DATABASE_AUTH 
-u sde -p Tgdbst@rtsh3r3 -D spdata -l '\\Program Files\ESRI\License\sysgen\keycodes'
```
Tipp:
Type -h or --help at the command prompt to get syntax help.

Sie verfügen nun über eine Geodatabase in der SQL Server-Datenbank.

Zum Erstellen der Geodatabase wird eine Protokolldatei (GDBCreateGeodatabase<#>.log) in das Verzeichnis geschrieben, das für die %TEMP%-Variable auf dem Computer angegeben wurde, auf dem das Skript ausgeführt wird.

Als Nächstes kann der Datenbankadministrator einen Benutzer erstellen, der Daten in die Geodatabase laden kann.