ការដើរតាមគន្លងនៃ Highload++ Siberia 2019 - កិច្ចការ 8 នៅលើ Oracle

ជំរាបសួរ!

នៅថ្ងៃទី 24-25 ខែមិថុនា សន្និសីទ Highload++ Siberia 2019 ត្រូវបានធ្វើឡើងនៅ Novosibirsk ។ បុរសរបស់យើងក៏នៅទីនោះដែរ របាយការណ៍ "មូលដ្ឋានទិន្នន័យ Oracle containers (CDB/PDB) និងការប្រើប្រាស់ជាក់ស្តែងរបស់ពួកគេសម្រាប់ការអភិវឌ្ឍន៍កម្មវិធី" យើងនឹងបោះពុម្ពកំណែអត្ថបទនៅពេលក្រោយបន្តិច។ វាត្រជាក់ណាស់ អរគុណ អូលេកប៊ុននីន សម្រាប់អង្គការ ក៏ដូចជាអ្នកគ្រប់គ្នាដែលបានមក។

ក្នុងការបង្ហោះនេះ យើងចង់ចែករំលែកជាមួយអ្នកនូវបញ្ហាដែលយើងមាននៅស្តង់របស់យើង ដើម្បីអោយអ្នកអាចសាកល្បងចំនេះដឹង Oracle របស់អ្នក។ ខាងក្រោម​នេះ​ជា​បញ្ហា​ទាំង ៨ ជម្រើស​ចម្លើយ និង​ការ​ពន្យល់។

តើអ្វីជាតម្លៃលំដាប់អតិបរមាដែលយើងនឹងឃើញជាលទ្ធផលនៃការប្រតិបត្តិស្គ្រីបខាងក្រោម?

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
• ទេ វានឹងមានកំហុស

ឆ្លើយតបយោងតាមឯកសារ Oracle (ដកស្រង់ពី 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

ឆ្លើយតបយោងតាមឯកសារ Oracle (ដកស្រង់ពី 11.2)៖

មុនពេលប្រតិបត្តិសេចក្តីថ្លែងការណ៍ SQL ណាមួយ Oracle សម្គាល់ចំណុចរក្សាទុកដែលបង្កប់ន័យ (មិនមានសម្រាប់អ្នកទេ)។ បន្ទាប់មក ប្រសិនបើសេចក្តីថ្លែងការណ៍បរាជ័យ នោះ Oracle នឹងវិលត្រឡប់មកវិញដោយស្វ័យប្រវត្តិ ហើយត្រឡប់កូដកំហុសដែលអាចអនុវត្តបានទៅ SQLCODE នៅក្នុង SQLCA ។ ឧទាហរណ៍ ប្រសិនបើសេចក្តីថ្លែងការណ៍ INSERT បណ្តាលឱ្យមានកំហុសដោយព្យាយាមបញ្ចូលតម្លៃស្ទួននៅក្នុងលិបិក្រមតែមួយគត់នោះ សេចក្តីថ្លែងការណ៍នឹងត្រលប់មកវិញ។

ការហៅទូរស័ព្ទទៅ HP ពីអតិថិជនក៏ត្រូវបានពិចារណា និងដំណើរការជាសេចក្តីថ្លែងការណ៍តែមួយ។ ដូច្នេះ ការហៅទូរសព្ទដំបូងរបស់ HP បានបញ្ចប់ដោយជោគជ័យ ដោយបានបញ្ចូលកំណត់ត្រាចំនួនបី។ ការហៅទូរសព្ទទីពីររបស់ HP បញ្ចប់ដោយកំហុស ហើយត្រលប់មកវិញនូវកំណត់ត្រាទី XNUMX ដែលវាបានគ្រប់គ្រងដើម្បីបញ្ចូល។ ការហៅទីបីបរាជ័យ ហើយមានកំណត់ត្រាបីនៅក្នុងតារាង.

តើមានជួរដេកប៉ុន្មានក្នុងតារាងដែលជាលទ្ធផលនៃការដំណើរការស្គ្រីបខាងក្រោម?

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

ឆ្លើយតបយោងតាមឯកសារ Oracle (ដកស្រង់ពី 11.2)៖

ដែនកំណត់ត្រួតពិនិត្យអនុញ្ញាតឱ្យអ្នកបញ្ជាក់លក្ខខណ្ឌដែលជួរនីមួយៗក្នុងតារាងត្រូវតែបំពេញ។ ដើម្បី​បំពេញ​ការ​រឹត​បន្តឹង ជួរ​នីមួយៗ​ក្នុង​តារាង​ត្រូវ​តែ​បង្កើត​លក្ខខណ្ឌ​ថា​ពិត ឬ​មិន​ស្គាល់ (ដោយសារ​គ្មាន​តម្លៃ)។ នៅពេលដែល Oracle វាយតម្លៃលក្ខខណ្ឌត្រួតពិនិត្យសម្រាប់ជួរដេកជាក់លាក់មួយ ឈ្មោះជួរឈរណាមួយនៅក្នុងលក្ខខណ្ឌសំដៅទៅលើតម្លៃជួរឈរនៅក្នុងជួរនោះ។

ដូច្នេះតម្លៃ null នឹងឆ្លងកាត់ការត្រួតពិនិត្យ ហើយប្លុកអនាមិកនឹងត្រូវបានប្រតិបត្តិដោយជោគជ័យ រហូតដល់ការព្យាយាមបញ្ចូលតម្លៃ 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, 'Д', 'Вася');

