Highload++ സൈബീരിയ 2019-ന്റെ പാത പിന്തുടരുന്നു - Oracle-ൽ 8 ജോലികൾ

ഹലോ!

ജൂൺ 24-25 തീയതികളിൽ, ഹൈലോഡ്++ സൈബീരിയ 2019 കോൺഫറൻസ് നോവോസിബിർസ്കിൽ നടന്നു. ഞങ്ങളുടെ ആളുകളും അവിടെ ഉണ്ടായിരുന്നു. റിപ്പോർട്ട് “ഒറാക്കിൾ കണ്ടെയ്‌നർ ഡാറ്റാബേസുകളും (CDB/PDB) സോഫ്റ്റ്‌വെയർ വികസനത്തിനുള്ള അവയുടെ പ്രായോഗിക ഉപയോഗവും”, ഞങ്ങൾ കുറച്ച് കഴിഞ്ഞ് ഒരു ടെക്‌സ്‌റ്റ് പതിപ്പ് പ്രസിദ്ധീകരിക്കും. അത് രസകരമായിരുന്നു, നന്ദി ഒലെഗ്ബുനിൻ സംഘടനയ്ക്കും അതുപോലെ വന്ന എല്ലാവർക്കും.

ഈ പോസ്റ്റിൽ, ഞങ്ങളുടെ ബൂത്തിൽ ഉണ്ടായ പ്രശ്‌നങ്ങൾ നിങ്ങളുമായി പങ്കിടാൻ ഞങ്ങൾ ആഗ്രഹിക്കുന്നു, അതുവഴി നിങ്ങളുടെ ഒറാക്കിൾ പരിജ്ഞാനം പരീക്ഷിക്കാനാകും. കട്ടിന് താഴെ 8 പ്രശ്നങ്ങൾ, ഉത്തര ഓപ്ഷനുകൾ, വിശദീകരണം എന്നിവയുണ്ട്.

ഇനിപ്പറയുന്ന സ്ക്രിപ്റ്റ് എക്സിക്യൂട്ട് ചെയ്യുന്നതിന്റെ ഫലമായി നമുക്ക് കാണാൻ കഴിയുന്ന പരമാവധി സീക്വൻസ് മൂല്യം എന്താണ്?

create sequence s start with 1;
 
select s.currval, s.nextval, s.currval, s.nextval, s.currval
from dual
connect by level <= 5;

• 1
• 5
• 10
• 25
• ഇല്ല, ഒരു പിശക് ഉണ്ടാകും

മറുപടിഒറാക്കിൾ ഡോക്യുമെന്റേഷൻ അനുസരിച്ച് (8.1.6 ൽ നിന്ന് ഉദ്ധരിച്ചത്):
ഒരൊറ്റ SQL പ്രസ്താവനയ്ക്കുള്ളിൽ, Oracle ഒരു വരിയിൽ ഒരിക്കൽ മാത്രം ക്രമം വർദ്ധിപ്പിക്കും. ഒരു സ്‌റ്റേറ്റ്‌മെന്റിൽ NEXTVAL എന്ന സീക്വൻസിനായി ഒന്നിലധികം റഫറൻസ് അടങ്ങിയിട്ടുണ്ടെങ്കിൽ, Oracle ഒരു തവണ ക്രമം വർദ്ധിപ്പിക്കുകയും NEXTVAL-ന്റെ എല്ലാ സംഭവങ്ങൾക്കും ഒരേ മൂല്യം നൽകുകയും ചെയ്യുന്നു. ഒരു പ്രസ്താവനയിൽ CURRVAL, NEXTVAL എന്നിവയിലേക്കുള്ള റഫറൻസുകൾ അടങ്ങിയിട്ടുണ്ടെങ്കിൽ, Oracle സീക്വൻസ് വർദ്ധിപ്പിക്കുകയും CURRVAL, NEXTVAL എന്നിവയ്‌ക്ക് ഒരേ മൂല്യം നൽകുകയും ചെയ്യുന്നു.

അങ്ങനെ, പരമാവധി മൂല്യം വരികളുടെ എണ്ണവുമായി പൊരുത്തപ്പെടും, അതായത് 5.

ഇനിപ്പറയുന്ന സ്ക്രിപ്റ്റ് പ്രവർത്തിപ്പിക്കുന്നതിന്റെ ഫലമായി പട്ടികയിൽ എത്ര വരികൾ ഉണ്ടാകും?

create table t(i integer check (i < 5));
 
create procedure p(p_from integer, p_to integer) as
begin
    for i in p_from .. p_to loop
        insert into t values (i);
    end loop;
end;
/
 
exec p(1, 3);
exec p(4, 6);
exec p(7, 9);

• 0
• 3
• 4
• 5
• 6
• 9

മറുപടിഒറാക്കിൾ ഡോക്യുമെന്റേഷൻ അനുസരിച്ച് (11.2 ൽ നിന്ന് ഉദ്ധരിച്ചത്):

