2008-12-30

ORACLE PRIVILEGES

uprawnienia:
SELECT * FROM user_role_privs; -- role aktualnego usera
SELECT * FROM user_sys_privs; -- uprawnienia systemowe aktualnego usera
SELECT * FROM role_sys_privs order by 1; -- uprawnienia systemowe powiązane z rolami
SELECT * FROM session_privs;
SELECT * FROM session_roles;
SELECT * FROM dba_roles; -- wypisanie ról
SELECT * FROM dba_role_privs; -- powiązanie ról z userami
SELECT * FROM dba_sys_privs; -- powiązanie uprawnienień systemowych z userami
SELECT b.grantee,a.role,a.privilege FROM role_sys_privs a,dba_role_privs b WHERE b.grantee=upper('&user') AND a.role=b.granted_role UNION ALL SELECT c.grantee,null,c.privilege FROM dba_sys_privs c WHERE c.grantee=upper('&user') ORDER BY 2,3;
SELECT * FROM dba_tab_privs; -- wszystkie prawa do obiektów w bazie także do procedur,funkcji,pakietów
SELECT * FROM role_tab_privs WHERE role=''; --prawa do obiektów dla roli
katalogi:
SELECT * FROM dba_tab_privs WHERE table_name = '[katalog]';
przykłady:
SELECT distinct privilege FROM dba_sys_privs where privilege like '%[text]%';
SELECT * FROM dba_role_privs WHERE grantee IN ('USER1','USER2') order by 1,2; #role przypisane do usera
SELECT * FROM role_sys_privs where role = '[role_name]' #uprawnienia przypisane do roli
użytkownicy źródła:
set long 2000
SELECT dbms_metadata.get_granted_ddl('ROLE_GRANT','SYSTEM') FROM DUAL;
SELECT dbms_metadata.get_granted_ddl('SYSTEM_GRANT','SYSTEM') FROM DUAL;
SELECT dbms_metadata.get_granted_ddl('OBJECT_GRANT','SYSTEM') FROM DUAL;
uwaga: jak nie będzie uprawnień to wywali błąd ORA-31608
case study:
-- create new role, add priviliges to it, grant role to user:
create role new_role;

begin
  for x in (SELECT object_name FROM ALL_OBJECTS WHERE object_type = 'TABLE' and owner = 'OWNER_NAME') loop
    execute immediate 'GRANT select,insert,update,delete on ea_test.'|| x.object_name || ' to NEW_ROLE';
  end loop;
end;

grant NEW_ROLE to username
-- check:
SELECT grantee,granted_role FROM dba_role_privs WHERE granted_role = upper('new_role');
SELECT table_name,column_name,privilege,grantable FROM role_tab_privs WHERE role = upper('new_role') order by table_name;

2008-12-19

WINSHIT MANAGEMENT

proteza uptime
net statistics server
proteza mtr
pathping
proteza grep
for %g in (file.*) do (find /n /i "text" "%g")
ustawienie IP
netsh interface ip set address "Local Area Connection" dhcp
- zmiana static IP na dhcp
netsh interface ip set address "Local Area Connection" static [IP] [mask] [gateway] 1
sprawdzenie IP
netsh interface ip show config
sprawdzenie usług w tle:
tasklist
tasklist /svc
usługi:
HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services - [Start 2-Automatic, 3-Manual, 4-Disabled]
zarządaznie usługami zdalnie:
net use [dysk:] \\[server]\[udzial] /user:[user] [haslo]
sc \\[server] start|stop [usluga]
net use /delete [dysk:]
usługi sieciowe:
netstat -naob
firewall:
sc query ipnat
netsh firewall show config
netsh firewall show state
wyłączenie udostępniania udziałów:
HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\LanManServer\Parameters
AutoShareServer=dword:00000000
AutoShareWks=dword:00000000
net stop server
net start server

