16. Systemkatalog
Einführung in den Systemkatalog
Ein Blick in den Systemkatalog von Oracle
Ziele
Die heutige Lektion, deren Schwerpunkt auf dem Systemkatalog liegt, erläutert ...
Einführung in den Systemkatalog
Zu jeder relationalen Datenbank gehört in irgendeiner Form ein Systemkatalog
Die Tabellen des Systemkatalogs mit den Angaben zum Datenbankentwurf werden beim Erstellen der Datenbank angelegt und bei der Ausführung von Befehlen der Datendefinitionssprache (DDL), wie zum Beispiel CREATE TABLE, aktualisiert. In diesem Teil des Systemkatalogs finden sich Informationen über die Spalten und Attribute einer Tabelle, Größen von Tabellen, Tabellenprivilegien und das Tabellenwachstum. Weiterhin gehören zum Systemkatalog Objekte wie Indizes, Trigger, Prozeduren, Pakete und Sichten.
Tabellen zur Benutzerstatistik protokollieren den Status von Elementen, wie Verbindungsinformationen zur Datenbank und Privilegien für einzelne Benutzer. Dabei unterscheidet man zwischen Privilegien auf Systemebene und Privilegien auf Objektebene. Die Berechtigung zum Erzeugen eines anderen Benutzers ist ein Privileg auf Systemebene, während der Zugriff auf Tabellen mit Privilegien auf Objektebene gesteuert wird. Rollen dienen ebenfalls der Gewährleistung der Sicherheit innerhalb einer Datenbank und werden auch im Systemkatalog abgelegt.
Tag 16 führt das gestern behandelte Thema fort. Anhand der Daten des Systemkatalogs kann man die Datenbankleistung überwachen und Parameter modifizieren, die das Leistungsverhalten der Datenbank und der SQL-Anweisungen verbessern.
Der Systemkatalog gehört zu den unentbehrlichen Werkzeugen einer Datenbank. Vergleichbar mit der Inventurliste in einem Einzelhandelsgeschäft erlaubt der Systemkatalog die Organisation einer Datenbank aufrechtzuerhalten und stellt die Mechanismen bereit, um die Integrität der Datenbank sicherzustellen. Wenn man zum Beispiel eine Tabelle erstellt, woher weiß der Datenbank-Server, ob eine Tabelle mit demselben Namen existiert? Wenn man eine Abfrage erzeugt, um Daten aus einer Tabelle auszuwählen, wie läßt sich verifizieren, daß man die passenden Privilegien für den Zugriff auf die Tabelle hat? Der Systemkatalog ist das Herz einer Datenbank, so daß man wissen muß, wie man ihn einsetzt.
Benutzer des Systemkatalogs
Endbenutzer, Systemingenieure und Datenbank-Administratoren greifen alle auf den Systemkatalog zu, ob sie es nun merken oder nicht. Der Zugriff kann sowohl direkt als auch indirekt stattfinden.
Endbenutzer - normalerweise die Kunden, für die die Datenbank erzeugt wurde - greifen auf den Systemkatalog indirekt zu. Wenn sich ein Benutzer in der Datenbank anmeldet, werden anhand des Systemkatalogs der Benutzername, das Kennwort und die Privilegien des Benutzers für die Verbindung zur Datenbank verifiziert. Ebenso finden Prüfungen statt, ob der Benutzer die passenden Privilegien für den Zugriff auf bestimmte Daten hat. In der Regel greift ein Endbenutzer über eine Frontend-Anwendung auf den Systemkatalog zu. Die grafischen Benutzeroberflächen gestatten dem Benutzer den einfachen Aufbau einer SQL-Anweisung. Wenn man sich in einer Datenbank anmeldet, kann die Frontend-Anwendung unmittelbar eine SELECT-Operation bezüglich des Systemkatalogs ausführen, um die Tabellen zu ermitteln, auf die der Benutzer Zugriff hat. Mit den aus dem Systemkatalog abgerufenen Daten kann die Frontend-Anwendung dann einen »lokalen« Systemkatalog für den betreffenden Benutzer anlegen. Auf der Basis des lokalen Katalogs kann der Benutzer die jeweiligen Tabellen auswählen, die er abfragen möchte.
Systemingenieure sind Datenbankbenutzer, die etwa für das Modellieren und den Entwurf der Datenbank, die Anwendungsentwicklung und die Anwendungsverwaltung zuständig sind. Systemingenieure arbeiten direkt mit dem Systemkatalog, um den Entwicklungsprozeß zu verwalten und die existierenden Projekte zu warten. Der Zugriff kann auch über Frontend-Anwendungen, Entwicklungswerkzeuge und CASE-Werkzeuge realisiert werden. Diese Benutzer setzen den Systemkatalog ein, um Abfragen zu Objekten in Schemas, Abfragen zu Rollen und Privilegien von Anwendungen sowie Abfragen zu statischen Daten über das Schemawachstum zu stellen. Systemingenieure können anhand des Systemkatalogs auch Datenbankobjekte in einem angegebenen Schema rekonstruieren.
Datenbank-Administratoren (DBAs) stellen mit Sicherheit den größten Anteil der direkten Benutzer des Systemkatalogs. Im Gegensatz zu den beiden anderen Benutzergruppen, die gelegentlich den Systemkatalog direkt verwenden, müssen DBAs explizit den Systemkatalog in das Repertoire ihrer täglichen Routinearbeiten aufnehmen. Der Zugriff erfolgt gewöhnlich über eine SQL-Abfrage, läßt sich aber auch über Administrationswerkzeuge wie den Server Manager von Oracle vornehmen. Der DBA nutzt die Informationen des Systemkatalogs, um Benutzer und Ressourcen zu verwalten und letztendlich eine gut abgestimmte Datenbank zu realisieren.
Man sieht, daß alle Datenbankbenutzer mit dem Systemkatalog arbeiten. Vor allem aber kann eine relationale Datenbank ohne irgendeine Form von Systemkatalog gar nicht existieren.
Inhalt des Systemkatalogs
Dieser Abschnitt untersucht die Systemkataloge von zwei RDBMS-Herstellern, Oracle und Sybase. Obwohl beide Implementierungen eigene Spezifikationen für ihre Systemkataloge haben, dienen sie der gleichen Funktion. Stoßen Sie sich nicht an den abweichenden Namen für die Systemtabellen, verstehen Sie einfach das Konzept eines Systemkatalogs mit den darin enthaltenen Daten.
Der Systemkatalog von Oracle
Jede Tabelle muß einen Eigentümer haben. In einem Oracle-Systemkatalog heißt der Eigentümer der Systemtabellen SYS. Die Tabellen des Oracle-Systemkatalogs werden in drei grundlegende Kategorien eingeteilt: durch den Benutzer zugängliche Sichten, DBA-Sichten und dynamische Leistungstabellen, die ebenfalls als Sichten erscheinen. Die für den Benutzer zugänglichen Sichten erlauben dem Benutzer, Informationen über das eigene Datenbank-Konto (beispielsweise Privilegien) oder zu den erzeugten Tabellen einzuholen. Die DBA-Sichten unterstützten den Datenbank-Administrator bei seinen Routinearbeiten und erlauben dem DBA, die Benutzer und Objekte innerhalb der Datenbank zu verwalten. Die dynamischen Leistungstabellen in Oracle werden ebenfalls vom DBA benutzt und liefern einen tieferen Einblick für die Überwachung des Leistungsverhaltens einer Datenbank. Diese Sichten liefern Informationen wie Statistiken zur Verarbeitung, die dynamische Nutzung von Rollback-Segmenten, Speichernutzung usw. Die dynamischen Leistungstabellen sind alle mit dem Präfix V$ versehen.
Der Systemkatalog von Sybase
Wie in Oracle lautet der Eigentümer von Tabellen in einem Sybase-Systemkatalog SYS. Die Tabellen innerhalb des Systemkatalogs werden in zwei Kategorien eingeteilt: Systemtabellen und Datenbanktabellen.
Die Systemtabellen sind nur in der Master-Datenbank vorhanden. Diese Tabellen definieren Objekte (wie Tabellen und Indizes), die über mehrere Datenbanken einheitlich sind. Die zweite Gruppe von Tabellen in einem Sybase-SQL-Server-Systemkatalog sind die Datenbanktabellen. Diese Tabellen beziehen sich nur auf Objekte innerhalb jeder Datenbank.
Ein Blick in den Systemkatalog von Oracle
Die im vorliegenden Abschnitt dargestellten Beispiele zeigen, wie man Informationen aus dem Systemkatalog abruft. Sie sind anwendbar auf die meisten Benutzer einer relationalen Datenbank, das heißt Systemingenieure, Endbenutzer oder DBAs. Der Systemkatalog von Oracle verfügt über ein riesiges Feld von Systemtabellen und Sichten für alle Arten von Datenbankbenutzern. Aus diesem Grund wollen wir den Systemkatalog von Oracle näher beleuchten.
Benutzersichten
Benutzersichten sind Sichten des Systemkatalogs, die allen Datenbankbenutzern zugänglich sind. Ein Benutzer muß lediglich über das Systemprivileg CREATE SESSION verfügen, damit er eine Abfrage bezüglich einer Benutzersicht ausführen kann. Dieses Privileg sollten alle Benutzer haben.
Wer sind Sie?
Bevor Sie sich in das scheinbar unerschöpfliche Wissen einer Datenbank vertiefen, müssen Sie genau wissen, wer Sie sind (in bezug auf die Datenbank) und was Sie tun können. Die beiden folgenden Beispiele bringen SELECT-Anweisungen aus zwei Tabellen: eine zeigt Ihnen, wer Sie sind, die andere, wer die Datenbank mit Ihnen zusammen nutzt.
SQL> SELECT *
2 FROM USER_USERS;
USERNAME USER_ID DEFAULT_TABLESPACE TEMPORARY TABLESPACE CREATED
---------- ------ -------------------- -------------------- --------
FRANK 21 USERS TEMP 01.12.97
1 Zeile wurde ausgewählt.
|
Die hier dargestellte Ausgabe zeigt aus Platzgründen nur einen Ausschnitt der Tabelle. Zusätzlich sind noch die Spalten ACCOUNT_STATUS, LOCK_DATE, EXPIRY_DATE und EXTERNAL_NAME vorhanden. Die Bedeutung dieser Spalten finden Sie in der Oracle-Dokumentation. |
SQL> SELECT *
2 FROM ALL_USERS;
USERNAME USER_ID CREATED
------------------------------ --------- --------
SYS 0 16.07.97
SYSTEM 5 16.07.97
FRANK 21 01.12.97
DBSNMP 17 16.07.97
SCOTT 18 16.07.97
DEMO 19 16.07.97
PO8 20 29.11.97
BRYAN 22 06.12.97
RON 23 06.12.97
JACK 24 06.12.97
JILL 25 06.12.97
11 Zeilen ausgewählt.
Wie man den Ergebnissen der obigen Abfrage entnehmen kann, lassen sich mit der Sicht ALL_USERS alle Benutzer anzeigen, die in der Datenbank existieren. Allerdings zeigt die Sicht ALL_USERS nicht die gleichen spezifischen Informationen wie die vorherige Sicht (USER_USERS), da diese Angaben auf Benutzerebene nicht relevant sind. Auf der Systemebene sind dagegen detailliertere Informationen erforderlich.
Welche Privilegien haben Sie?
Sie wissen nun, wer Sie sind, und wollen natürlich auch wissen, was Sie tun können. Die Sichten USER_SYS_PRIVS und USER_ROLE_PRIVS geben Ihnen (dem Benutzer) eine gute Vorstellung darüber, welche Autorität Sie haben.
Anhand der Sicht USER_SYS_PRIVS können Sie Ihre Systemprivilegien untersuchen. Systemprivilegien beziehen sich nicht auf ein Objekt oder eine Objektgruppe, sondern erlauben Ihnen, bestimmte Operationen innerhalb der gesamten Datenbank zu erledigen.
SQL> SELECT *
2 FROM USER_SYS_PRIVS;
USERNAME PRIVILEGE ADM
------------------------------ ---------------------------------------- ---
FRANK UNLIMITED TABLESPACE NO
FRANK CREATE SESSION NO
2 Zeilen ausgewählt.
|
FRANK verfügt über zwei Privilegien auf Systemebene, außerhalb aller erteilten Rollen. Das zweite Privileg, CREATE SESSION, ist auch in einer Standardrolle von Oracle, CONNECT, enthalten. Darauf geht das nächste Beispiel ein. |
Die Sicht USER_ROLE_PRIVS liefert Informationen zu den Rollen, die man innerhalb der Datenbank erhalten hat. Datenbankrollen sind den Privilegien auf Systemebene sehr ähnlich. Eine Rolle erzeugt man fast in der gleichen Weise wie einen Benutzer und weist ihr dann Privilegien zu. Danach läßt sich die Rolle einem Benutzer zuteilen. Denken Sie daran, daß Privilegien auf Objektebene ebenfalls innerhalb einer Rolle enthalten sein können.
SQL> SELECT *
2 FROM USER_ROLE_PRIVS;
USERNAME GRANTED_ROLE ADM DEF OS_
------------------------------ ------------------------------ --- --- ---
FRANK CONNECT NO YES NO
FRANK RESOURCE NO YES NO
2 Zeilen ausgewählt.
Worauf haben Sie Zugriff?
Als nächstes möchten Sie vielleicht wissen, worauf Sie zugreifen können. Mittlerweile wissen Sie, wer Sie sind und welche Privilegien Sie haben. Aber nun interessiert es, woher Sie Ihre Daten bekommen. Diese Frage läßt sich anhand verschiedener Benutzersichten des Systemkatalogs beantworten. Dieser Abschnitt zeigt ein paar hilfreiche Sichten.
Die vielleicht grundlegendste Benutzersicht ist USER_CATALOG, die einen Katalog der Tabellen, Sichten, Synonyme und Sequenzen darstellt, deren Eigentümer der Benutzer ist.
SQL> SELECT *
2 FROM USER_CATALOG;
TABLE_NAME TABLE_TYPE
------------------------------ -----------
MAGAZINE_TBL TABLE
MAG_COUNTER SEQUENCE
MAG_VIEW VIEW
SPORTS TABLE
4 Zeilen ausgewählt.
In der Sicht ALL_CATALOG können Sie auch Tabellen anderer Eigentümer einsehen.
SQL> SELECT *
2 FROM ALL_CATALOG;
OWNER TABLE_NAME TABLE_TYPE
------------------------------ ------------------------------ -----------
SYS DUAL TABLE
PUBLIC DUAL SYNONYM
JILL GEHALT_SICHT VIEW
FRANK BANKKONTEN TABLE
FRANK FIRMA TABLE
FRANK RECHNUNGEN TABLE
JSMITH MAG_COUNTER SEQUENCE
JSMITH MAG_VIEW VIEW
JSMITH SPORTS TABLE
VJOHNSON TEST1 TABLE
10 Zeilen ausgewählt.
SQL> SELECT SUBSTR(OBJECT_TYPE,1,15) OBJECT_TYPE,
2 SUBSTR(OBJECT_NAME,1,30) OBJECT_NAME,
3 CREATED,
4 STATUS
5 FROM USER_OBJECTS
6 ORDER BY 1;
OBJECT_TYPE OBJECT_NAME CREATED STATUS
--------------- ------------------------------ -------- -------
INDEX KONTEN_IDX 10.12.97 VALID
INDEX TYP_IDX 10.12.97 VALID
TABLE BANKKONTEN 05.12.97 VALID
TABLE RECHNUNGEN 05.12.97 VALID
TABLE FIRMA 05.12.97 VALID
5 Zeilen ausgewählt.
SQL> SELECT TABLE_NAME, INITIAL_EXTENT, NEXT_EXTENT
2 FROM USER_TABLES;
TABLE_NAME INITIAL_EXTENT NEXT_EXTENT
------------------------------ -------------- -----------
BANKKONTEN 10240 10240
FIRMA 10240 10240
RECHNUNGEN 10240 10240
3 Zeilen ausgewählt.
|
Die Sicht USER_TABLES stellt noch wesentlich mehr Daten zur Verfügung. Die meisten Angaben beziehen sich auf Speicherinformationen. Hier wurden nur drei Spalten ausgewählt. |
Die Sicht ALL_TABLES ist für USER_TABLES das gleiche wie ALL_CATALOG für USER_CATALOG. Mit anderen Worten: ALL_TABLES erlaubt die Anzeige aller Tabellen, auf die Sie Zugriff haben, und nicht nur die Tabellen, die Sie besitzen. Die Sicht ALL_TABLES kann auch alle Tabellen einschließen, die in einem anderen Benutzerkatalog existieren.
SQL> SELECT SUBSTR(OWNER,1,15) OWNER,
2 SUBSTR(TABLE_NAME,1,25) TABLE_NAME,
3 SUBSTR(TABLESPACE_NAME,1,13) TABLESPACE
4 FROM ALL_TABLES;
OWNER TABLE_NAME TABLESPACE
--------------- ------------------------- -------------
SYSTEM SAMMLUNG USER_DATA
SYSTEM TEMP USER_DATA
SYSTEM BANKKONTEN USER_DATA
FRANK RECHNUNGEN SYSTEM
FRANK BANKKONTEN SYSTEM
FRANK FIRMA SYSTEM
6 Zeilen ausgewählt.
|
Auch hier wurden nur die gewünschten Informationen ausgewählt. Die Sicht ALL_TABLES bietet noch eine ganze Reihe anderer Spalten. |
Als Datenbankbenutzer können Sie das Wachstum von Tabellen und Indizes durch Abfrage der Sicht USER_SEGMENTS aus dem Systemkatalog überwachen. Wie der Name bereits verrät, liefert USER_SEGMENTS Informationen zur Speicherzuweisung für Datenbanksegmente, die zu den Objekten eines Benutzers gehören. Als SEGMENT_TYPE kann man INDEX PARTITION, TABLE PARTITION, TABLE, CLUSTER, INDEX, ROLLBACK, DEFERRED ROLLBACK, TEMPORARY oder CACHE angeben. Das folgende Beispiel ruft ausgewählte Informationen aus der Sicht USER_SEGMENTS ab.
SQL> SELECT SUBSTR(SEGMENT_NAME,1,30) SEGMENT_NAME,
2 SUBSTR(SEGMENT_TYPE,1,8) SEG_TYPE,
3 SUBSTR(TABLESPACE_NAME,1,25) TABLESPACE_NAME,
4 BYTES, EXTENTS
5 FROM USER_SEGMENTS
6 ORDER BY EXTENTS DESC;
SEGMENT_NAME SEG_TYPE TABLESPACE_NAME BYTES EXTENTS
------------------------------ -------- ------------------------- --------- ---------
RECHNUNGEN TABLE SYSTEM 4292608 7
BANKKONTEN TABLE SYSTEM 573440 4
KONTEN_IDX INDEX SYSTEM 344064 2
TYP_IDX INDEX SYSTEM 1589248 1
4 Zeilen ausgewählt.
|
Die Ausgabe in der obigen Abfrage wurde nach EXTENTS in fallender Richtung sortiert. Die Segmente mit dem größten Wachstum (eingenommene Erweiterungen) erscheinen zuerst in der Ergebnismenge. |
Nachdem Sie nun wissen, auf welche Tabellen Sie zugreifen können, interessiert es natürlich, was man mit jeder Tabelle anfangen kann. Ist man nur auf die Abfrage eingeschränkt, oder kann man eine Tabelle auch aktualisieren? Die Sicht ALL_TAB_PRIVS listet alle Privilegien auf, die man für die einzelnen Tabellen als Datenbankbenutzer hat.
SQL> SELECT SUBSTR(TABLE_SCHEMA,1,10) OWNER,
2 SUBSTR(TABLE_NAME,1,25) TABLE_NAME,
3 PRIVILEGE
4 FROM ALL_TAB_PRIVS;
OWNER TABLE_NAME PRIVILEGE
---------- ------------------------- --------------------------------------
SYS DUAL SELECT
JSMITH MAGAZINE_TBL SELECT
JSMITH MAGAZINE_TBL INSERT
JSMITH MAGAZINE_TBL UPDATE
JSMITH MAGAZINE_TBL DELETE
JSMITH SPORTS SELECT
JSMITH SPORTS INSERT
JSMITH SPORTS UPDATE
JSMITH SPORTS DELETE
VJOHNSON TEST1 SELECT
VJOHNSON TEST1 INSERT
VJOHNSON TEST1 UPDATE
VJOHNSON TEST1 DELETE
VJOHNSON HOBBIES SELECT
VJOHNSON CLASSES SELECT
|
Wie Sie sehen, können Sie die Daten in einigen Tabellen manipulieren, während Sie auf andere Tabellen nur Nur-Lese-Zugriff (nur SELECT) haben. |
Wenn man Objekte erzeugt, muß man gewöhnlich wissen, wo man sie in der Datenbank plaziert, sofern man nicht die Standardeinstellungen übernimmt. Eine Oracle-Datenbank gliedert sich in Tabellenbereiche, die jeweils Objekte speichern können. Jedem Tabellenbereich wird entsprechend dem im System verfügbaren Platz ein bestimmter Bereich auf dem Datenträger zugeordnet. Den Festplattenplatz fordert normalerweise der Systemadministrator (SA) an.
Die folgende Abfrage stammt aus der Sicht USER_TABLESPACES. Diese Sicht zeigt Ihre Tabellenbereiche, die Standardeinstellungen für die anfängliche und nächste Größe der im jeweiligen Tabellenbereich erzeugten Objekte sowie den Status.
SQL> SELECT SUBSTR(TABLESPACE_NAME,1,15) TABLESPACE_NAME,
2 INITIAL_EXTENT,
3 NEXT_EXTENT,
4 PCT_INCREASE,
5 STATUS
6 FROM USER_TABLESPACES;
TABLESPACE_NAME INITIAL_EXTENT NEXT_EXTENT PCT_INCREASE STATUS
--------------- -------------- ----------- ------------ ---------
SYSTEM 32768 16384 1 ONLINE
RBS 2097152 2097152 1 ONLINE
TEMP 114688 114688 1 ONLINE
TOOLS 32768 16384 1 ONLINE
USERS 32768 16384 1 ONLINE
5 Zeilen ausgewählt.
Manchmal genügt es nicht, die Tabellenbereiche zu kennen, auf die man zugreifen bzw. in denen man Tabellen anlegen kann. Gegebenenfalls muß man auch wissen, welche Grenzen innerhalb der Tabellenbereiche bestehen, damit man beim Erstellen und der Größenfestlegung der Objekte entsprechend Einfluß nehmen kann. Die Sicht USER_TS_QUOTAS bietet die notwendigen Angaben. Die nächste Abfrage zeigt die Einschränkungen des Benutzers für das Erzeugen von Objekten in der Datenbank an.
SQL> SELECT SUBSTR(TABLESPACE_NAME,1,30) TABLESPACE_NAME,
2 BYTES, MAX_BYTES
3 FROM USER_TS_QUOTAS;
TABLESPACE_NAME BYTES MAX_BYTES
------------------------------ --------- ---------
SYSTEM 0 0
TOOLS 5242880 16384
USERS 573440 -1
3 Zeilen ausgewählt.
|
Die Funktion SUBSTR erscheint in vielen der vorherigen Abfragen von Daten aus Katalogsichten. Mit den bisher behandelten Funktionen läßt sich die Lesbarkeit der abzufragenden Daten verbessern. Wenn man bestimmte Konventionen zur Benennung von Objekten in der Datenbank einhält, kann man übersichtliche Ausgaben erzeugen, die nicht über die Breite einer Seite hinausgehen. |
Die Beispiele haben nur einen geringen Teil der Sichten vorgeführt, über die ein normaler Datenbankbenutzer auf die Informationen des Systemkatalogs zugreifen kann. Auf jeden Fall sollten Sie die Dokumentation zu Ihrem Datenbanksystem studieren, um alle Möglichkeiten des Systemkatalogs ausschöpfen zu können. Denken Sie daran, daß man den Systemkatalog für die Verwaltung der Datenbankaktivitäten einsetzt. Auch wenn sich die Systemkataloge in den einzelnen Implementierungen unterscheiden, muß man doch wissen, wie man die erforderlichen Daten zur Ergänzung der eigenen Arbeit abrufen kann.
System-DBA-Sichten
Der Datenbank-Administrator wird in erster Linie mit den DBA-Sichten eines Oracle-Systemkatalogs arbeiten. Diese Sichten sind unschätzbar für die Produktivität jedes DBA. Wenn man diese Tabellen einem DBA vorenthält, wäre das so, als würde man einem Tischler den Hammer rauben.
Für den Zugriff auf die DBA-Tabellen ist das Systemprivileg SELECT ANY TABLE erforderlich, das in der DBA-Rolle enthalten ist. Nehmen wir zum Beispiel an, daß Sie JSMITH sind, der nicht das erforderliche Privileg hat, um aus den DBA-Tabellen auszuwählen.
SQL> SELECT *
2 FROM USER_ROLE_PRIVS;
USERNAME GRANTED_ROLE ADM DEF OS_
------------------------------ ------------------------------ --- --- ---
JSMITH CONNECT NO YES NO
JSMITH RESOURCE NO YES NO
2 Zeilen ausgewählt.
SQL> SELECT *
2 FROM SYS.DBA_ROLES;
FROM SYS.DBA_ROLES
*
FEHLER in Zeile 2:
ORA-00942: Tabelle oder View nicht vorhanden
Datenbankinformationen zum Benutzer
Die Sichten USER_USERS und ALL_USERS bieten ein Minimum an Informationen über die Benutzer. Die DBA-Sicht DBA_USERS (Eigentümer ist SYS) liefert Angaben zu allen Benutzern, wenn Sie über die DBA-Rolle oder das Privileg SELECT ANY TABLE verfügen. Das folgende Beispiel zeigt die Ausgabe der Sicht DBA_USERS.
SQL> SELECT SUBSTR(USERNAME,1,10) USERNAME,
2 SUBSTR(USER_ID,1,3) ID,
3 PASSWORD,
4 CREATED
5 FROM SYS.DBA_USERS;
USERNAME ID PASSWORD CREATED
---------- --- ------------------------------ --------
SYS 0 D4C5016086B2DC6A 16.07.97
SYSTEM 5 D4DF7931AB130E37 16.07.97
FRANK 21 39E3F186A9C3975E 01.12.97
DBSNMP 17 E066D214D5421CCC 16.07.97
SCOTT 18 F894844C34402B67 16.07.97
DEMO 19 4646116A123897CF 16.07.97
PO8 20 7E15FBACA7CDEBEC 29.11.97
JSMITH 26 E0981CA164650CAD 10.12.97
BRYAN 22 E3B3DC9B5DF33852 06.12.97
RON 23 4E3F825C3E9E18DB 06.12.97
JACK 24 F734693258873324 06.12.97
JILL 25 0D719190C6F172B6 06.12.97
12 Zeilen ausgewählt.
|
Das Beispiel zeigt nur einen Teil der in DBA_USERS enthaltenen Spalten. Beachten Sie, daß das Kennwort verschlüsselt ist. DBA_USERS ist die Hauptsicht, die der DBA zur Verwaltung der Benutzer verwendet. |
Datenbanksicherheit
Drei grundlegende Sichten des Systemkatalogs betreffen die Sicherheit. (Zur Darstellung umfassender Informationen kann man diese Sichten auch mit verwandten Sichten koppeln.) Die Sichten DBA_ROLES, DBA_ROLE_PRIVS und DBA_SYS_PRIVS geben Auskunft über Datenbankrollen, an Benutzer zugeteilte Rollen und den Benutzern gewährte Privilegien. Die folgenden Beispielabfragen ermitteln die Informationen zur Datenbanksicherheit aus dem Systemkatalog.
SQL> SELECT *
2 FROM SYS.DBA_ROLES;
ROLE PASSWORD
------------------------------ --------
CONNECT NO
RESOURCE NO
DBA NO
SNMPAGENT NO
SELECT_CATALOG_ROLE NO
EXECUTE_CATALOG_ROLE NO
DELETE_CATALOG_ROLE NO
AQ_USER_ROLE NO
IMP_FULL_DATABASE NO
EXP_FULL_DATABASE NO
RECOVERY_CATALOG_OWNER NO
AQ_ADMINISTRATOR_ROLE NO
12 Zeilen ausgewählt.
|
Die Sicht DBA_ROLES listet alle in der Datenbank erzeugten Rollen auf und zeigt an, ob zu diesen Rollen ein Kennwort gehört. |
SQL> SELECT *
2 FROM SYS.DBA_ROLE_PRIVS
3 WHERE GRANTEE = 'RJENNINGS';
GRANTEE GRANTED_ROLE ADM DEF
------------------------------ ------------------------------ --- ---
RJENNINGS CONNECT NO YES
RJENNINGS DBA NO YES
RJENNINGS RESOURCE NO YES
3 Zeilen ausgewählt.
SQL> SELECT *
2 FROM SYS.DBA_SYS_PRIVS
3 WHERE GRANTEE = 'RJENNINGS';
GRANTEE PRIVILEGE ADM
------------------------------ ---------------------------------------- ---
RJENNINGS CREATE SESSION NO
RJENNINGS UNLIMITED TABLESPACE NO
2 Zeilen ausgewählt.
Datenbankobjekte
Datenbankobjekte stehen ebenfalls im Mittelpunkt der DBA-Arbeit. Verschiedene Sichten innerhalb des Systemkatalogs liefern Informationen über Objekte, wie Tabellen und Indizes. Diese Sichten können allgemeine Angaben oder detaillierte Informationen zu den Objekten in der Datenbank enthalten.
SQL> SELECT *
2 FROM SYS.DBA_CATALOG
3 WHERE ROWNUM < 5;
OWNER TABLE_NAME TABLE_TYPE
------------------------------ ------------------------------ -----------
SYS IND$ TABLE
SYS FILE$ TABLE
SYS UNDO$ TABLE
SYS CLU$ TABLE
4 Zeilen ausgewählt.
Die folgende Abfrage zeigt, welche Objekttypen in einer bestimmten Datenbank existieren.
SQL> SELECT DISTINCT(OBJECT_TYPE)
2 FROM SYS.DBA_OBJECTS;
OBJECT_TYPE
---------------
CLUSTER
DATABASE LINK
INDEX
LIBRARY
PACKAGE
PACKAGE BODY
PROCEDURE
SEQUENCE
SYNONYM
TABLE
TYPE
UNDEFINED
VIEW
13 Zeilen ausgewählt.
Die Sicht DBA_TABLES gibt spezifische Informationen zu Datenbanktabellen. Die Angaben beziehen sich größtenteils auf die Speicherung.
SQL> SELECT SUBSTR(OWNER,1,8) OWNER,
2 SUBSTR(TABLE_NAME,1,25) TABLE_NAME,
3 SUBSTR(TABLESPACE_NAME,1,30) TABLESPACE_NAME
4 FROM SYS.DBA_TABLES
5 WHERE OWNER = 'JSMITH';
OWNER TABLE_NAME TABLESPACE_NAME
-------- ------------------------- ------------------------------
JSMITH MAGAZINE_TBL USERS
JSMITH HOBBY_TBL USERS
JSMITH ADDRESS_TBL SYSTEM
JSMITH CUSTOMER_TBL USERS
4 Zeilen ausgewählt.
JSMITH sollte unverzüglich aufgefordert werden, seine Tabelle in einen anderen geeigneten Tabellenbereich zu verschieben.
Die Sicht DBA_SYNONYMS liefert eine Liste aller Synonyme, die in der Datenbank existieren. DBA_SYNONYMS führt alle Datenbankbenutzer auf, während USER_SYNONYMS nur die privaten Synonyme des aktuellen Benutzers enthält.
SQL> SELECT SYNONYM_NAME,
2 SUBSTR(TABLE_OWNER,1,10) TAB_OWNER,
3 SUBSTR(TABLE_NAME,1,30) TABLE_NAME
4 FROM SYS.DBA_SYNONYMS
5 WHERE OWNER = 'JSMITH';
SYNONYM_NAME TAB_OWNER TABLE_NAME
------------------------------ ---------- ----------
TRIVIA_SYN VJOHNSON TRIVIA_TBL
1 Zeile wurde ausgewählt.
|
Die obige Ausgabe zeigt, daß JSMITH ein Synonym namens TRIVIA_SYN auf einer Tabelle namens TRIVIA_TBL angelegt hat. Der Eigentümer der Tabelle ist VJOHNSON. |
Nehmen wir an, daß Sie eine Liste aller Tabellen und deren Indizes haben möchten, die zu JSMITH gehören. Mit Hilfe von läßt sich dann eine Abfrage ähnlich der folgenden schreiben:
SQL> SELECT SUBSTR(TABLE_OWNER,1,10) TBL_OWNER,
2 SUBSTR(TABLE_NAME,1,30) TABLE_NAME,
3 SUBSTR(INDEX_NAME,1,30) INDEX_NAME
4 FROM SYS.DBA_INDEXES
5 WHERE OWNER = 'JSMITH'
6 AND ROWNUM < 5
7 ORDER BY TABLE_NAME;
TBL_OWNER TABLE_NAME INDEX_NAME
---------- ------------------------------ ------------
JSMITH ADDRESS_TBL ADDR_INX
JSMITH CUSTOMER_TBL CUST_INX
JSMITH HOBBY_TBL HOBBY_PK
JSMITH MAGAZINE_TBL MAGAZINE_INX
4 Zeilen ausgewählt.
|
Mit einer derartigen Abfrage lassen sich leicht alle Indizes eines bestimmten Schemas auflisten und den entsprechenden Tabellen zuordnen. |
SQL> SELECT SUBSTR(TABLE_NAME,1,15) TABLE_NAME,
2 SUBSTR(INDEX_NAME,1,30) INDEX_NAME,
3 SUBSTR(COLUMN_NAME,1,15) COLUMN_NAME,
4 COLUMN_POSITION
5 FROM SYS.DBA_IND_COLUMNS
6 WHERE TABLE_OWNER = 'JSMITH'
7 AND ROWNUM < 10
8 ORDER BY 1,2,3;
TABLE_NAME INDEX_NAME COLUMN_NAME COLUMN_POSITION
-------------- ------------------------------ -------------- ---------------
ADDRESS_TBL ADDR_INX PERS_ID 1
ADDRESS_TBL ADDR_INX NAME 2
ADDRESS_TBL ADDR_INX CITY 3
CUSTOMER_TBL CUST_INX CUST_ID 1
CUSTOMER_TBL CUST_INX CUST_NAME 2
CUSTOMER_TBL CUST_INX CUST_ZIP 3
HOBBY_TBL HOBBY_PK SAKEY 1
MAGAZINE_TBL MAGAZINE_INX ISSUE_NUM 1
MAGAZINE_TBL MAGAZINE_INX EDITOR 2
9 Zeilen ausgewählt.
SQL> SELECT TABLESPACE_NAME, STATUS
2 FROM SYS.DBA_TABLESPACES;
TABLESPACE_NAME STATUS
------------------------------ ---------
SYSTEM ONLINE
RBS ONLINE
TEMP ONLINE
TOOLS ONLINE
USERS ONLINE
DATA_TS ONLINE
INDEX_TS ONLINE
7 Zeilen ausgewählt.
|
Der Status ONLINE in dieser Abfrage weist darauf hin, daß alle Tabellenbereiche verfügbar sind. Wenn für einen Tabellenbereich der Status OFFLINE angegeben ist, sind die darin enthaltenen Datenbankobjekte (das heißt die Tabellen) nicht zugänglich. |
Welche Quoten sind JSMITH für die Tabellenbereiche zugewiesen, auf die er Zugriff hat? Anders gefragt: Wieviel Platz ist für die Datenbankobjekte von JSMITH verfügbar?
SQL> SELECT TABLESPACE_NAME,
2 BYTES,
3 MAX_BYTES
4 FROM SYS.DBA_TS_QUOTAS
5 WHERE USERNAME = 'JSMITH'
TABLESPACE_NAME BYTES MAX_BYTES
------------------------------ ---------- ----------
DATA_TS 134111232 -1
INDEX_TS 474390528 -1
2 Zeilen ausgewählt.
|
JSMITH hat auf die beiden, ihm zugänglichen Tabellenbereiche unbegrenzte Quoten. In diesem Fall steht der gesamte Tabellenbereich demjenigen zur Verfügung, der ihn zuerst beansprucht. Wenn zum Beispiel JSMITH den gesamten freien Platz in DATA_TS belegt, kann kein anderer Benutzer in diesem Tabellenbereich Objekte erzeugen. |
Datenbankwachstum
Dieser Abschnitt beschäftigt sich mit zwei Sichten, die das Wachstum einer Datenbank betreffen: DBA_SEGMENTS und DBA_EXTENTS. Die Sicht DBA_SEGMENTS liefert Angaben zu jedem Segment oder Objekt in der Datenbank, wie zum Beispiel Speicherzuweisung, belegter Platz und Umfang. Wenn eine Tabelle oder ein Index wächst und mehr Platz als in NEXT_EXTENT angegeben belegen muß, erhält die Tabelle die nächste Erweiterung (Extent). Wächst eine Tabelle auf diese Weise, wird sie normalerweise fragmentiert. DBA_EXTENTS liefert Informationen über alle Erweiterungen eines Segments.
SQL> SELECT SUBSTR(SEGMENT_NAME,1,30) SEGMENT_NAME,
2 SUBSTR(SEGMENT_TYPE,1,12) SEGMENT_TYPE,
3 BYTES,
4 EXTENTS,
5 FROM SYS.DBA_SEGMENTS
6 WHERE OWNER = 'TWILLIAMS'
7 AND ROWNUM < 5;
SEGMENT_NAME SEGMENT_TYPE BYTES EXTENTS
------------------------------ ------------ ---------- ----------
INVOICE_TBL TABLE 163840 10
COMPLAINT_TBL TABLE 4763783 3
HISTORY_TBL TABLE 547474996 27
HISTORY_INX INDEX 787244534 31
4 Zeilen ausgewählt.
Als nächstes sehen wir uns alle Extents der Tabelle INVOICE_TBL an.
SQL> SELECT SUBSTR(OWNER,1,10) OWNER,
2 SUBSTR(SEGMENT_NAME,1,30) SEGMENT_NAME,
3 EXTENT_ID,
4 BYTES
5 FROM SYS.DBA_EXTENTS
6 WHERE OWNER = 'TWILLIAMS'
7 AND SEGMENT_NAME = 'INVOICE_TBL'
8 ORDER BY EXTENT_ID;
OWNER SEGMENT_NAME EXTENT_ID BYTES
---------- ------------------------------ --------- ---------
TWILLIAMS INVOICE_TBL 0 16384
TWILLIAMS INVOICE_TBL 1 16384
TWILLIAMS INVOICE_TBL 2 16384
TWILLIAMS INVOICE_TBL 3 16384
TWILLIAMS INVOICE_TBL 4 16384
TWILLIAMS INVOICE_TBL 5 16384
TWILLIAMS INVOICE_TBL 6 16384
TWILLIAMS INVOICE_TBL 7 16384
TWILLIAMS INVOICE_TBL 8 16384
TWILLIAMS INVOICE_TBL 9 16384
10 Zeilen ausgewählt.
|
Dieses Beispiel zeigt alle Extents der Tabelle, die EXTENT_ID und die jeweilige Größe in Bytes an. Jeder Extent ist nur 16 Kbyte groß. Da es bereits 10 Extents gibt, empfiehlt sich der Neuaufbau der Tabelle. Dabei sollte man INITIAL_EXTENT entsprechend vergrößern, um die Platznutzung zu optimieren. Nach dem Neuaufbau der Tabelle passen alle Daten in einen einzelnen Extent, so daß die Tabelle nicht mehr fragmentiert ist. |
Zugewiesener Platz
Oracle reserviert mit Hilfe sogenannter »Datendateien« den Platz für die Datenbank. Der Platz ist einem Tabellenbereich in logischen Einheiten zugeordnet, während die Datendateien die physikalischen Einheiten der Tabellenbereiche darstellen. In anderen Implementierungen sind die Daten letztendlich auch in Datendateien enthalten, auch wenn diese einen anderen Namen tragen. Mit der Sicht DBA_DATA_FILES können Sie sich die tatsächliche Zuordnung der Datendateien zu einem Tabellenbereich ansehen.
SQL> SELECT SUBSTR(TABLESPACE_NAME,1,20) TABLESPACE_NAME,
2 SUBSTR(FILE_NAME,1,40) FILE_NAME,
3 BYTES
4 FROM SYS.DBA_DATA_FILES;
TABLESPACE_NAME FILE_NAME BYTES
-------------------- ---------------------------------------- ---------
USER_DATA F:\ORAWIN95\DATABASE\USR1ORCL.ORA 3145728
ROLLBACK_DATA F:\ORAWIN95\DATABASE\RBS1ORCL.ORA 5242880
TEMPORARY_DATA F:\ORAWIN95\DATABASE\TMP1ORCL.ORA 2097152
SYSTEM F:\ORAWIN95\DATABASE\SYS1ORCL.ORA 20971520
MIST F:\ORASQL\MIST.DAT 20971520
5 Zeilen ausgewählt.
|
Mit einer derartigen Abfrage können Sie sich über den Platzbedarf aller Tabellenbereiche in der Datenbank informieren. Beachten Sie, daß die Namen der Datendateien mit dem zugehörigen Tabellenbereich korrespondieren. |
Verfügbarer Platz
Wie das folgende Beispiel zeigt, gibt die Sicht DBA_FREE_SPACE darüber Auskunft, wie viel freier Platz in jedem Tabellenbereich verfügbar ist.
SQL> SELECT TABLESPACE_NAME, SUM(BYTES)
2 FROM SYS.DBA_FREE_SPACE
3 GROUP BY TABLESPACE_NAME;
TABLESPACE_NAME SUM(BYTES)
------------------------------ ----------
MIST 20969472
ROLLBACK_DATA 3244032
SYSTEM 2848768
TEMPORARY_DATA 2095104
USER_DATA 2201600
5 Zeilen ausgewählt.
|
Das obige Beispiel listet den gesamten freien Platz für jeden Tabellenbereich auf. Man kann auch die einzelnen freien Segmente anzeigen, indem man einfach die Bytes aus DBA_FREE_SPACE auswählt und sie nicht mit SUM(BYTES) summiert. |
Rollback-Segmente
Da Bereiche für das Rückgängigmachen von Transaktionen entscheidenden Einfluß auf die Datenbankleistung haben, muß man die verfügbaren Rollback-Segmente kennen. Diese Angaben liefert die Sicht DBA_ROLLBACK_SEGS.
SQL> SELECT OWNER,
2 SEGMENT_NAME
3 FROM SYS.DBA_ROLLBACK_SEGS;
OWNER SEGMENT_NAME
------ ------------------------------
SYS SYSTEM
SYS RB_TEMP
PUBLIC RB1
PUBLIC RB2
PUBLIC RB3
PUBLIC RB4
PUBLIC RB5
PUBLIC RB6
PUBLIC RB7
PUBLIC RB8
PUBLIC RB9
PUBLIC RB10
PUBLIC RB11
PUBLIC RB12
PUBLIC RB13
PUBLIC RB14
PUBLIC RB15
PUBLIC RB16
18 Zeilen ausgewählt.
|
Dieses Beispiel führt eine einfache Auswahl aus, um alle Rollback-Segmente nach dem Namen aufzulisten. Zur Beurteilung stehen noch zahlreiche andere Daten zur Verfügung. |
Sichten der dynamischen Leistung
Mit Oracle arbeitende DBAs greifen häufig auf Sichten für die dynamische Leistung zu, da diese mehr Details zu den internen Leistungsdaten bringen als andere Sichten des Systemkatalogs. (Die DBA-Sichten enthalten einige dieser Informationen.)
Diese Sichten liefern umfangreiche Einzeldaten, die von der jeweiligen Implementierung abhängig sind. Der vorliegende Abschnitt bietet lediglich einen Überblick über die Informationstypen eines bestimmten Systemkatalogs.
Sitzungsinformationen
Das nachstehende Beispiel zeigt einen DESCRIBE-Befehl der V$SESSION-Sichten. (DESCRIBE ist ein Befehl von SQL*Plus, auf den Tag 20 eingeht.) Die Ausgabe erläutert die Spalten, die in der Sicht enthalten sind.
SQL> DESCRIBE V$SESSION
Name Null? Type
------------------------------- -------- ----
SADDR RAW(4)
SID NUMBER
SERIAL# NUMBER
AUDSID NUMBER
PADDR RAW(4)
USER# NUMBER
USERNAME VARCHAR2(30)
COMMAND NUMBER
TADDR VARCHAR2(8)
LOCKWAIT VARCHAR2(8)
STATUS VARCHAR2(8)
SERVER VARCHAR2(9)
SCHEMA# NUMBER
SCHEMANAME VARCHAR2(30)
OSUSER VARCHAR2(15)
PROCESS VARCHAR2(9)
MACHINE VARCHAR2(64)
TERMINAL VARCHAR2(10)
PROGRAM VARCHAR2(48)
TYPE VARCHAR2(10)
SQL_ADDRESS RAW(4)
SQL_HASH_VALUE NUMBER
PREV_SQL_ADDR RAW(4)
PREV_HASH_VALUE NUMBER
MODULE VARCHAR2(48)
MODULE_HASH NUMBER
ACTION VARCHAR2(32)
ACTION_HASH NUMBER
CLIENT_INFO VARCHAR2(64)
FIXED_TABLE_SEQUENCE NUMBER
ROW_WAIT_OBJ# NUMBER
ROW_WAIT_FILE# NUMBER
ROW_WAIT_BLOCK# NUMBER
ROW_WAIT_ROW# NUMBER
LOGON_TIME DATE
LAST_CALL_ET NUMBER
Informationen zu den aktuellen Datenbanksitzungen lassen sich über eine SELECT-Anweisung bezüglich V$SESSION wie im folgenden Beispiel ermitteln.
SQL> SELECT USERNAME, COMMAND, STATUS
2 FROM V$SESSION
3 WHERE USERNAME IS NOT NULL;
USERNAME COMMAND STATUS
------------------------------ --------- --------
TWILLIAMS 3 ACTIVE
JSMITH 0 INACTIVE
2 Zeilen ausgewählt.
|
TWILLIAMS ist in der Datenbank angemeldet und führt eine SELECT-Abfrage aus, die durch den Befehl 3 (COMMAND 3) repräsentiert wird. |
JSMITH ist lediglich in der Datenbank angemeldet. Seine Sitzung ist nicht aktiv, und er führt keinerlei Befehle aus. Die Kennzeichnung der Befehle im Systemkatalog entnehmen Sie bitte der Dokumentation zu Ihrer Datenbank. Zu den Befehlen gehören , INSERT, UPDATE, DELETE, CREATE TABLE und DROP TABLE.
Leistungsstatistik
Im Systemkatalog finden sich auch Daten, die Angaben zur Leistungsstatistik außerhalb des Bereichs von Benutzersitzungen liefern. Diese Art von Daten ist stärker von der Implementierung abhängig als andere Sichten, die heute behandelt wurden.
Zu den Leistungsstatistiken gehören Daten wie Lese-/Schreibraten, erfolgreiche Treffer in Tabellen, Verwendung des globalen Systembereichs, Nutzung des Speicher-Caches, detaillierte Informationen über das Rollback-Segment, Einzelheiten zum Transaktionsprotokoll sowie Sperren und Wartezustände von Tabellen. Die Quelle der Informationen ist nahezu unerschöpflich.
Die Tabelle PLAN_TABLE
Der Oracle-Befehl EXPLAIN PLAN zur Untersuchung von SQL-Anweisungen verwendet PLAN_TABLE als Standardtabelle. (Siehe dazu Tag 15.) Das Erstellen dieser Tabelle übernimmt das Oracle-Skript UTLXPLAN.SQL, das bei der Installation der Software auf den Server kopiert wird. Der Befehl EXPLAIN PLAN schreibt die Informationen zum jeweiligen Objekt und den Ausführungsplan einer SQL-Anweisung in die Tabelle PLAN_TABLE.
Zusammenfassung
Obwohl die Einzelheiten des Systemkatalogs stark von der Implementierung abhängen, bleibt der Inhalt vom Konzept her in allen relationalen Datenbanken der gleiche. Es sind zwar die Syntax und die Regeln des konkreten Datenbank-Managementsystems zu beachten, die heutigen Beispiele sollten Ihnen aber zumindest das Selbstvertrauen geben, daß Sie Ihren Systemkatalog abfragen und damit kreativ arbeiten können.
|
Die Untersuchung des Systemkatalogs ist ein Abenteuer, auf das Sie sich einlassen müssen, um den Systemkatalog effektiv nutzen zu können. |
Fragen & Antworten
Frage:
Warum sollte ich auf Sichten und Tabellen des Systemkatalogs zurückgreifen?
Antwort:
Anhand der Sichten des Systemkatalogs läßt sich der Aufbau einer Datenbank am genauesten erkunden. Den Tabellen entnehmen Sie, worauf Sie zugreifen können und welche Privilegien Sie haben. Außerdem bieten diese Tabellen die Möglichkeit, verschiedene andere Datenbankereignisse, wie etwa Benutzerprozesse, und die Datenbankleistung zu überwachen.
Frage:
Wie wird der Systemkatalog erzeugt?
Antwort:
Der Systemkatalog wird bei der Initialisierung der Datenbank angelegt. Oracle liefert verschiedene Skripts, die beim Erstellen einer Datenbank ablaufen und alle erforderlichen Tabellen und Sichten für den Systemkatalog der betreffenden Datenbank erzeugen.
Frage:
Wie wird der Systemkatalog aktualisiert?
Antwort:
Das RDBMS aktualisiert den Systemkatalog intern während der laufenden Operationen. Wenn man die Struktur einer Tabelle ändert, werden die entsprechenden Änderungen intern am Systemkatalog vorgenommen. Man sollte niemals versuchen, irgendwelche Tabellen im Systemkatalog auf eigene Faust zu aktualisieren. Beschädigungen der Datenbank könnten die Folge sein.
Frage:
Wie kann ich ermitteln, wer was in der Datenbank gemacht hat?
Antwort:
Normalerweise erlauben Tabellen oder Sichten in einem Systemkatalog die Revision der Benutzeraktivitäten.
Workshop
Kontrollfragen
1. Wie kann man in Oracle ermitteln, welche Tabellen und Sichten man besitzt?
2. Welche Arten von Informationen werden im Systemkatalog gespeichert?
3. Wie kann man Leistungsstatistiken nutzen?
4. Nennen Sie einige Datenbankobjekte.
Übung
Nehmen wir an, daß Sie eine kleine bis mittlere Datenbank verwalten. Zu Ihren Verantwortlichkeiten gehört die Entwicklung und die Verwaltung der Datenbank. Ein anderer Benutzer fügt große Datenmengen in eine Tabelle ein und erhält einen Fehler, der auf mangelnden Platz hinweist. Nun müssen Sie die Ursache für dieses Problem ermitteln. Muß die Quote des Benutzers für den Tabellenbereich erhöht werden, oder müssen Sie mehr Platz für den Tabellenbereich reservieren? Erstellen Sie eine Liste mit den erforderlichen Schritten, um die benötigten Informationen aus dem Systemkatalog zusammenzutragen. Auf die Angabe spezieller Tabellen- oder Sichtnamen können Sie verzichten.