• A និង X
• B និង Y
• C និង K
• C និង Z
• K និង Z
• ខ្ញុំ និង J
• J និង X
• បានរាយទាំងអស់

ឆ្លើយតបនេះគឺជាការដកស្រង់ចេញពីឯកសារ (12.1.0.2) ស្តីពីការរក្សាទុកប្រភេទផ្សេងៗនៃទិន្នន័យនៅក្នុង Oracle ។

ប្រភេទទិន្នន័យ CHAR
ប្រភេទទិន្នន័យ CHAR បញ្ជាក់ខ្សែអក្សរប្រវែងថេរនៅក្នុងសំណុំតួអក្សរមូលដ្ឋានទិន្នន័យ។ អ្នកបញ្ជាក់សំណុំតួអក្សរមូលដ្ឋានទិន្នន័យ នៅពេលអ្នកបង្កើតមូលដ្ឋានទិន្នន័យរបស់អ្នក។ Oracle ធានាថាតម្លៃទាំងអស់ដែលរក្សាទុកក្នុងជួរឈរ CHAR មានប្រវែងដែលបានបញ្ជាក់ដោយទំហំនៅក្នុង semantics ប្រវែងដែលបានជ្រើសរើស។ ប្រសិនបើអ្នកបញ្ចូលតម្លៃដែលខ្លីជាងប្រវែងជួរឈរនោះ Oracle blank-pads តម្លៃទៅប្រវែងជួរឈរ។

ប្រភេទទិន្នន័យ VARCHAR2
ប្រភេទទិន្នន័យ VARCHAR2 បញ្ជាក់ខ្សែអក្សរប្រវែងអថេរនៅក្នុងសំណុំតួអក្សរមូលដ្ឋានទិន្នន័យ។ អ្នកបញ្ជាក់សំណុំតួអក្សរមូលដ្ឋានទិន្នន័យ នៅពេលអ្នកបង្កើតមូលដ្ឋានទិន្នន័យរបស់អ្នក។ Oracle រក្សាទុកតម្លៃតួអក្សរនៅក្នុងជួរឈរ VARCHAR2 យ៉ាងពិតប្រាកដ ដូចដែលអ្នកបញ្ជាក់វា ដោយគ្មានចន្លោះទទេណាមួយ ផ្តល់តម្លៃមិនលើសពីប្រវែងនៃជួរឈរ។