ഏതെങ്കിലും SQL പ്രസ്താവന നടപ്പിലാക്കുന്നതിന് മുമ്പ്, Oracle ഒരു വ്യക്തമായ സേവ് പോയിന്റ് അടയാളപ്പെടുത്തുന്നു (നിങ്ങൾക്ക് ലഭ്യമല്ല). തുടർന്ന്, പ്രസ്താവന പരാജയപ്പെടുകയാണെങ്കിൽ, Oracle അത് യാന്ത്രികമായി റോൾ ചെയ്യുകയും ബാധകമായ പിശക് കോഡ് SQLCA-യിലെ SQLCODE-ലേക്ക് തിരികെ നൽകുകയും ചെയ്യുന്നു. ഉദാഹരണത്തിന്, ഒരു അദ്വിതീയ സൂചികയിൽ ഒരു ഡ്യൂപ്ലിക്കേറ്റ് മൂല്യം തിരുകാൻ ശ്രമിക്കുന്നതിലൂടെ ഒരു INSERT പ്രസ്താവന ഒരു പിശക് ഉണ്ടാക്കുന്നുവെങ്കിൽ, സ്റ്റേറ്റ്മെന്റ് റോൾ ബാക്ക് ചെയ്യും.

ക്ലയന്റിൽനിന്ന് എച്ച്പി വിളിക്കുന്നതും ഒരൊറ്റ പ്രസ്താവനയായി പരിഗണിക്കുകയും പ്രോസസ്സ് ചെയ്യുകയും ചെയ്യുന്നു. അങ്ങനെ, മൂന്ന് റെക്കോർഡുകൾ ചേർത്തുകൊണ്ട് ആദ്യത്തെ HP കോൾ വിജയകരമായി പൂർത്തിയാക്കുന്നു; രണ്ടാമത്തെ HP കോൾ ഒരു പിശകോടെ അവസാനിക്കുകയും അത് തിരുകാൻ കഴിഞ്ഞ നാലാമത്തെ റെക്കോർഡ് തിരികെ കൊണ്ടുവരികയും ചെയ്യുന്നു; മൂന്നാമത്തെ കോൾ പരാജയപ്പെടുന്നു, കൂടാതെ പട്ടികയിൽ മൂന്ന് റെക്കോർഡുകൾ ഉണ്ട്.

ഇനിപ്പറയുന്ന സ്ക്രിപ്റ്റ് പ്രവർത്തിപ്പിക്കുന്നതിന്റെ ഫലമായി പട്ടികയിൽ എത്ര വരികൾ ഉണ്ടാകും?

create table t(i integer, constraint i_ch check (i < 3));
 
begin
    insert into t values (1);
    insert into t values (null);
    insert into t values (2);
    insert into t values (null);
    insert into t values (3);
    insert into t values (null);
    insert into t values (4);
    insert into t values (null);
    insert into t values (5);
exception
    when others then
        dbms_output.put_line('Oops!');
end;
/

• 1
• 2
• 3
• 4
• 5
• 6
• 7

മറുപടിഒറാക്കിൾ ഡോക്യുമെന്റേഷൻ അനുസരിച്ച് (11.2 ൽ നിന്ന് ഉദ്ധരിച്ചത്):

പട്ടികയിലെ ഓരോ വരിയും പാലിക്കേണ്ട ഒരു വ്യവസ്ഥ വ്യക്തമാക്കാൻ ഒരു ചെക്ക് കൺസ്ട്രൈന്റ് നിങ്ങളെ അനുവദിക്കുന്നു. നിയന്ത്രണത്തെ തൃപ്തിപ്പെടുത്താൻ, പട്ടികയിലെ ഓരോ വരിയും വ്യവസ്ഥ ശരിയോ അജ്ഞാതമോ ആക്കണം (ശൂന്യമായതിനാൽ). ഒറാക്കിൾ ഒരു പ്രത്യേക വരിയുടെ ചെക്ക് കൺസ്ട്രെയിന്റ് അവസ്ഥ വിലയിരുത്തുമ്പോൾ, വ്യവസ്ഥയിലുള്ള ഏതെങ്കിലും കോളം പേരുകൾ ആ വരിയിലെ കോളം മൂല്യങ്ങളെ സൂചിപ്പിക്കുന്നു.

അങ്ങനെ, മൂല്യം നൾ ചെക്ക് പാസാക്കും, മൂല്യം 3 ചേർക്കാനുള്ള ശ്രമം വരെ അജ്ഞാത ബ്ലോക്ക് വിജയകരമായി നടപ്പിലാക്കും. ഇതിനുശേഷം, പിശക് കൈകാര്യം ചെയ്യൽ ബ്ലോക്ക് ഒഴിവാക്കും, റോൾബാക്ക് സംഭവിക്കില്ല, കൂടാതെ പട്ടികയിൽ നാല് വരികൾ ശേഷിക്കും മൂല്യങ്ങൾക്കൊപ്പം 1, null, 2, null വീണ്ടും.