Usuwanie plików skrypt vbs:
Dim fso, l_logFiles, logFile,files
Set fso = CreateObject("Scripting.FileSystemObject")
Set files = fso.GetFolder("d:\[log_dir]")
Set l_logFiles = files.Files
For Each logFile in l_logFiles
If DateDiff("d", logFile.DateLastModified, Now) > 30 Then
logFile.Delete
end if
next

2008-12-17

ORACLE SPACE MANAGEMENT

sprawdzanie wielkości poszczególnych segmentów:
SELECT segment_name,tablespace_name,bytes/(1024*1024) as totsize_bytes FROM DBA_SEGMENTS WHERE owner='[user]' order by totsize_bytes;
w przypadku obiektów LOB, zapytania szczegółowe należy odnieść do DBA_LOBS
sprawdzanie wielkości segmentów wraz z lobami:
SELECT a.tablespace_name,a.segment_name,b.table_name,b.column_name,a.bytes/(1024*1024) as MB,c.comments FROM dba_segments a,dba_lobs b,all_tab_comments c WHERE a.owner=upper('[user]') and a.segment_name=b.segment_name(+) and b.table_name=c.table_name(+) and b.owner=c.owner(+) order by MB desc;
sprawdzanie liczby segmentow w przestrzeniach tabel dla określonego usera:
SELECT tablespace_name,count(*) FROM DBA_SEGMENTS WHERE owner=[user] GROUP BY tablespace_name;
shrink tabeli (pamiętać aby nie było tam sesji aktywnych, nie shrinkuje lobow):
ALTER TABLE [table] ENABLE ROW MOVEMENT;
tabele z indexami:
ALTER TABLE [table] SHRINK SPACE CASCADE;
nie zmienia hwm musi nastąpić po niej normalny shrink:
ALTER TABLE [table] SHRINK SPACE COMPACT;
ALTER TABLE [table] SHRINK PACE;
ALTER TABLE [table] DISABLE ROW MOVEMENT;
shrink segmentu lobow (pamietac aby nie było tam sesji aktywnych):
ALTER TABLE [table] MODIFY LOB([column]) (SHRINK SPACE)update pustego loba:UPDATE [table] SET [column] = EMPTY_BLOB()|EMPTY_CLOB();
szacowanie plików do zmniejszenia:
SELECT 'alter database datafile ''' || file_name || ''' resize ' || ceil( (nvl(hwm,1)*8192)/1024/1024 ) || 'm;' cmd FROM dba_data_files a,( SELECT file_id, max(block_id+blocks-1) hwm FROM dba_extents GROUP BY file_id ) b WHERE a.file_id = b.file_id(+) AND ceil(blocks*8192/1024/1024)-ceil((nvl(hwm,1)*8192)/1024/1024 ) > 0;
sprawdzenie rozkładu bloków w segmencie:
variable unf_blocks number;
variable unf_bytes number;
variable full_blocks number;
variable full_bytes number;
variable fs1_blocks number;
variable fs1_bytes number;
variable fs2_blocks number;
variable fs2_bytes number;
variable fs3_blocks number;
variable fs3_bytes number;
variable fs4_blocks number;
variable fs4_bytes number;

begin
  dbms_space.space_usage('[user]','[segment]',
  '[TABLE|INDEX|CLUSTER|LOB]',
  :unf_blocks, :unf_bytes,
  :fs1_blocks, :fs1_bytes,
  :fs2_blocks, :fs2_bytes,
  :fs3_blocks, :fs3_bytes,
  :fs4_blocks, :fs4_bytes,
  :full_blocks, :full_bytes);
end;
/
print unf_blocks; --liczba niesformatowanych blokow
print unf_bytes;
print fs4_blocks; --liczba blokow ktore maja od 75-100% wolnej przestrzeni
print fs4_bytes;
print fs3_blocks; --liczba blokow ktore maja od 50-75% wolnej przestrzeni
print fs3_bytes;
print fs2_blocks; --liczba blokow ktore maja od 25-50% wolnej przestrzeni
print fs2_bytes;
print fs1_blocks; --liczba blokow ktore maja od 0-25% wolnej przestrzeni
print fs1_bytes;
print full_blocks; --liczba pelnych blokow
print full_bytes;
procedura do sprawdzania:
CREATE OR REPLACE PROCEDURE SYS.SEGMENT_USAGE(
val_owner varchar2,
val_segment varchar2,
val_type varchar2) is
l_fs1_bytes number;
l_fs2_bytes number;
l_fs3_bytes number;
l_fs4_bytes number;
l_fs1_blocks number;
l_fs2_blocks number;
l_fs3_blocks number;
l_fs4_blocks number;
l_full_bytes number;
l_full_blocks number;
l_unformatted_bytes number;
l_unformatted_blocks number;

begin
  dbms_space.space_usage(
  segment_owner => val_owner,
  segment_name => val_segment,
  segment_type => val_type,
  fs1_bytes => l_fs1_bytes,
  fs1_blocks => l_fs1_blocks,
  fs2_bytes => l_fs2_bytes,
  fs2_blocks => l_fs2_blocks,
  fs3_bytes => l_fs3_bytes,
  fs3_blocks => l_fs3_blocks,
  fs4_bytes => l_fs4_bytes,
  fs4_blocks => l_fs4_blocks,
  full_bytes => l_full_bytes,
  full_blocks => l_full_blocks,
  unformatted_blocks => l_unformatted_blocks,
  unformatted_bytes => l_unformatted_bytes
  );

  dbms_output.put_line(' FS1 Blocks = '||l_fs1_blocks||' Bytes = '||l_fs1_bytes);
  dbms_output.put_line(' FS2 Blocks = '||l_fs2_blocks||' Bytes = '||l_fs2_bytes);
  dbms_output.put_line(' FS3 Blocks = '||l_fs3_blocks||' Bytes = '||l_fs3_bytes);
  dbms_output.put_line(' FS4 Blocks = '||l_fs4_blocks||' Bytes = '||l_fs4_bytes);
  dbms_output.put_line('Full Blocks = '||l_full_blocks||' Bytes = '||l_full_bytes);

end;
/

wywolanie powyższej procedury:
BEGIN
  FOR rec in (SELECT segment_name FROM dba_segments WHERE owner='' AND segment_type='[type]'   ORDER BY segment_name)
  LOOP
    BEGIN
      DBMS_OUTPUT.PUT_LINE(rec.segment_name);
      SEGMENT_USAGE('[user]',rec.segment_name,'[user]');
    END;
  END LOOP;
END;
optymalizacja wszystkich tabel:
DECLARE
  dupa varchar2(200);BEGIN for rec in (SELECT segment_name FROM dba_segments WHERE owner='[user]' and segment_type='[TABLE|INDEX]' ) LOOP
BEGIN
  DBMS_UTILITY.EXEC_DDL_STATEMENT(' ALTER TABLE TEST.'||rec.segment_name||' MOVE');
  dupa := rec.segment_name;
  DBMS_OUTPUT.PUT_LINE ('ZOPTYMALIZOWALEM SEGMENT: '||dupa||'');
  EXCEPTION WHEN OTHERS THEN
    DBMS_OUTPUT.PUT_LINE (dupa);
END; 
END LOOP;
END;
sprawdzenie które segmenty znajdują się na końcu przestrzeni tabel:
SELECT * FROM (SELECT owner, segment_name, segment_type, block_id FROM dba_extents WHERE file_id = [file_id] ORDER BY block_id DESC ) WHERE rownum = 5;
sprawdzanie HWM w pliku:
SELECT file_id, max(block_id+blocks-1) hwm FROM dba_extents where file_id = [file_id] group by file_id;
sprawdzenie segmentow których block_id sa ostatnie w pliku:
SELECT * FROM (SELECT segment_name, max(block_id) FROM dba_extents WHERE file_id=[file_id] GROUP BY segment_name ORDER BY max(block_id) desc ) WHERE rownum 10;
sprawdzanie block_id dla określonego segmentu:
SELECT segment_name, max(block_id) FROM dba_extents WHERE file_id=21 AND segment_name='[segment]' GROUP BY segment_name
sprawdzanie nr bloków dla lobów:
SELECT tablespace_name,(SELECT max(block_id+blocks-1) FROM dba_extents where segment_name = b.segment_name group by segment_name) last_block, c.header_block,c.blocks,b.segment_name,a.index_name,a.index_type,a.table_name,b.column_name FROM dba_indexes a,dba_lobs b,dba_segments c
where a.index_name=b.index_name and b.segment_name=c.segment_name and a.owner=upper('[owner]') and a.index_type=upper('lob');

2008-12-01

ORACLE SIMPLE RECOVERY

Należy pamiętać że nowa baza mimo że zmienimy nazwę będzie miała taki sam DBID czyli nie możemy jej dopisać do RMAN-a z bazą źródłową, sytucację tę możemy zmienić stosując polecenie NID

1. Na bazie źródłowej w trybie mount wygenerować skrypt tworzący pliki kontrolne:
ALTER DATABASE BACKUP CONTROLFILE TO TRACE AS '[path]'

2. Skopiować:
- wszystkie pliki danych
- plik pfile
- plik haseł
- nie kopiować plików redologs oraz controlfiles (można także pominąć pliki przestrzeni TEMP i UNDO jednak trzeba będzie potem kombinować)

3. Edycja pliku PFILE:
- ścieżki do plików logów
- ścieżki dla plików trace
- nazwa bazy

4. Edycja skryptu tworzącego pliki kontrolne:
- ! usunąć puste linie
- ścieżki plików danych
- ścieżka pliku TEMP
- nazwa bazy
- zamiana lini REUSE DATABASE na SET DATABASE
- usunąć linię RECOVER DATABASE USING BACKUP CONTROLFILE

5. Stworzyć w nowej lokalizacji odpowiednie katalogi zgodne z powyższymi

6. W w$ utworzyć service dla nowej bazy
oradim -new -sid [nowy_sid] -startmode M -pfile [init_file]

7. W razie potrzeby stworzyć nowy plik haseł:
orapwd file=PWD[db_name] password=[pass] entries=[max_liczba_wpisów]

8. Ustawić zmienną ORACLE_HOME i ORACLE_SID

9. wykonać skrypt tworzący nowe pliki kontrolne

10. otworzyć bazę z wyczyszczonymi redologami
ALTER DATABASE OPEN RESETLOGS

W przypadku braku pliku UNDO należy zakomentować w pliku INIT wszelkie zapisy dotyczące UNDO następnie otworzyć bazę z wyczyszczonymi logami, usunąć przestrzeń UNDO i stworzyć ją na nowo poleceniem:
CREATE UNDO TABLESPACE [nazwa z pliku init] DATAFILE '[path]' SIZE [nr]M;

12. ustawić przestrzeń tymczasową
ALTER TABLESPACE TEMP ADD TEMPFILE '[path]' SIZE 41943040 REUSE AUTOEXTEND ON NEXT 655360 MAXSIZE 32767M;

W przypadku gdy była odtwarzana przestrzeń UNDO odkomentować wpisy w INIT

Do zmiany DBID wykonujemy:
1. uruchamiamy bazę w trybie MOUNT
2a. zmiana nazwy bazy i DBID:
nid target=sys/[passwd]@[dbsid] dbname=[newname]
2b. zmiana DBID:
nid target=/
3. zamykamy bazę
4. jeżeli zmienialiśmy nazwę to zmienić w pliku INIT
5. jeżeli zmienialiśmy nazwę to zmienić nazwę pliku haseł

Jeżeli chcemy zmienić tylko nazwę bazy:
nid target=sys/[passwd]@[dbsid] dbname=[newname] setname=yes logfile=log.out