ប្រភេទទិន្នន័យ NUMBER
ប្រភេទទិន្នន័យ NUMBER រក្សាទុកសូន្យ ក៏ដូចជាលេខថេរវិជ្ជមាន និងអវិជ្ជមានដែលមានតម្លៃដាច់ខាតចាប់ពី 1.0 x 10-130 ដល់ ប៉ុន្តែមិនរាប់បញ្ចូល 1.0 x 10126។ ប្រសិនបើអ្នកបញ្ជាក់កន្សោមលេខនព្វន្ធដែលតម្លៃរបស់វាមានតម្លៃដាច់ខាតធំជាង ឬស្មើនឹង 1.0 x 10126 បន្ទាប់មក Oracle ត្រឡប់កំហុស។ តម្លៃ NUMBER នីមួយៗទាមទារពី 1 ទៅ 22 បៃ។ ដោយគិតពីវា ទំហំជួរឈរគិតជាបៃសម្រាប់តម្លៃទិន្នន័យជាលេខជាក់លាក់មួយ NUMBER(p) ដែល p ជាភាពជាក់លាក់នៃតម្លៃដែលបានផ្តល់ឱ្យ អាចត្រូវបានគណនាដោយប្រើរូបមន្តខាងក្រោម៖ ROUND((ប្រវែង(p)+s)/2))+1 ដែល s ស្មើសូន្យ បើលេខវិជ្ជមាន ហើយ s ស្មើ 1 ប្រសិនបើលេខអវិជ្ជមាន។

បន្ថែមពីលើនេះ សូមលើកយកការដកស្រង់ចេញពីឯកសារអំពីការរក្សាទុកតម្លៃ Null ។

មោឃៈគឺជាអវត្ដមាននៃតម្លៃក្នុងជួរឈរ។ Nulls បង្ហាញពីទិន្នន័យដែលបាត់ មិនស្គាល់ ឬមិនអាចអនុវត្តបាន។ Nulls ត្រូវបានរក្សាទុកក្នុង database ប្រសិនបើពួកវាធ្លាក់នៅចន្លោះជួរឈរដែលមានតម្លៃទិន្នន័យ។ នៅក្នុងករណីទាំងនេះ ពួកគេត្រូវការ 1 បៃដើម្បីរក្សាទុកប្រវែងនៃជួរឈរ (សូន្យ) ។ ការ​បន្ត​ទុក​ជាមោឃៈ​ក្នុង​ជួរ​ដេក​មិន​ទាមទារ​កន្លែង​ផ្ទុក​ទេ ព្រោះ​បឋមកថា​ជួរ​ដេក​ថ្មី​ផ្តល់​សញ្ញា​ថា​ជួរ​ឈរ​ដែល​នៅ​សល់​ក្នុង​ជួរ​មុន​គឺ​ទទេ។ ឧទាហរណ៍ ប្រសិនបើជួរឈរបីចុងក្រោយនៃតារាងគឺទទេ នោះគ្មានទិន្នន័យណាមួយត្រូវបានរក្សាទុកសម្រាប់ជួរឈរទាំងនេះទេ។

ផ្អែកលើទិន្នន័យទាំងនេះ យើងបង្កើតហេតុផល។ យើងសន្មត់ថាមូលដ្ឋានទិន្នន័យប្រើការអ៊ិនកូដ AL32UTF8 ។ នៅក្នុងការអ៊ិនកូដនេះ អក្សររុស្ស៊ីនឹងកាន់កាប់ 2 បៃ។