ഏത് ജോഡി മൂല്യങ്ങളാണ് ബ്ലോക്കിൽ ഒരേ അളവിൽ സ്ഥലം എടുക്കുന്നത്?

create table t (
    a char(1 char),
    b char(10 char),
    c char(100 char),
    i number(4),
    j number(14),
    k number(24),
    x varchar2(1 char),
    y varchar2(10 char),
    z varchar2(100 char));
 
insert into t (a, b, i, j, x, y)
    values ('Y', 'Вася', 10, 10, 'Д', 'Вася');

• എ, എക്സ്
• ബി, വൈ
• സിയും കെ
• സി, ഇസഡ്
• കെ, ഇസഡ്
• ഞാനും ജെ
• ജെ, എക്സ്
• എല്ലാം പട്ടികപ്പെടുത്തി

മറുപടിഒറാക്കിളിൽ വിവിധ തരം ഡാറ്റ സംഭരിക്കുന്നതിനുള്ള ഡോക്യുമെന്റേഷനിൽ നിന്നുള്ള (12.1.0.2) ഉദ്ധരണികൾ ഇവിടെയുണ്ട്.

CHAR ഡാറ്റ തരം
CHAR ഡാറ്റ തരം ഡാറ്റാബേസ് പ്രതീക സെറ്റിൽ ഒരു നിശ്ചിത ദൈർഘ്യമുള്ള പ്രതീക സ്ട്രിംഗ് വ്യക്തമാക്കുന്നു. നിങ്ങളുടെ ഡാറ്റാബേസ് സൃഷ്ടിക്കുമ്പോൾ നിങ്ങൾ ഡാറ്റാബേസ് പ്രതീക സെറ്റ് വ്യക്തമാക്കുന്നു. ഒരു CHAR നിരയിൽ സംഭരിച്ചിരിക്കുന്ന എല്ലാ മൂല്യങ്ങൾക്കും തിരഞ്ഞെടുത്ത ദൈർഘ്യ സെമാന്റിക്‌സിൽ വലുപ്പം അനുസരിച്ച് വ്യക്തമാക്കിയ ദൈർഘ്യമുണ്ടെന്ന് ഒറാക്കിൾ ഉറപ്പാക്കുന്നു. നിരയുടെ നീളത്തേക്കാൾ കുറവുള്ള ഒരു മൂല്യം നിങ്ങൾ തിരുകുകയാണെങ്കിൽ, Oracle ബ്ലാങ്ക് പാഡ് മൂല്യത്തെ നിരയുടെ നീളത്തിലേക്ക് മാറ്റുന്നു.

VARCHAR2 ഡാറ്റ തരം
VARCHAR2 ഡാറ്റ തരം ഡാറ്റാബേസ് പ്രതീക സെറ്റിൽ ഒരു വേരിയബിൾ-ലെങ്ത് ക്യാരക്ടർ സ്ട്രിംഗ് വ്യക്തമാക്കുന്നു. നിങ്ങളുടെ ഡാറ്റാബേസ് സൃഷ്ടിക്കുമ്പോൾ നിങ്ങൾ ഡാറ്റാബേസ് പ്രതീക സെറ്റ് വ്യക്തമാക്കുന്നു. നിരയുടെ ദൈർഘ്യം കവിയുന്നില്ലെങ്കിൽ മൂല്യം ശൂന്യമായ പാഡിംഗും കൂടാതെ നിങ്ങൾ വ്യക്തമാക്കുന്നത് പോലെ തന്നെ Oracle ഒരു VARCHAR2 കോളത്തിൽ ഒരു പ്രതീക മൂല്യം സംഭരിക്കുന്നു.

NUMBER ഡാറ്റ തരം
1.0 x 10-130 മുതൽ എന്നാൽ 1.0 x 10126 വരെയുള്ള സമ്പൂർണ്ണ മൂല്യങ്ങളുള്ള പൂജ്യവും പോസിറ്റീവ്, നെഗറ്റീവ് സ്ഥിര സംഖ്യകളും NUMBER ഡാറ്റാ തരം സംഭരിക്കുന്നു. നിങ്ങൾ ഒരു ഗണിത പദപ്രയോഗം വ്യക്തമാക്കുകയാണെങ്കിൽ, അതിന്റെ മൂല്യത്തിന് കൂടുതലോ തുല്യമോ ആയ ഒരു കേവല മൂല്യമുണ്ട് 1.0 x 10126, തുടർന്ന് Oracle ഒരു പിശക് നൽകുന്നു. ഓരോ NUMBER മൂല്യത്തിനും 1 മുതൽ 22 വരെ ബൈറ്റുകൾ ആവശ്യമാണ്. ഇത് കണക്കിലെടുക്കുമ്പോൾ, നൽകിയിരിക്കുന്ന മൂല്യത്തിന്റെ കൃത്യത p എന്നത് ഒരു പ്രത്യേക സംഖ്യാ ഡാറ്റ മൂല്യമായ NUMBER(p) യുടെ ബൈറ്റുകളിലുള്ള നിരയുടെ വലുപ്പം ഇനിപ്പറയുന്ന ഫോർമുല ഉപയോഗിച്ച് കണക്കാക്കാം: ROUND((നീളം(p)+s)/2))+1 സംഖ്യ പോസിറ്റീവ് ആണെങ്കിൽ s പൂജ്യത്തിനും സംഖ്യ നെഗറ്റീവ് ആണെങ്കിൽ 1 നും തുല്യമാണ്.