1) A និង X តម្លៃនៃវាល 'Y' យក 1 បៃ តម្លៃនៃវាល x 'D' យក 2 បៃ
2) B និង Y, 'Vasya' ក្នុង b តម្លៃនឹងត្រូវបានដាក់ចន្លោះរហូតដល់ 10 តួអក្សរ ហើយនឹងយក 14 បៃ 'Vasya' នៅក្នុង d នឹងយក 8 បៃ។
3) C និង K. វាលទាំងពីរមានតម្លៃ NULL បន្ទាប់ពីពួកវាមានវាលសំខាន់ៗ ដូច្នេះពួកវាកាន់កាប់ 1 បៃ។
4) C និង Z ។ វាលទាំងពីរមានតម្លៃ NULL ប៉ុន្តែវាល Z គឺជាចុងក្រោយក្នុងតារាង ដូច្នេះវាមិនយកទំហំទំនេរ (0 បៃ) ទេ។ វាល C កាន់កាប់ 1 បៃ។
5) K និង Z. ស្រដៀងគ្នាទៅនឹងករណីមុន។ តម្លៃនៅក្នុងវាល K កាន់កាប់ 1 បៃក្នុង Z - 0 ។
6) ខ្ញុំ និង J. យោងតាមឯកសារ តម្លៃទាំងពីរនឹងយក 2 បៃ។ យើងគណនាប្រវែងដោយប្រើរូបមន្តយកចេញពីឯកសារ៖ ជុំ((1+0)/2) +1=1+1=2។
7) J និង X. តម្លៃក្នុងវាល J នឹងយក 2 បៃ តម្លៃក្នុងវាល X នឹងយក 2 បៃ។

សរុបមក ជម្រើសត្រឹមត្រូវគឺ៖ C និង K, I និង J, J និង X ។

តើកត្តាចង្កោមនៃសន្ទស្សន៍ 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);

• ប្រហែលដប់
• ប្រហែលរាប់រយ
• ប្រហែលរាប់ពាន់នាក់។
• ប្រហែលរាប់ម៉ឺននាក់។

ឆ្លើយតបយោងតាមឯកសារ Oracle (ដកស្រង់ពី 12.1)៖

សម្រាប់សន្ទស្សន៍ B-tree កត្តាចង្កោមលិបិក្រមវាស់វែងការដាក់ជាក្រុមនៃជួរដេកដែលទាក់ទងទៅនឹងតម្លៃសន្ទស្សន៍។

កត្តាចង្កោមលិបិក្រមជួយអ្នកបង្កើនប្រសិទ្ធភាពសម្រេចចិត្តថាតើការស្កេនលិបិក្រមឬការស្កេនតារាងពេញមានប្រសិទ្ធភាពជាងសម្រាប់សំណួរជាក់លាក់)។ កត្តាចង្កោមទាបបង្ហាញពីការស្កេនលិបិក្រមប្រកបដោយប្រសិទ្ធភាព។

កត្តាចង្កោមដែលនៅជិតចំនួនប្លុកក្នុងតារាងបង្ហាញថា ជួរដេកត្រូវបានតម្រៀបតាមរូបវ័ន្តក្នុងប្លុកតារាងដោយគ្រាប់ចុចលិបិក្រម។ ប្រសិនបើមូលដ្ឋានទិន្នន័យធ្វើការស្កេនតារាងពេញ នោះមូលដ្ឋានទិន្នន័យមានទំនោរទៅយកជួរដេក ដូចដែលពួកវាត្រូវបានរក្សាទុកនៅលើថាសដែលតម្រៀបដោយគ្រាប់ចុចលិបិក្រម។ កត្តាចង្កោមដែលនៅជិតចំនួនជួរដេកបង្ហាញថាជួរដេកត្រូវបានខ្ចាត់ខ្ចាយដោយចៃដន្យនៅទូទាំងប្លុកមូលដ្ឋានទិន្នន័យទាក់ទងនឹងគន្លឹះលិបិក្រម។ ប្រសិនបើមូលដ្ឋានទិន្នន័យធ្វើការស្កេនតារាងពេញ នោះមូលដ្ឋានទិន្នន័យនឹងមិនទៅយកជួរដេកក្នុងលំដាប់ដែលបានតម្រៀបណាមួយដោយគ្រាប់ចុចលិបិក្រមនេះទេ។