കൂടാതെ, നൾ മൂല്യങ്ങൾ സംഭരിക്കുന്നതിനുള്ള ഡോക്യുമെന്റേഷനിൽ നിന്നുള്ള ഒരു ഉദ്ധരണി എടുക്കാം.

ഒരു നിരയിൽ ഒരു മൂല്യത്തിന്റെ അഭാവമാണ് നൾ. നൾസ് നഷ്‌ടമായതോ അറിയാത്തതോ ബാധകമല്ലാത്തതോ ആയ ഡാറ്റയെ സൂചിപ്പിക്കുന്നു. ഡാറ്റ മൂല്യങ്ങളുള്ള നിരകൾക്കിടയിൽ വീണാൽ നൾസ് ഡാറ്റാബേസിൽ സംഭരിക്കപ്പെടും. ഈ സന്ദർഭങ്ങളിൽ, നിരയുടെ ദൈർഘ്യം (പൂജ്യം) സംഭരിക്കുന്നതിന് അവർക്ക് 1 ബൈറ്റ് ആവശ്യമാണ്. മുമ്പത്തെ വരിയിലെ ശേഷിക്കുന്ന നിരകൾ അസാധുവാണെന്ന് ഒരു പുതിയ വരി തലക്കെട്ട് സൂചിപ്പിക്കുന്നതിനാൽ ഒരു വരിയിലെ ട്രെയിലിംഗ് nullകൾക്ക് സംഭരണം ആവശ്യമില്ല. ഉദാഹരണത്തിന്, ഒരു പട്ടികയുടെ അവസാനത്തെ മൂന്ന് നിരകൾ അസാധുവാണെങ്കിൽ, ഈ കോളങ്ങൾക്കായി ഒരു ഡാറ്റയും സംഭരിക്കില്ല.

ഈ ഡാറ്റയെ അടിസ്ഥാനമാക്കി, ഞങ്ങൾ ന്യായവാദം നിർമ്മിക്കുന്നു. ഡാറ്റാബേസ് AL32UTF8 എൻകോഡിംഗ് ഉപയോഗിക്കുന്നതായി ഞങ്ങൾ അനുമാനിക്കുന്നു. ഈ എൻകോഡിംഗിൽ, റഷ്യൻ അക്ഷരങ്ങൾ 2 ബൈറ്റുകൾ ഉൾക്കൊള്ളും.

1) A, X എന്നിവ, ഒരു 'Y' ഫീൽഡിന്റെ മൂല്യം 1 ബൈറ്റ് എടുക്കുന്നു, ഫീൽഡ് x 'D' ന്റെ മൂല്യം 2 ബൈറ്റുകൾ എടുക്കുന്നു
2) ബിയിലെ ബി, വൈ, 'വാസ്യ' എന്നിവ 10 പ്രതീകങ്ങൾ വരെയുള്ള സ്‌പെയ്‌സുകളാൽ പാഡ് ചെയ്യപ്പെടും, 14 ബൈറ്റുകൾ എടുക്കും, ഡിയിലെ 'വാസ്യ' 8 ബൈറ്റുകൾ എടുക്കും.
3) C, K. രണ്ട് ഫീൽഡുകൾക്കും NULL മൂല്യമുണ്ട്, അവയ്ക്ക് ശേഷം കാര്യമായ ഫീൽഡുകൾ ഉണ്ട്, അതിനാൽ അവ 1 ബൈറ്റ് ഉൾക്കൊള്ളുന്നു.
4) C, Z. രണ്ട് ഫീൽഡുകൾക്കും NULL മൂല്യമുണ്ട്, എന്നാൽ Z ഫീൽഡ് പട്ടികയിൽ അവസാനത്തേതാണ്, അതിനാൽ ഇത് സ്ഥലം എടുക്കുന്നില്ല (0 ബൈറ്റുകൾ). ഫീൽഡ് C 1 ബൈറ്റ് ഉൾക്കൊള്ളുന്നു.
5) K, Z. മുമ്പത്തെ കേസിന് സമാനമാണ്. K ഫീൽഡിലെ മൂല്യം Z - 1-ൽ 0 ബൈറ്റാണ്.
6) I, J. ഡോക്യുമെന്റേഷൻ അനുസരിച്ച്, രണ്ട് മൂല്യങ്ങളും 2 ബൈറ്റുകൾ എടുക്കും. ഡോക്യുമെന്റേഷനിൽ നിന്ന് എടുത്ത ഫോർമുല ഉപയോഗിച്ച് ഞങ്ങൾ ദൈർഘ്യം കണക്കാക്കുന്നു: റൗണ്ട് ( (1 + 0)/2) +1 = 1 + 1 = 2.
7) J, X. J ഫീൽഡിലെ മൂല്യം 2 ബൈറ്റുകൾ എടുക്കും, X ഫീൽഡിലെ മൂല്യം 2 ബൈറ്റുകൾ എടുക്കും.

മൊത്തത്തിൽ, ശരിയായ ഓപ്ഷനുകൾ ഇവയാണ്: സി, കെ, ഐ, ജെ, ജെ, എക്സ്.

T_I സൂചികയുടെ ക്ലസ്റ്ററിംഗ് ഘടകം ഏകദേശം എന്തായിരിക്കും?

create table t (i integer);
 
insert into t select rownum from dual connect by level <= 10000;
 
create index t_i on t(i);

• പത്തോളം
• ഏകദേശം നൂറുകണക്കിന്
• ഏകദേശം ആയിരങ്ങൾ
• ഏകദേശം പതിനായിരങ്ങൾ

മറുപടിഒറാക്കിൾ ഡോക്യുമെന്റേഷൻ അനുസരിച്ച് (12.1 ൽ നിന്ന് ഉദ്ധരിച്ചത്):

ഒരു ബി-ട്രീ സൂചികയ്ക്ക്, സൂചിക മൂല്യവുമായി ബന്ധപ്പെട്ട് വരികളുടെ ഫിസിക്കൽ ഗ്രൂപ്പിംഗ് സൂചിക ക്ലസ്റ്ററിംഗ് ഘടകം അളക്കുന്നു.

ചില ചോദ്യങ്ങൾക്ക് ഇൻഡെക്സ് സ്കാൻ അല്ലെങ്കിൽ ഫുൾ ടേബിൾ സ്കാൻ കൂടുതൽ കാര്യക്ഷമമാണോ എന്ന് തീരുമാനിക്കാൻ ഒപ്റ്റിമൈസറിനെ ഇൻഡെക്സ് ക്ലസ്റ്ററിംഗ് ഘടകം സഹായിക്കുന്നു). കുറഞ്ഞ ക്ലസ്റ്ററിംഗ് ഘടകം കാര്യക്ഷമമായ സൂചിക സ്കാനിനെ സൂചിപ്പിക്കുന്നു.

ഒരു പട്ടികയിലെ ബ്ലോക്കുകളുടെ എണ്ണത്തോട് അടുത്തിരിക്കുന്ന ഒരു ക്ലസ്റ്ററിംഗ് ഘടകം സൂചിക കീ ഉപയോഗിച്ച് പട്ടിക ബ്ലോക്കുകളിൽ വരികൾ ഭൗതികമായി ക്രമീകരിച്ചിരിക്കുന്നുവെന്ന് സൂചിപ്പിക്കുന്നു. ഡാറ്റാബേസ് ഒരു പൂർണ്ണ ടേബിൾ സ്കാൻ നടത്തുകയാണെങ്കിൽ, സൂചിക കീ ഉപയോഗിച്ച് അടുക്കിയ ഡിസ്കിൽ സംഭരിച്ചിരിക്കുന്ന വരികൾ വീണ്ടെടുക്കാൻ ഡാറ്റാബേസ് പ്രവണത കാണിക്കുന്നു. വരികളുടെ എണ്ണത്തോട് അടുത്തിരിക്കുന്ന ഒരു ക്ലസ്റ്ററിംഗ് ഘടകം സൂചിക കീയുമായി ബന്ധപ്പെട്ട് ഡാറ്റാബേസ് ബ്ലോക്കുകളിലുടനീളം വരികൾ ക്രമരഹിതമായി ചിതറിക്കിടക്കുന്നുവെന്ന് സൂചിപ്പിക്കുന്നു. ഡാറ്റാബേസ് ഒരു ഫുൾ ടേബിൾ സ്കാൻ നടത്തുകയാണെങ്കിൽ, ഈ സൂചിക കീ ഉപയോഗിച്ച് അടുക്കിയ ക്രമത്തിൽ ഡാറ്റാബേസ് വരികൾ വീണ്ടെടുക്കില്ല.

ഈ സാഹചര്യത്തിൽ, ഡാറ്റ മികച്ച രീതിയിൽ അടുക്കുന്നു, അതിനാൽ ക്ലസ്റ്ററിംഗ് ഘടകം പട്ടികയിലെ അധിനിവേശ ബ്ലോക്കുകളുടെ എണ്ണത്തിന് തുല്യമോ അതിനടുത്തോ ആയിരിക്കും. 8 കിലോബൈറ്റുകളുടെ ഒരു സാധാരണ ബ്ലോക്ക് വലുപ്പത്തിന്, ഏകദേശം ആയിരം ഇടുങ്ങിയ സംഖ്യ മൂല്യങ്ങൾ ഒരു ബ്ലോക്കിലേക്ക് യോജിക്കുമെന്ന് നിങ്ങൾക്ക് പ്രതീക്ഷിക്കാം, അതിനാൽ ബ്ലോക്കുകളുടെ എണ്ണം, അതിന്റെ ഫലമായി, ക്ലസ്റ്ററിംഗ് ഘടകം പത്തോളം.