ក្នុងករណីនេះ ទិន្នន័យត្រូវបានតម្រៀបតាមឧត្ដមគតិ ដូច្នេះកត្តាចង្កោមនឹងស្មើនឹង ឬជិតទៅនឹងចំនួនប្លុកដែលកាន់កាប់នៅក្នុងតារាង។ សម្រាប់ទំហំប្លុកស្តង់ដារ 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

ឆ្លើយតបយោងតាមឯកសារ Oracle (ដកស្រង់ពី 11.2)៖

ដែនកំណត់មូលដ្ឋានទិន្នន័យឡូជីខល

ធាតុ
ប្រភេទនៃដែនកំណត់
តម្លៃកំណត់

លិបិក្រម
ទំហំសរុបនៃជួរឈរដែលបានធ្វើលិបិក្រម
75% នៃទំហំប្លុកមូលដ្ឋានទិន្នន័យដកផ្នែកខ្លះ

ដូច្នេះ ទំហំសរុបនៃជួរឈរដែលបានធ្វើលិបិក្រមមិនគួរលើសពី 6Kb ទេ។ តើមានអ្វីកើតឡើងបន្ទាប់អាស្រ័យលើការអ៊ិនកូដមូលដ្ឋានដែលបានជ្រើសរើស។ សម្រាប់ការអ៊ិនកូដ AL32UTF8 តួអក្សរមួយអាចកាន់កាប់អតិបរមា 4 បៃ ដូច្នេះក្នុងករណីដ៏អាក្រក់បំផុត ប្រហែល 6 តួអក្សរនឹងសមនឹង 1500 គីឡូបៃ។ ដូច្នេះ Oracle នឹងមិនអនុញ្ញាតការបង្កើតលិបិក្រមនៅ N = 400 (នៅពេលដែលប្រវែងសោរដ៏អាក្រក់បំផុតគឺ 1600 តួអក្សរ * 4 បៃ + ប្រវែងជួរដេក) ខណៈពេលដែល នៅ N = 200 (ឬតិចជាង) ការបង្កើតលិបិក្រមនឹងដំណើរការដោយគ្មានបញ្ហា។

ប្រតិបត្តិករ INSERT ដែលមានព័ត៌មានជំនួយ APPEND ត្រូវបានរចនាឡើងដើម្បីផ្ទុកទិន្នន័យក្នុងរបៀបផ្ទាល់។ តើមានអ្វីកើតឡើងប្រសិនបើវាត្រូវបានអនុវត្តទៅតារាងដែលគន្លឹះព្យួរ?

• ទិន្នន័យនឹងត្រូវបានផ្ទុកក្នុងរបៀបផ្ទាល់ គន្លឹះនឹងដំណើរការដូចការរំពឹងទុក
• ទិន្នន័យនឹងត្រូវបានផ្ទុកក្នុងរបៀបផ្ទាល់ ប៉ុន្តែគន្លឹះនឹងមិនត្រូវបានប្រតិបត្តិទេ។
• ទិន្នន័យនឹងត្រូវបានផ្ទុកនៅក្នុងរបៀបសាមញ្ញ គន្លឹះនឹងដំណើរការដូចដែលវាគួរតែ
• ទិន្នន័យនឹងត្រូវបានផ្ទុកនៅក្នុងរបៀបសាមញ្ញ ប៉ុន្តែគន្លឹះនឹងមិនត្រូវបានប្រតិបត្តិទេ។
• ទិន្នន័យនឹងមិនត្រូវបានផ្ទុកទេ កំហុសនឹងត្រូវបានកត់ត្រាទុក