സ്റ്റാൻഡേർഡ് സെറ്റിംഗ്‌സ് ഉള്ള ഒരു സാധാരണ ഡാറ്റാബേസിൽ ഇനിപ്പറയുന്ന സ്‌ക്രിപ്റ്റ് N-ന്റെ ഏത് മൂല്യങ്ങളിലാണ് വിജയകരമായി നടപ്പിലാക്കുന്നത്?

create table t (
    a varchar2(N char),
    b varchar2(N char),
    c varchar2(N char),
    d varchar2(N char));
 
create index t_i on t (a, b, c, d);

• 100
• 200
• 400
• 800
• 1600
• 3200
• 6400

മറുപടിഒറാക്കിൾ ഡോക്യുമെന്റേഷൻ അനുസരിച്ച് (11.2 ൽ നിന്ന് ഉദ്ധരിച്ചത്):

ലോജിക്കൽ ഡാറ്റാബേസ് പരിധികൾ

ഇനം
പരിധിയുടെ തരം
പരിധി മൂല്യം

ഇന്ഡക്സുകളില്
ഇൻഡക്‌സ് ചെയ്‌ത കോളത്തിന്റെ ആകെ വലുപ്പം
ഡാറ്റാബേസ് ബ്ലോക്ക് വലുപ്പത്തിന്റെ 75% കുറച്ച് ഓവർഹെഡ് മൈനസ്

അതിനാൽ, ഇൻഡക്‌സ് ചെയ്‌ത നിരകളുടെ ആകെ വലുപ്പം 6Kb കവിയാൻ പാടില്ല. അടുത്തതായി സംഭവിക്കുന്നത് തിരഞ്ഞെടുത്ത അടിസ്ഥാന എൻകോഡിംഗിനെ ആശ്രയിച്ചിരിക്കുന്നു. AL32UTF8 എൻകോഡിംഗിനായി, ഒരു പ്രതീകത്തിന് പരമാവധി 4 ബൈറ്റുകൾ ഉൾക്കൊള്ളാൻ കഴിയും, അതിനാൽ ഏറ്റവും മോശം സാഹചര്യത്തിൽ, ഏകദേശം 6 പ്രതീകങ്ങൾ 1500 കിലോബൈറ്റിലേക്ക് യോജിക്കും. അതിനാൽ, N = 400 (ഏറ്റവും മോശം കീ ദൈർഘ്യം 1600 പ്രതീകങ്ങൾ * 4 ബൈറ്റുകൾ + റോയ്ഡ് ദൈർഘ്യം ആയിരിക്കുമ്പോൾ) സൂചിക സൃഷ്ടിക്കൽ Oracle അനുവദിക്കില്ല. N = 200 (അല്ലെങ്കിൽ അതിൽ കുറവ്) സൂചിക സൃഷ്ടിക്കുന്നത് പ്രശ്നങ്ങളില്ലാതെ പ്രവർത്തിക്കും.

APPEND സൂചനയുള്ള INSERT ഓപ്പറേറ്റർ ഡയറക്ട് മോഡിൽ ഡാറ്റ ലോഡുചെയ്യാൻ രൂപകൽപ്പന ചെയ്‌തിരിക്കുന്നു. ട്രിഗർ തൂങ്ങിക്കിടക്കുന്ന മേശയിൽ ഇത് പ്രയോഗിച്ചാൽ എന്ത് സംഭവിക്കും?

• ഡാറ്റ ഡയറക്ട് മോഡിൽ ലോഡ് ചെയ്യും, ട്രിഗർ പ്രതീക്ഷിച്ച പോലെ പ്രവർത്തിക്കും
• ഡാറ്റ ഡയറക്ട് മോഡിൽ ലോഡ് ചെയ്യും, പക്ഷേ ട്രിഗർ എക്സിക്യൂട്ട് ചെയ്യില്ല
• ഡാറ്റ പരമ്പരാഗത മോഡിൽ ലോഡ് ചെയ്യും, ട്രിഗർ അത് പോലെ പ്രവർത്തിക്കും
• ഡാറ്റ പരമ്പരാഗത മോഡിൽ ലോഡ് ചെയ്യും, എന്നാൽ ട്രിഗർ എക്സിക്യൂട്ട് ചെയ്യില്ല
• ഡാറ്റ ലോഡുചെയ്യില്ല, ഒരു പിശക് രേഖപ്പെടുത്തും