ឆ្លើយតបជាទូទៅនេះគឺជាសំណួរនៃតក្កវិជ្ជា។ ដើម្បីស្វែងរកចម្លើយត្រឹមត្រូវ ខ្ញុំសូមណែនាំគំរូហេតុផលខាងក្រោម៖

1. ការបញ្ចូលក្នុងរបៀបផ្ទាល់ត្រូវបានអនុវត្តដោយការបង្កើតប្លុកទិន្នន័យដោយផ្ទាល់ដោយឆ្លងកាត់ម៉ាស៊ីន SQL ដែលធានានូវល្បឿនលឿន។ ដូច្នេះ ការធានាថាការប្រតិបត្តិនៃគន្លឹះគឺពិបាកណាស់ ប្រសិនបើមិនអាចទៅរួច ហើយគ្មានចំណុចណាមួយក្នុងរឿងនេះទេ ព្រោះវានឹងនៅតែបន្ថយល្បឿននៃការបញ្ចូល។
2. ការបរាជ័យក្នុងការប្រតិបត្តិគន្លឹះនឹងនាំឱ្យការពិតដែលថាប្រសិនបើទិន្នន័យនៅក្នុងតារាងគឺដូចគ្នានោះស្ថានភាពនៃមូលដ្ឋានទិន្នន័យទាំងមូល (តារាងផ្សេងទៀត) នឹងអាស្រ័យលើរបៀបដែលទិន្នន័យនេះត្រូវបានបញ្ចូល។ វាច្បាស់ណាស់ថាវានឹងបំផ្លាញភាពត្រឹមត្រូវនៃទិន្នន័យ ហើយមិនអាចអនុវត្តជាដំណោះស្រាយក្នុងផលិតកម្មបានទេ។
3. អសមត្ថភាពក្នុងការអនុវត្តប្រតិបត្តិការដែលបានស្នើសុំជាទូទៅត្រូវបានចាត់ទុកថាជាកំហុស។ ប៉ុន្តែនៅទីនេះយើងគួរចងចាំថា APPEND គឺជាព័ត៌មានជំនួយ ហើយតក្កវិជ្ជាទូទៅនៃព័ត៌មានជំនួយគឺថាពួកគេត្រូវបានយកមកពិចារណាប្រសិនបើអាចធ្វើទៅបាន ប៉ុន្តែប្រសិនបើមិនមាន ប្រតិបត្តិករត្រូវបានប្រតិបត្តិដោយមិនគិតពីព័ត៌មានជំនួយនោះទេ។

ដូច្នេះចម្លើយដែលរំពឹងទុកគឺ ទិន្នន័យនឹងត្រូវបានផ្ទុកក្នុងរបៀបធម្មតា (SQL) គន្លឹះនឹងឆេះ។

យោងតាមឯកសារ Oracle (ដកស្រង់ពី 8.04)៖

ការបំពានលើការរឹតបន្តឹងនឹងធ្វើឱ្យសេចក្តីថ្លែងការណ៍ដំណើរការជាស៊េរី ដោយប្រើផ្លូវបញ្ចូលធម្មតា ដោយគ្មានការព្រមាន ឬសារកំហុស។ ករណីលើកលែងគឺការរឹតបន្តឹងលើការចូលប្រើតារាងដូចគ្នាច្រើនជាងមួយដងក្នុងប្រតិបត្តិការ ដែលអាចបណ្តាលឱ្យមានសារកំហុស។
ឧទាហរណ៍ ប្រសិនបើកេះ ឬភាពត្រឹមត្រូវនៃសេចក្តីយោងមានវត្តមាននៅលើតារាង នោះព័ត៌មានជំនួយ APPEND នឹងត្រូវបានមិនអើពើ នៅពេលអ្នកព្យាយាមប្រើ 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 នាក់បានបោះឆ្នោត។ អ្នកប្រើប្រាស់ ១៤ នាក់ត្រូវបានហាមឃាត់។

ប្រភព: www.habr.com