മറുപടിഅടിസ്ഥാനപരമായി, ഇത് യുക്തിയുടെ ഒരു ചോദ്യമാണ്. ശരിയായ ഉത്തരം കണ്ടെത്താൻ, ഞാൻ ഇനിപ്പറയുന്ന ന്യായവാദ മാതൃക നിർദ്ദേശിക്കുന്നു:

1. ഉയർന്ന വേഗത ഉറപ്പാക്കുന്ന SQL എഞ്ചിൻ മറികടന്ന് ഒരു ഡാറ്റ ബ്ലോക്കിന്റെ നേരിട്ടുള്ള രൂപീകരണത്തിലൂടെയാണ് ഡയറക്ട് മോഡിൽ ഉൾപ്പെടുത്തൽ നടത്തുന്നത്. അതിനാൽ, ട്രിഗറിന്റെ നിർവ്വഹണം ഉറപ്പാക്കുന്നത് വളരെ ബുദ്ധിമുട്ടാണ്, അസാധ്യമല്ലെങ്കിൽ, ഇതിൽ കാര്യമില്ല, കാരണം ഇത് ഉൾപ്പെടുത്തലിനെ സമൂലമായി മന്ദഗതിയിലാക്കും.
2. ട്രിഗർ എക്സിക്യൂട്ട് ചെയ്യുന്നതിൽ പരാജയപ്പെടുന്നത്, പട്ടികയിലെ ഡാറ്റ ഒന്നുതന്നെയാണെങ്കിൽ, ഡാറ്റാബേസിന്റെ മൊത്തത്തിലുള്ള അവസ്ഥ (മറ്റ് പട്ടികകൾ) ഈ ഡാറ്റ ചേർത്ത മോഡിനെ ആശ്രയിച്ചിരിക്കും എന്ന വസ്തുതയിലേക്ക് നയിക്കും. ഇത് വ്യക്തമായും ഡാറ്റയുടെ സമഗ്രതയെ നശിപ്പിക്കും, ഉൽപ്പാദനത്തിൽ ഒരു പരിഹാരമായി പ്രയോഗിക്കാൻ കഴിയില്ല.
3. അഭ്യർത്ഥിച്ച പ്രവർത്തനം നടത്താനുള്ള കഴിവില്ലായ്മ സാധാരണയായി ഒരു പിശകായി കണക്കാക്കുന്നു. എന്നാൽ ഇവിടെ APPEND എന്നത് ഒരു സൂചനയാണെന്ന് ഓർമ്മിക്കേണ്ടതാണ്, സാധ്യമെങ്കിൽ അവ കണക്കിലെടുക്കും എന്നതാണ് സൂചനകളുടെ പൊതുവായ യുക്തി, പക്ഷേ ഇല്ലെങ്കിൽ, സൂചന കണക്കിലെടുക്കാതെ ഓപ്പറേറ്റർ എക്സിക്യൂട്ട് ചെയ്യപ്പെടും.

അതിനാൽ പ്രതീക്ഷിക്കുന്ന ഉത്തരം ഡാറ്റ സാധാരണ (SQL) മോഡിൽ ലോഡ് ചെയ്യപ്പെടും, ട്രിഗർ ഫയർ ചെയ്യും.

ഒറാക്കിൾ ഡോക്യുമെന്റേഷൻ അനുസരിച്ച് (8.04 ൽ നിന്ന് ഉദ്ധരിച്ചത്):

നിയന്ത്രണങ്ങളുടെ ലംഘനങ്ങൾ, മുന്നറിയിപ്പുകളോ പിശക് സന്ദേശങ്ങളോ ഇല്ലാതെ, പരമ്പരാഗത ഇൻസേർട്ട് പാത്ത് ഉപയോഗിച്ച്, സീരിയൽ ആയി എക്സിക്യൂട്ട് ചെയ്യാൻ പ്രസ്താവനയ്ക്ക് കാരണമാകും. ഒരു ഇടപാടിൽ ഒരേ ടേബിളിൽ ഒന്നിലധികം തവണ ആക്‌സസ് ചെയ്യുന്ന പ്രസ്താവനകൾക്കുള്ള നിയന്ത്രണമാണ് ഒരു അപവാദം, ഇത് പിശക് സന്ദേശങ്ങൾക്ക് കാരണമാകും.
ഉദാഹരണത്തിന്, പട്ടികയിൽ ട്രിഗറുകളോ റഫറൻഷ്യൽ സമഗ്രതയോ ഉണ്ടെങ്കിൽ, നിങ്ങൾ ഡയറക്ട്-ലോഡ് INSERT (സീരിയൽ അല്ലെങ്കിൽ പാരലൽ), അതുപോലെ പാരലൽ സൂചന അല്ലെങ്കിൽ ക്ലോസ് എന്നിവ ഉപയോഗിക്കാൻ ശ്രമിക്കുമ്പോൾ, അനുബന്ധ സൂചന അവഗണിക്കപ്പെടും.

ഇനിപ്പറയുന്ന സ്ക്രിപ്റ്റ് എക്സിക്യൂട്ട് ചെയ്യുമ്പോൾ എന്ത് സംഭവിക്കും?

create table t(i integer not null primary key, j integer references t);
 
create trigger t_a_i after insert on t for each row
declare
    pragma autonomous_transaction;
begin
    insert into t values (:new.i + 1, :new.i);
    commit;
end;
/
 
insert into t values (1, null);

• വിജയകരമായ പൂർത്തീകരണം
• വാക്യഘടന പിശക് കാരണം പരാജയം
• പിശക്: സ്വയംഭരണ ഇടപാട് സാധുതയുള്ളതല്ല
• പരമാവധി കോൾ നെസ്റ്റിംഗ് കവിയുന്നതുമായി ബന്ധപ്പെട്ട പിശക്
• വിദേശ കീ ലംഘന പിശക്
• ലോക്കുകളുമായി ബന്ധപ്പെട്ട പിശക്

മറുപടിപട്ടികയും ട്രിഗറും ശരിയായി സൃഷ്ടിച്ചിരിക്കുന്നു, ഈ പ്രവർത്തനം പ്രശ്നങ്ങളിലേക്ക് നയിക്കരുത്. ഒരു ട്രിഗറിലെ സ്വയംഭരണ ഇടപാടുകളും അനുവദനീയമാണ്, അല്ലാത്തപക്ഷം ലോഗിംഗ് സാധ്യമാകില്ല, ഉദാഹരണത്തിന്.

ആദ്യ വരി ചേർത്ത ശേഷം, വിജയകരമായ ഒരു ട്രിഗർ ഫയറിംഗ്, രണ്ടാമത്തെ വരി തിരുകാൻ ഇടയാക്കും, ട്രിഗർ വീണ്ടും തീപിടിക്കാൻ ഇടയാക്കും, മൂന്നാമത്തെ വരി തിരുകുകയും, കോളുകളുടെ പരമാവധി നെസ്റ്റിംഗ് കവിഞ്ഞതിനാൽ പ്രസ്താവന പരാജയപ്പെടുന്നതുവരെ. എന്നിരുന്നാലും, മറ്റൊരു സൂക്ഷ്മമായ കാര്യം പ്രവർത്തിക്കുന്നു. ട്രിഗർ നിർവ്വഹിക്കുന്ന സമയത്ത്, ആദ്യം ചേർത്ത റെക്കോർഡിന്റെ കമ്മിറ്റ് ഇതുവരെ പൂർത്തിയായിട്ടില്ല. അതിനാൽ, ഒരു സ്വയംഭരണ ഇടപാടിൽ പ്രവർത്തിക്കുന്ന ഒരു ട്രിഗർ ഇതുവരെ പ്രതിജ്ഞാബദ്ധമല്ലാത്ത ഒരു റെക്കോർഡിലേക്ക് ഒരു വിദേശ കീയെ പരാമർശിക്കുന്ന ഒരു വരി പട്ടികയിലേക്ക് തിരുകാൻ ശ്രമിക്കുന്നു. ഇത് ഒരു കാത്തിരിപ്പിന് കാരണമാകുന്നു (സ്വയംഭരണ ഇടപാട് പ്രധാന ഇടപാടിന് ഡാറ്റ ഉൾപ്പെടുത്താൻ കഴിയുമോ എന്ന് നോക്കാൻ കാത്തിരിക്കുന്നു) അതേ സമയം പ്രധാന ഇടപാട് ട്രിഗറിന് ശേഷം സ്വയംഭരണ ഇടപാട് തുടരുന്നതിന് കാത്തിരിക്കുന്നു. ഒരു ഡെഡ്‌ലോക്ക് സംഭവിക്കുന്നു, അതിന്റെ ഫലമായി, ലോക്കുകളുമായി ബന്ധപ്പെട്ട കാരണങ്ങളാൽ സ്വയംഭരണ ഇടപാട് റദ്ദാക്കപ്പെടുന്നു.

രജിസ്റ്റർ ചെയ്ത ഉപയോക്താക്കൾക്ക് മാത്രമേ സർവേയിൽ പങ്കെടുക്കാൻ കഴിയൂ. സൈൻ ഇൻദയവായി.

അത് ബുദ്ധിമുട്ടായിരുന്നോ?

• രണ്ട് വിരലുകൾ പോലെ, ഞാൻ എല്ലാം ശരിയായി തീരുമാനിച്ചു.

• ശരിയല്ല, രണ്ട് ചോദ്യങ്ങളിൽ എനിക്ക് തെറ്റുപറ്റി.

• ഞാൻ അതിന്റെ പകുതി ശരിയാക്കി.

• ഞാൻ ഉത്തരം രണ്ടുതവണ ഊഹിച്ചു!

• ഞാൻ അഭിപ്രായങ്ങളിൽ എഴുതാം

14 ഉപയോക്താക്കൾ വോട്ട് ചെയ്തു. 10 ഉപയോക്താക്കൾ വിട്ടുനിന്നു.

അവലംബം: www.habr.com