‫ﻣﻤﻴﺰات ﻧﻈﺎم إدارة ﻗﺎﻋﺪة اﻟﺒﻴﺎﻧﺎت أوراآﻞ‬

‫ﻳﺘﻤﻴﺰ ﻧﻈﺎم ﻗﺎﻋﺪة اﻟﺒﻴﺎﻧﺎت أوراآﻞ ﻋﻦ ﻏﻴﺮﻩ ﻣﻦ ﻧﻈﻢ إدارة ﻗﻮاﻋﺪ اﻟﺒﻴﺎﻧﺎت اﻷﺧﺮى ﺑﺎﻵﺗﻲ‪:‬‬
‫‪ -1‬اﻟﻘﺪرة اﻟﻔﺎﺋﻘﺔ ﻋﻠﻰ اﺳﺘﻴﻌﺎب آﻤﻴﺎت آﺒﻴﺮة ﻣﻦ اﻟﺒﻴﺎﻧﺎت ﻗﺪ ﻳﺼﻞ ﻋﺪد اﻟﺴﺠﻼت إﻟﻰ‬
‫اﻟﻤﻼﻳﻴﻦ ﻣﻊ اﻟﺤﻔﺎظ ﻋﻠﻰ اﻟﻤﺴﺘﻮى اﻟﻌﺎﻟﻲ ﻓﻲ اﻷداء واﻟﺴﺮﻋﺔ ﻋﻨﺪ اﺳﺘﺮﺟﺎع واﻟﺘﺨﺰﻳﻦ‬
‫واﻟﺤﺬف‬
‫‪ -2‬ﻻﺳﺮﻳﺔ اﻟﺘﺎﻣﺔ واﻷﻣﻦ ﻻ ﺣﺘﻮاﺋﻪ ﻋﻠﻰ ﻧﻈﺎم اﻟﺼﻼﺣﻴﺎت واﻟﺤﻘﻮق اﻟﺬي ﻳﻀﻤﻦ ﺗﻄﺒﻴﻖ‬
‫اﻟﺸﺮوط اﻟﻘﻴﺎﺳﻴﺔ واﻷﻣﻨﻴﺔ ﻟﻠﺤﻔﺎظ ﻋﻠﻰ ﻗﺎﻋﺪة اﻟﺒﻴﺎﻧﺎت‬
‫‪ -3‬ﻓﻌﺎﻟﻴﺔ اﻟﺘﺤﻜﻢ اﻟﻤﺮآﺰي ﺑﺎﻟﺒﻴﺎﻧﺎت ﻻذي ﻳﻀﻤﻦ ‪:‬‬
‫• ﺗﻘﻠﻴﻞ اﻟﺘﻜﺮرات ﻋﻴﺮ اﻟﻼزﻣﺔ ﻓﻲ اﻟﺒﻴﺎﻧﺎت اﻟﺪﺧﻠﺔ )‪(No Repetition‬‬
‫• ﺗﺠﻨﺐ اﻟﺘﻨﺎﻗﺾ ﺑﻴﻦ اﻟﺒﻴﺎﻧﺎت )‪(No Contradiction‬‬
‫• إﻣﻜﺎﻧﻴﺔ اﻟﺘﺸﺎرك ﻓﻲ اﻟﺒﻴﺎﻧﺎت )‪(Data Sharing‬‬
‫• اﻟﺤﻔﺎظ ﻋﻠﻰ ﺗﻜﺎﻣﻞ اﻟﺒﻴﺎﻧﺎت ﻓﻴﻤﺎ ﺑﻴﻨﻬﺎ )‪(Data Integrity‬‬
‫‪ -4‬اﻟﺴﻴﻄﺮة اﻟﺘﺎﻣﺔ ﻋﻠﻰ ﻋﻤﻠﻴﺔ اﻟﻨﺴﺦ اﻻﺣﺘﻴﺎﻃﻲ ﻟﻘﺎﻋﺪة اﻟﺒﻴﺎﻧﺎت وﺣﻤﺎﻳﺘﻬﺎ ﻣﻦ اﻟﻔﻘﺪان أو‬
‫اﻟﺘﻠﻒ ﻣﻊ اﻣﻜﺎﻧﻴﺔ اﺳﺘﺮﺟﺎﻋﻬﺎ ﻓﻲ أي ﻟﺤﻈﺔ‬

‫ﻟﻐﺔ اﻻﺳﺘﻌﻼم ‪:sql‬‬

‫هﻰ ﻋﺒﺎرة ﻋﻦ ﻣﺠﻤﻮﻋﺔ ﻣﻦ اﻻواﻣﺮ اﻟﺘﻰ ﻳﺤﺘﺎﺟﻬﺎ اﻟﻤﺒﺮﻣﺠﻴﻦ وآﺬﻟﻚ اﻟﻤﺴﺘﺨﺪﻣﻴﻦ‬
‫ﻟﻠﻮﺻﻮل ﻟﻠﺒﻴﺎﻧﺎت اﻟﻤﻮﺟﻮدة ﺿﻤﻦ ﻗﺎﻋﺪة اورآﻞ‬

‫ﺗﺎرﻳﺨﻬﺎ‪:‬‬
‫ﺗﻢ ﺗﻄﻮﻳﺮ هﺬﻩ اﻟﻠﻐﺔ ﻓﻰ اﻟﺒﺪاﻳﺔ ﻣﻦ ﻗﺒﻞ ﺷﺮآﺔ ‪ ibm‬وذﻟﻚ ﻓﻰ ﻣﻨﺘﺼﻒ اﻟﺴﺒﻴﻌﻴﻨﺎت ﺛﻢ‬
‫ﻗﺎﻣﺖ ﺷﺮآﺔ اورآﻞ ﻓﻰ ‪ 1979‬ﺑﺘﻄﻮﻳﺮهﺎ وﺑﺎﻧﺘﺎج اول ﻧﺴﺨﺔ ﺗﺠﺎرﻳﺔ ﻣﻦ ﻟﻐﺔ ‪sql‬‬

‫ﻣﻤﻴﺰاﺗﻬﺎ‪:‬‬
‫• اﻧﻬﺎ ﻗﺎﻋﺪة ﺑﻴﺎﻧﺎت ﻗﻮﻳﺔ ﻣﻘﺎرﻧﺔ ﺑﻤﺜﻴﻠﺘﻬﺎ ﻣﺜﻞ )‪ (Access‬و)‪(Microsoft SQL Server‬‬
‫• اﻧﻬﺎ ﺗﺘﻤﺘﻊ ﺑﻘﺪر آﺒﻴﺮ ﻣﻦ اﻻﻣﺎن وهﻮ اﻟﺴﺒﺐ وراء اﻧﺘﺸﺎرهﺎ‬
‫• ﺳﺮﻳﻌﺔ ﺟﺪا ﻓﻰ ﻋﻤﻠﻴﺔ اﻟﺒﺤﺚ ﻣﻦ ﺧﻼﻟﻬﺎ‪.‬‬
‫و ﻳﻤﻜﻦ اﻟﺘﻌﺎﻣﻞ ﻣﻊ ﻗﺎﻋﺪة اﻟﺒﻴﺎﻧﺎت ﻣﻦ ﺧﻼﻟﻬﺎ وﻣﻦ ﺧﻼل هﺬﻩ اﻟﻠﻐﺔ ﻳﻤﻜﻦ اﻋﻄﺎء‬
‫ﺻﻼﺣﻴﺎت واﻣﺘﻴﺎزات ﻣﻤﺎرﺳﺔ ﻋﻤﻠﻴﺎت ﻣﻌﻴﻨﺔ ﻣﺜﻞ‪:‬‬
‫‪ -1‬اﻧﺸﺎء ﺟﺪاول )‪(create table‬‬
‫‪ -2‬اﻟﺘﻌﺪﻳﻞ ﻓﻴﻬﺎ )‪(alter‬‬
‫‪ -3‬ﺣﺬف ﺟﺪاول )‪(drop‬‬
‫‪ -4‬ﻣﻞء ﺟﺪاول اﻟﺒﻴﺎﻧﺎت )‪(insert‬‬
‫‪ -5‬ﺣﺬف اﻟﺒﻴﺎﻧﺎت اﻟﻤﺪﺧﻠﺔ )‪(delete‬‬
‫‪ -6‬اﻟﺘﻌﺪﻳﻞ ﻋﻠﻰ اﻟﺒﻴﺎﻧﺎت اﻟﻤﺪﺧﻠﺔ )‪(update‬‬
‫‪ – 7‬اﻟﺒﺤﺚ ﻋﻦ اﻟﺒﻴﺎﻧﺎت )‪(query‬‬
 ‫ﻣﻜﻮﻧﺎﺗﻬﺎ‪:‬‬
‫ﺗﻨﻘﺴﻢ ﻟﻐﺔ ‪ SQL‬اﻟﻰ ﺛﻼث اﻗﺴﺎم ﺣﻴﺚ ﺗﺸﻜﻞ آﻞ ﻣﺠﻤﻮﻋﺔ اواﻣﺮ ﻟﻐﺔ ﻓﺮﻋﻴﺔ ﻣﻦ‬
‫هﺬﻩ اﻟﻠﻐﺔ وهﻰ آﺎﻻﺗﻰ‪:‬‬

‫أواﻣﺮ ﻟﻐﺔ ﺗﻌﺮﻳﻒ اﻟﺒﻴﺎﻧﺎت )‪Data Definition Language (DDL‬‬ ‫‪-1‬‬

‫ﺗﺴﺘﺨﺪم هﺬﻩ اﻟﻠﻐﺔ ﻓﻲ ﺗﻌﺮﻳﻒ وإﻧﺸﺎء اﻟﻜﺎﺋﻦ ‪ ، Object‬وﻳﻤﻜﻦ أن ﻳﻜﻮن اﻟﻜﺎﺋﻦ ﻣﻠﻔﺎت‬
‫وﺟﺪاول ﺑﻴﺎﻧﺎت ‪ ،‬ﻓﻴﻤﻜﻨﻨﺎ إﻧﺸﺎء وﺗﻌﺪﻳﻞ وﺣﺬف اﻟﻜﺎﺋﻦ وﻳﻤﻜﻨﻨﺎ إﻧﺸﺎء اﻣﺘﻴﺎز ﻟﻤﺴﺘﺨﺪم‬
‫ﻣﻌﻴﻦ ‪ ،‬أو اﻧﺸﺎء آﺎﺋﻦ ﺧﻴﺎرات ﻟﻔﺤﺺ وإﺿﺎﻓﺔ ﺗﻌﻠﻴﻘﺎت إﻟﻰ ﻗﺎﻣﻮس اﻟﺒﻴﺎﻧﺎت‬
‫وﺗﺤﺘﻮى ﻋﻠﻰ ﺛﻼث اواﻣﺮ وهﻰ ‪:‬‬
‫• اﻣﺮ )‪ (Create table‬ﻳﺴﺘﺨﺪم ﻻﻧﺸﺎء اﻟﺠﺪاول‬
‫• اﻣﺮ)‪ (Alter table‬ﻳﺴﺘﺤﺪم ﻟﻠﺘﻌﺪﻳﻞ ﻓﻰ ﺟﺪول ﻣﻨﺸﺎ ﺳﺎﺑﻘﺎ‬
‫• اﻣﺮ )‪ (Drop table‬ﻳﺴﺘﺨﺪم ﻓﻰ ﺣﺬف ﺟﺪول ﻏﻴﺮ ﻣﺮﻏﻮب ﻓﻴﻪ‬
‫ﺣﻴﺚ ﻳﻘﺘﺼﺮ ﻋﻤﻞ هﺬﻩ اﻻواﻣﺮ ﻋﻠﻰ اﻟﺠﺪاول وﺣﻘﻮﻟﻬﺎ ﻓﻘﻂ دون اﻟﺘﻌﺮض ﻟﻠﺒﻴﺎﻧﺎت‬
‫اﻟﺘﻰ ﺑﺪاﺧﻞ اﻟﺠﺪاول‬

‫‪ -2‬أواﻣﺮ ﻟﻐﺔ ﻣﻌﺎﻣﻠﺔ اﻟﺒﻴﺎﻧﺎت )‪Data Manipulation Language (DML‬‬

‫ﺗﺘﻴﺢ هﺬﻩ اﻷواﻣﺮ اﻟﺘﻌﺎﻣﻞ ﻣﻊ اﻟﺒﻴﺎﻧﺎت وﺗﻌﺪﻳﻠﻬﺎ ﺿﻤﻦ اﻟﻜﺎﺋﻦ اﻟﻤﻮﺟﻮد ‪Object‬‬
‫وﺗﺤﺘﻮى ﻋﻠﻰ ارﺑﻌﺔ اواﻣﺮ وهﻰ‪:‬‬
‫اﻣﺮ )‪ (Insert into‬ﻳﺴﺘﺨﺪم ﻓﻰ ادﺧﺎل اﻟﺒﻴﺎﻧﺎت اﻟﻰ اﻟﺠﺪاول‬ ‫•‬
‫اﻣﺮ )‪ (Update‬ﻳﺴﺘﺨﺪم ﻓﻰ ﺗﻌﺪﻳﻞ اﻟﺒﻴﺎﻧﺎت ﻓﻰ اﻟﺠﺪاول‬ ‫•‬
‫اﻣﺮ )‪ (Delete‬ﻳﺴﺘﺨﺪم ﻓﻰ ﺣﺬف اﻟﺒﻴﺎﻧﺎت ﻣﻦ اﻟﺠﺪول‬ ‫•‬
‫اﻣﺮ )‪ (Select‬ﻳﺴﺘﺤﺪم ﻓﻰ اﻻﺳﺘﻌﻼم ﻋﻦ ﺷﻰء ﻣﻌﻴﻦ ﺑﻴﺎﻧﺎت اﻟﺠﺪول‬ ‫•‬

‫‪-3‬أواﻣﺮ ﻟﻐﺔ اﻟﺘﺤﻜﻢ ﻓﻲ اﻟﺒﻴﺎﻧﺎت )‪Data Control Language (DCL‬‬

‫ﺗﺘﻴﺢ هﺬﻩ اﻷواﻣﺮ اﻟﺘﺤﻜﻢ ﻓﻲ ﻗﺎﻋﺪة اﻟﺒﻴﺎﻧﺎت وأداﺋﻬﺎ آﺎﻟﺼﻼﺣﻴﺎت واﻟﻤﺴﺘﺨﺪﻣﻴﻦ‬

‫واﻟﺤﻘﻮق وﻏﺎﻟﺒﺎ ﻣﺎﺗﻜﻮن هﺬﻩ اﻷواﻣﺮ ﻣﺨﺼﺼﺔ ﻟﻼﺳﺘﺨﺪام ﻣﻦ ﻗﺒﻞ ﻣﺪﻳﺮ ﻗﺎﻋﺪة اﻟﺒﻴﺎﻧﺎت‬
‫)‪ (DBA‬وﻣﻦ هﺬﻩ اﻻواﻣﺮ ‪GRANT and REVOKE :‬‬

‫أﺳﺎﺳﻴﺎت ﺟﻤﻠﺔ ‪SELECT‬‬

‫اﻷهﺪاف ‪:‬‬
‫ﺑﻌﺪ إآﻤﺎلِ هﺬا اﻟﺪرسِ‪ ،‬أﻧﺖ ﻳﺠِﺐ أَن ﺗﻜﻮن ﻗﺎدر إِﻟﻰ ﻋﻤﻞ اﻟﺘﺎﻟﻲ ‪:‬‬
‫‪ .1‬اﻟﻘﺪرة ﻋﻠﻰ ﺗﻨﻔﻴﺬﺟﻤﻠﺔ ‪.SELECT‬‬
‫‪ .2‬اﻟﻔﺮق ﺑﻴﻦ ‪ SQL*PLUS‬و ‪iSQL* plus‬‬

‫هﺪف اﻟﺪرس‪:‬‬
‫ﺟﻤﻠﺔ ‪SELECT‬‬
‫ﺗﺴﺘﺨﺪم ﺟﻤﻠﺔ ‪ SELECT‬ﻻﺳﺘﺮﺟﺎع اﻟﺒﻴﺎﻧﺎت اﻟﻤﺨﺰﻧﺔ ﻓﻲ ﺟﺪول أو ﻋﺪة ﺟﺪاول ﺣﻴﺚ أن‬
‫ﻋﻤﻠﻴﺔ اﻻﺳﺘﺮﺟﺎع ﻻ ﺗﻌﺪل ﻓﻲ هﺬﻩ اﻟﺒﻴﺎﻧﺎت وﻳﻤﻜﻨﻨﺎ ﻣﻦ ﺧﻼل ﺟﻤﻠﺔ ‪ SELECT‬أن ﻧﻘﻮم ﺑﺎﻟﺘﺎﻟﻲ‪:‬‬

‫اﺧﺘﻴﺎر وﻋﺮض ﻣﺠﻤﻮﻋﺔ ﻣﻌﻴﻨﺔ ﻣﻦ اﻟﺴﺠﻼت اﻟﻤﺨﺰﻧﺔ ﻓﻲ اﻟﺠﺪول‬ ‫‪-1‬‬

‫اﺳﺘﺮﺟﺎع ﺑﻴﺎﻧﺎت ﺑﻌﺾ ﺣﻘﻮل اﻟﺠﺪول‬ ‫‪-2‬‬
‫اﺳﺘﺮﺟﺎع ﺑﻴﺎﻧﺎت ﻣﺨﺰﻧﺔ ﻓﻲ ﺟﺪاول ﻣﺨﺘﻠﻔﺔ‬ ‫‪-3‬‬
 ‫و ﻳﻤﻜﻦ أَن ﺗﻨﺸﺊ ﺟﻤﻞ ‪ SELECT‬أآﺜﺮ ﻣﻦ ﻣﺮة‪.‬‬
‫هﺬا اﻟﺪرس ﻳﻐﻄﻲ أﻳﻀﺎ ‪ ISQL*Plus‬ﺣﻴﺚ ﺗﻨﻔﺬ ﺟﻤﻞ ‪.Sql‬‬
‫ﻣﻼﺣﻆ ‪ iSQL* plus :‬ﻳﻌﺘﺒﺮ ﻣﻜﺎن ﺟﺪﻳﺪ ﻟﻜﺘﺎﺑﺔ اﻟﻜﻮد ﺑﺪاﺧﻠﺔ وذﻟﻚ ﻓﻰ اﻷﺻﺪار‬
‫‪ .ORACLE 10G‬ذﻟﻚ ﺑﺎﻷﺿﺎﻓﺔ اﻟﻰ اﻟﻤﻜﺎن اﻟﻘﺪﻳﻢ ‪.SQL*PLUS‬‬

‫اﺳﺘﺨﺪاﻣﺎت ﺟﻤﻠﺔ ‪: SELECT‬‬

‫* ‪ : PROJECTION‬ﻳﺴﺘﺨﺪم ﻓﻲ اﺧﺘﻴﺎر ﻋﻤﻮد أو أآﺜﺮ ﻣﻦ ﺟﺪول ﻣﻌﻴﻦ ‪.‬‬
‫* ‪ : S ELECTION‬ﻳﺴﺘﺨﺪم ﻓﻲ اﺧﺘﻴﺎر ﺻﻒ أو أآﺜﺮ ﻣﻦ ﺻﻒ ذﻟﻚ ﻣﻦ ﺟﺪول‬
‫ﻣﻌﻴﻦ‪.‬‬
‫‪ :‬ﻳﺴﺘﺨﺪم ﻟﻠﺤﺼﻮل ﻋﻠﻰ ﺑﻴﺎﻧﺎت ﻣﻦ ﺟﺪوﻟﻴﻦ ﻣﻦ ﺧﻼل اﻟﺮﺑﻂ‬ ‫* ‪JOIN‬‬
‫ﺑﻴﻨﻬﻤﺎ ﺑﺎﺣﺪى اﻟﻄﺮق اﻟﻤﺨﺘﻠﻔﺔ اﻟﺘﻰ ﺳﻮف ﻧﺮاهﺎ ﻓﻰ اﻟﻔﺼﻞ اﻟﺮاﺑﻊ‪.‬‬

‫اﻟﺸﻜﻞ اﻟﺘﺎﻟﻰ ﻳﻮﺿﺢ اﻟﻤﻔﺎهﻴﻢ اﻟﺴﺎﺑﻘﺔ و ﻻﺣﻆ اﻟﺘﻈﻠﻴﻞ‪:‬‬

‫ﺟﻤﻠﺔ ) ‪ (SELECT Statement‬ﺗﺴﺘﺮﺟﻊ اﻟﻤﻌﻠﻮﻣﺎت ﻣﻦ ﻗﺎﻋﺪة اﻟﺒﻴﺎﻧﺎت ﺑﺎﺣﺪى‬

‫اﻟﻄﺮق اﻟﺘﺎﻟﻴﺔ ‪:‬‬

‫* اﻹﺳﻘﺎط ) ‪ :( PROJECTION‬و ﺑﻬﺬا ﻳﻤﻜﻦ اﺳﺘﺨﻼص ﻋﻤﻮد أو أآﺜﺮ ﻣﻦ ﻋﻤﻮد‬

‫ﻣﻦ اﻟﺠﺪول وﻟﻜﻦ ﺑﺪون اﻣﻜﺎﻧﻴﺔ ﺗﺤﺪﻳﺪ ﺻﻒ ﻣﻌﻴﻦ‪.‬‬

‫* اﻻﺧﺘﻴﺎر ) ‪ :( SELECTION‬وهﺬا ﻳﻌﻨﻰ اﻧﺔ ﻳﻤﻜﻦ أَن ﺗﺨﺘﺎر ﻣﺠﻤﻮﻋﺔ ﻣﻦ‬

‫اﻟﺼﻔﻮف ذﻟﻚ ﻋﻦ ﻃﺮﻳﻖ اَﺳﺘﻌﻤﺎل ﻣﺠﻤﻮﻋﺔ ﻣﻌﺎﻳﻴﺮ ﻳﻤﻜﻦ ﺑﻬﺎ ﺗﺤﺪﻳﺪ اﻟﺼﻔﻮف اﻟﺘﻲ ﺗﺮاهﺎ )‬
‫اﺧﺘﻴﺎر اﻓﻘﻰ ( ‪.‬‬

‫* اﻟﺮﺑﻂ ) ‪ :( JOIN‬أﻧﺖ ﻳﻤﻜﻦ أَن ﺗﺴﺘﻌﻤﻞ اﻟﺮﺑﻂ ﻓﻲ ‪ SQL‬وهﺬا ﻳﻌﻨﻰ اﻣﻜﺎﻧﻴﺔ‬

‫اﺳﺘﺨﻼص ﺑﻴﺎﻧﺎت ﻣﻦ ﺟﺪوﻟﻴﻦ أو أآﺜﺮ ﻣﻦ ﺟﺪول ﻋﻦ ﻃﺮﻳﻖ إﻧﺸﺎء رﺑﻂ ﺑﻴﻨﻬﻢ ﺑﺎﺣﺪى‬
‫اﻟﻄﺮق اﻟﻤﺨﺘﻠﻔﺔ‪.‬‬
 ‫‪SQL‬‬ ‫آﺘﺎﺑﺔ ﺟﻤﻞ‬
‫ﻧﻮﺿﺢ ﻓﻴﻤﺎ ﻳﻠﻲ ﺑﻌﺾ اﻟﻘﻮاﻋﺪ اﻹرﺷﺎدﻳﺔ اﻟﺘﻲ ﻳﺠﺐ أن ﺗﻮﺿﻊ ﺑﻌﻴﻦ اﻻﻋﺘﺒﺎر ﻏﻨﺪ آﺘﺎﺑﺔ ﺟﻤﻞ‬
‫‪SQL‬‬

‫ﻳﻤﻜﻦ آﺘﺎﺑﺔ ﺟﻤﻞ ‪ SQL‬ﺑﺎﻟﺤﺮوف اﻟﻜﺒﻴﺮة أو اﻟﺼﻐﻴﺮة‬ ‫‪-1‬‬

‫ﻳﻤﻜﻦ آﺘﺎﺑﺔ ﺟﻤﻞ ‪ SQL‬ﻓﻲ ﻋﺬة أﺳﻄﺮ‬ ‫‪-2‬‬
‫ﻻ ﻳﻤﻜﻦ ﻓﺼﻞ اﻟﻜﻠﻤﺎت اﻟﻤﺤﺠﻮزة ﻋﺒﺮ اﻟﺴﻄﻮر ﻣﺜﻞ ‪FROM‬‬ ‫‪-3‬‬
‫اﺗﺮك ﻣﺴﺎﻗﺎت ﺑﻴﻦ ﻣﻜﻮﻧﺎت اﻟﺠﻤﻠﺔ ﻟﺘﺴﻬﻴﻞ ﻋﻤﻠﻴﺔ اﻟﻘﺮاءة‬ ‫‪-4‬‬
‫ﻓﻲ ﺑﺮﻧﺎﻣﺞ ‪ SQL *PLUS‬ﺗﻜﺘﺐ اﻷواﻣﺮ ﻣﻊ ﻣﺆﺷﺮ ‪ SQL‬وﻳﺘﻢ ﺗﺨﺰﻳﻦ هﺬا اﻟﻤﺮ‬ ‫‪-5‬‬
‫ﻣﺒﺎﺷﺮة ﻓﻲ اﻟﺬاآﺮة‬

‫‪SELECT‬‬ ‫}…‪* | { [DISTINCT] column | expression [alias] ,‬‬

‫‪FROM‬‬ ‫; ‪table‬‬

‫ﻣﻦ اﻟﺸﻜﻞ اﻟﺴﺎﺑﻖ ‪ ،‬ﺟﻤﻠﺔ ‪ SELECT‬ﻳﻤﻜﻦ أَن ﺗﺘﻀﻤﻦ اﻟﺘﺎﻟﻲ ‪:‬‬

‫* ﻓﻘﺮة ‪ ،SELECT‬ﺗﺤﺪد اﻷﻋﻤﺪة اﻟﺘﻲ ﺳﻮف ﺗﻌﺮض ﺳﻮاء آﺎن ﻋﻤﻮد أو أآﺜﺮ‪.‬‬
‫‪،‬ﺗﺤﺪد اﻟﺠﺪاول اﻟﺘﻲ ﺗﺤﺘﻮي ﻋﻠﻰ اﻷﻋﻤﺪة اﻟﺘﻰ ﺳﺠﻠﺖ ﻓﻲ ﻓﻘﺮة‬ ‫* ‪FROM‬‬
‫اﻟﺴﺎﺑﻘﺔ ﻋﻠﻰ اﻟﻨﺤﻮ اﻟﺘﺎﻟﻲِ ‪:‬‬ ‫‪SELECT‬‬

‫ﺗﻌﻨﻰ اﺧﺘﻴﺎر ﻋﻤﻮد أو أآﺜﺮ ﻣﻦ ﻋﻤﻮد‪.‬‬ ‫‪SELECT‬‬

‫ﺗﻌﻨﻰ اﺧﺘﻴﺎر آﻞ اﻷﻋﻤﺪة ﺑﺪون ﺗﺤﺪﻳﺪ اﺳﻤﺎﺋﻬﻢ‪.‬‬ ‫*‬
‫اﺧﻔﺎء اﻟﺘﻜﺮار ﻓﻰ ﺑﻴﺎﻧﺎت اﻟﻌﻤﻮد‪.‬‬ ‫‪DISTINCT‬‬

‫اﻟﻌﻤﻮد اﻟﺬى ﺗﻢ اﻟﻌﻤﻞ ﻋﻠﻴﺔ ﻋﻤﻠﻴﺔ ﺣﺴﺎﺑﻴﺔ ﺑﺪاﺧﻞ ﺟﻤﻠﺔ‬ ‫‪Column /expression‬‬
‫‪.SELECT‬‬

‫) اﻻﺳﻢ (اﻟﻤﺴﺘﻌﺎر ﻳﻌﻄﻲ اﻷﻋﻤﺪة اﻟﻤﺨﺘﺎرة ﻋﻨﺎوﻳﻦ ﻏﻴﺮ‬ ‫‪alias‬‬

‫أﺳﻤﺎﺋﻬﺎ‬
‫اﻟﺤﻘﻴﻘﻴﺔ‪.‬‬

‫آﻴﻔﻴﺔ ﻋﻤﻞ ) ‪:(ALIAS‬‬

‫‪ last_name‬اﻟﻰ ‪ name‬آﻤﺎ ﻓﻰ اﻟﻤﺜﺎل‬ ‫ﻋﻨﺪﻣﺎ ﺗﺮﻳﺪ ﺗﻐﻴﺮ اﺳﻢ اﻟﻌﻤﻮد ﻣﻦ‬
‫اﻟﺘﺎﻟﻰ ﻓﻬﺬا هﻮ ﻣﺎ ﻳﺴﻤﻰ ‪ alias‬و هﺬا ﻳﻜﻮن ﻓﻰ اﻟﺠﺪول اﻟﻤﻌﺮوض ﻓﻘﻂ و ﻳﺒﻘﻰ‬
‫اﺳﻢ اﻟﻌﻤﻮد ﺑﺎﻟﺠﺪول داﺧﻞ ﻗﺎﻋﺪة اﻟﺒﻴﺎﻧﺎت آﻤﺎ هﻮ دون ﺗﻐﻴﺮ‪.‬‬
‫‪ FROM table‬ﺗﺤﺪد اﻟﺠﺪاول اﻟﺘﻲ ﺗﺤﺘﻮي ﻋﻠﻰ اﻷﻋﻤﺪة‬

‫‪-: Alias‬‬ ‫ﻃﺮق اﺳﺘﺨﺪام‬

‫ﻳﻤﻜﻦ آﺘﺎﺑﺔ اﻻﺳﻢ اﻟﻤﺴﺘﻌﺎر) ‪ (ALIAS‬ﺑﻌﺪ آﺘﺎﺑﺔ اﺳﻢ اﻟﻌﻤﻮد اﻟﺤﻘﻴﻘﻰ‬ ‫„‬
‫ﺑﺸﺮط وﺟﻮد ﻣﺴﺎﻓﺔ ﺑﻴﻦ اﻻﺳﻤﻴﻦ وان ﻳﻜﻮن اﻻﺳﻢ اﻟﻤﺴﺘﻌﺎر ﻻ ﻳﺤﺘﻮى‬
‫ﻋﻠﻰ ﻣﺴﺎﻓﺔ‪.‬‬
‫ﻳﻤﻜﻦ آﺘﺎﺑﺔ اﻻﺳﻢ اﻟﻤﺴﺘﻌﺎر) ‪ (ALIAS‬ﺑﺔ ﻣﺴﺎﻓﺔ وﻟﻜﻦ ﻻﺑﺪ ﻣﻦ آﺘﺎﺑﺔ‬ ‫„‬
‫اﻻﺳﻢ اﻟﻤﺴﺘﻌﺎر ﺑﻴﻦ ‪double quotation‬‬
 ‫‪Example 1‬‬
‫; "‪Select ename NAME from "T emp‬‬

‫ﺗﻢ وﺿﻊ ‪ double quotation‬ﻻن اﻻﺳﻢ اﻟﻤﺴﺘﻌﺎر ﻳﺤﺘﻮى ﻋﻠﻰ ﻣﺴﺎﻓﺔ‪.‬‬

‫‪Example 2‬‬
‫‪Select FIRST_NAME NAMESSS ,JOB_ID‬‬
‫‪from employees‬‬

‫‪ FIRST_NAME‬ﺗﺤﻮل اﺳﻤﻪ اﻟﻰ ‪NAMESSS‬‬ ‫ﻧﻼﺣﻆ ان هﻨﺎ‬

‫ﻣﺜﺎل ﻻﺧﺘﻴﺎر آﻞ اﻷﻋﻤﺪة ﺑﺪون ذآﺮ اﺳﻤﺎﺋﻬﺎ ‪:‬‬

‫ﻓﻲ اﻟﻤﺜﺎل ﺗﻢ ﻋﺮض آﻞ اﻟﺼﻔﻮف ﺑﺎﻟﺠﺪول وذﻟﻚ ﻷن أﻣﺮ ‪ SELECT‬ﻟﻢ ﻳﺘﺒﻌﻪ ﺷﺮط‬
‫ﺗﺤﺪﻳﺪ ﻋﺪد اﻟﺼﻔﻮف‪.‬‬
‫‪SELECT‬‬ ‫اﺳﺘﺨﺪام أواﻣﺮ ‪SQL‬‬
‫وهﻮ ﻳﺴﺘﻌﺮض ﺑﻴﺎﻧﺎت اﻟﺠﺪول وﺗﺸﻴﺮ اﻟﻨﺠﻤﺔ اﻟﻤﺴﺘﺨﺪﻣﺔ * اﻟﻰ إﻇﻬﺎر ﺟﻤﻴﻊ أﻋﻤﺪة‬
‫اﻟﺠﺪول ﺛﻢ ﻧﻜﺘﺐ أﻣﺮ ‪ FROM‬ﻳﻠﻴﻪ أﺳﻢ اﻟﺠﺪول اﻟﺬي ﻳﺮاد اﻻﺳﺘﻌﻼم ﻋﻦ ﺑﻴﺎﻧﺎﺗﻪ وﺑﻌﺪ‬
‫اﻧﺘﻬﺎء اﻷﻣﺮ ﻳﺘﻢ وﺿﻊ ;‬
‫ﻻﺣﻆ أن أواﻣﺮ ‪ SQL‬ﺗﻄﻠﺐ آﺘﺎﺑﺔ ﻓﺼﻠﺔ ﻣﻨﻘﻮﻃﺔ) ;( ﻓﻲ ﺁﺧﺮ اﻷﻣﺮ وهﻨﺎ ﺳﻴﺘﻢ‬
‫اﺳﺘﻌﺮاض ﺟﻤﻴﻊ ﺑﻴﺎﻧﺎت أﻋﻤﺪة اﻟﺠﺪول ﻣﻠﺤﻮﻇﺔ أواﻣﺮ ‪ SQL‬ﻻ ﺗﺨﺘﺼﺮ ﻣﺜﻞ آﺘﺎﺑﺔ ‪SEL‬‬
‫‪ .‬أﻧﺖ ﻳﻤﻜﻦ أَن ﺗﻌﺮض آﻞ أﻋﻤﺪة اﻟﺠﺪول ﺑﻜﺘﺎﺑﺔ اﻟﻜﻠﻤﺔ اﻟﺮﺋﻴﺴﻴﺔ ‪ SELECT‬وﻳﻠﻴﻬﺎ‬
‫ﺑﻨﺠﻤﺔ )*(‬

‫ﻣﻦ اﻟﻤﺜﺎل اﻟﺴﺎﺑﻖ ﻧﺠﺪ أن ﺟﺪول اﻻﻗﺴﺎم ﻳﺤﺘﻮي ﻋﻠﻲ أرﺑﻌﺔ أﻋﻤﺪة وهﻢ‪:‬‬
‫‪DEPARTMENT_ID , DEPARTMENT_NAME, MANAGER_ID , LOCATION_ID .‬‬

‫أﻧﺖ ﻳﻤﻜﻦ أَن ﺗﻌﺮض أﻳﻀﺎ آﻞ اﻷﻋﻤﺪة ﻓﻲ اﻟﺠﺪاول ﺑﺘﺴﺠﻴﻞ آﻞ اﻷﻋﻤﺪة ﺑﻌﺪ‬
‫آﻠﻤﺔ ‪SELECT‬‬
‫ﺑﺪﻻ ﻣﻦ اﺳﺘﺨﺪام اﻟﻨﺠﻤﺔ)*(‪.‬‬
 ‫‪Example:‬‬

‫‪SELECT department_id, department_name, manager_id,location_id‬‬

‫‪FROM‬‬ ‫; ‪departments‬‬

‫وﻳﻤﻜﻦ ان ﻧﺨﺘﺎر ﻋﺪد ﻣﺤﺪد ﻣﻦ اﻻﻋﻤﺪة ﻓﻘﻂ ذﻟﻚ ﻋﻦ ﻃﺮﻳﻖ آﺘﺎﺑﺔ اﺳﻤﺎء اﻻﻋﻤﺪة‬
‫اﻟﻤﺮاد ﻋﺮﺿﻬﺎ ﺑﻌﺪ آﻠﻤﺔ ‪ SELECT‬ووﺿﻊ ‪ (,) coma‬ﺑﻴﻦ آﻞ ﻋﻤﻮد آﻤﺎ ﻓﻰ اﻟﻤﺜﺎل‬
‫اﻟﺘﺎﻟﻰ‪:‬‬

‫اﺧﺘﻴﺎر اﻷﻋﻤﺪة اﻟﻤﺤﺪدة‬

‫وهﺬا ﻳﻌﻨﻰ اﻧﻨﺎ ﻣﻦ اﻟﻤﻤﻜﻦ ﻋﺮض أﻋﻤﺪة ﻣﺤﺪدة وﻟﻴﺴﺖ آﻞ اﻷﻋﻤﺪة‪.‬‬

‫وﻻﺣﻆ ان ﺗﺮﺗﻴﺐ ﻇﻬﻮر اﻻﻋﻤﺪة ﻳﻜﻮن ﻋﻠﻰ اﺳﺎس ﺗﺮﺗﻴﺐ ﺗﻠﻚ اﻻﻋﻤﺪة ﻓﻰ ﺟﻤﻠﺔ‬
‫‪.SELECT‬‬
‫ﺑﻌﺪهﺎ ‪department_id‬‬ ‫‪SELECT‬‬ ‫ﻓﺎﻟﻔﺮق ﺑﻴﻦ اﻟﻤﺜﺎﻟﻴﻦ ﺣﻴﺚ اﻷول آﺎن‬
‫وﻋﺮﺿﺖ أوﻻ ﻳﺴﺎرا ﻓﻲ اﻟﺠﺪول ﻋﻜﺲ اﻟﻤﺜﺎل اﻟﺘﺎﻟﻰ ﺣﻴﺚ ﺟﺎءت ﻓﻲ اﻟﺘﺮﺗﻴﺐ اﻟﺜﺎﻧﻲ ‪.‬‬

‫‪SELECT location_id, department_id‬‬

‫‪FROM‬‬ ‫; ‪departments‬‬
‫‪LOCATION_ID‬‬ ‫‪DEPARTMENT_ID‬‬
‫‪1700‬‬ ‫‪10‬‬
‫‪1800‬‬ ‫‪20‬‬
‫‪1500‬‬ ‫‪50‬‬

‫‪:dept‬‬ ‫‪table‬‬ ‫اﺧﺘﻴﺎر ‪ 2‬ﻋﻤﻮد ﻣﻦ‬

‫آﺘﺎﺑﺔ ﺟﻤﻞ ‪SQL‬‬

‫‪ .1‬ﺟﻤﻞ ‪ SQL‬ﻳﻤﻜﻦ أَن ﺗﻜﻮن ﻓﻰ ﺳﻄﺮ أو أآﺜﺮ ﻣﻦ ﺳﻄﺮ أي ﻳﻤﻜﻦ آﺘﺎﺑﺘﻬﺎ ﻓﻰ‬
‫ﻋﺪة ﺳﻄﻮرِ‪.‬‬
‫‪ .2‬آﻠﻤﺎﺗﻬﺎ اﻟﺮﺋﻴﺴﻴﺔ ﻻ ﻳﻤﻜﻦ أَن ﺗﺨﺘﺼﺮ أو ﺗﻨﻔﺼﻞ ﻋﺒﺮ اﻟﺴﻄﻮر ‪.‬‬
‫‪ .3‬ﻓﻘﺮاﺗﻬﺎ ﺗﻮﺿﻊ ﻋﺎدة ﻋﻠﻰ ﺳﻄﻮر ﻣﻨﻔﺼﻠﺔ ﻟﺘﺴﻬﻴﻞ ﻣﺮاﺟﻌﺘﻬﺎ ‪.‬‬
‫‪ .4‬ﺗﺮك ﻣﺴﺎﻓﺎت ﺑﻴﻦ ﻣﻜﻮﻧﺎت اﻟﺠﻤﻠﺔ آﻲ ﺗﺤﺴﻦ اﻟﻘﺮاءة‪.‬‬
 ‫ﺗﻨﻔﻴﺬ ﺟﻤﻞ ‪SQL‬‬
‫ﻓﻲ ‪ ،ISQL*Plus‬اﻧﻘﺮ ﻋﻠﻰ زر اﻟﺘﻨﻔﻴﺬ )‪ (Execute‬ﻟﻜﻲ ﻳﺘﻢ اﻟﺘﻨﻔﻴﺬ ‪.‬‬

‫ﻣﻼﺣﻈﺔ‬
‫);( ‪ semicolon‬ﻓﻲ ﻧﻬﺎﻳﺔ‬ ‫ﻳﺘﻄﻠﺐ ﻓﻲ ‪ ISQL*PLUS‬او ‪ SQL*PLUS‬أن ﺗﻀﻊ‬
‫اﻟﻔﻘﺮة اﻷﺧﻴﺮة‬
‫أﺧﺘﻼف ﻋﻨﻮان اﻟﻌﻤﻮد ﺑﻴﻦ ‪SQL*PLUS & ISQL*Plus:‬‬ ‫•‬

‫‪:Sql*plus‬‬
‫‪ .1‬ﻋﻨﺎوﻳﻦ اﻟﺤﺮوف و اﻟﺘﻮارﻳﺦ ﻟﺮأس اﻟﻌﻤﻮد ﺗﻈﻬﺮ ﻳﺴﺎرا ‪.‬‬
‫‪ .2‬ﻋﻨﺎوﻳﻦ رأس اﻟﻌﻤﻮد ﻟﻸرﻗﺎم ﺗﻈﻬﺮ ﻳﻤﻴﻨﺎ‪.‬‬
‫‪ .3‬ﺗﻌﺮض اﻟﻌﻨﺎوﻳﻦ ﺑﺤﺮوف آﺒﻴﺮة‬

‫‪SELECT ename, date, sal‬‬

‫‪FROM emp‬‬ ‫;‬
‫‪ENAM‬‬ ‫‪DATE‬‬ ‫‪SAL‬‬
‫‪KING‬‬ ‫‪17-JUN-87‬‬ ‫‪1500‬‬

‫‪:ISQL*Plus‬‬
‫* ﻋﻨﻮان اﻟﻌﻤﻮد ﻳﻮﺿﻊ ﻓﻲ اﻟﻤﻨﺘﺼﻒ‪.‬‬
‫ﻋﺮض اﻟﻌﻨﻮان )ﻓﻲ أﻋﻠﻰ اﻟﺼﻔﺤﺔ( ﺑﺤﺮوف آﺒﻴﺮة وﻓﻰ اﻟﻮﺳﻂ‪.‬‬ ‫•‬

‫‪SELECT last_name, hire_date, salary‬‬

‫;‪FROM employees‬‬
 ‫اﻟﻌﻤﻠﻴﺎت اﻟﺤﺴﺎﺑﻴﺔ‬ ‫‪1-9‬‬

‫اﻟﻮﺻﻒ‬ ‫اﻟﻌﻤﻠﻴﺔ‬
‫اﻹﺿﺎﻓﺔ‬ ‫‪+‬‬
‫اﻟﻄﺮح‬ ‫‪-‬‬
‫اﻟﻀﺮب‬ ‫*‬
‫اﻟﻘﺴﻤﺔ‬ ‫‪/‬‬

‫اﻟﻌﻤﻠﻴﺎت اﻟﺤﺴﺎﺑﻴﺔ‬
‫ورﺑﻤﺎ ﺗﺤﺘﺎج أَن ﺗﻌﺪل ﻃﺮﻳﻘﺔ ﻋﺮض اﻟﺒﻴﺎﻧﺎت ﻟﺘﺆدي ﺣـﺴﺎﺑﺎت ﻣﻌﻴﻨـﺔ ‪،‬دون أن ﺗـﺆﺛﺮ ﻋﻠـﻰ‬
‫اﻟﺒﻴﺎﻧﺎت اﻟﻤﺨﺰﻧﺔ ﻓﻲ اﻟﺠﺪول‪ .‬هﺬا ﻳﺘﻢ ﺑﺎَﺳﺘﻌﻤﺎل اﻟﻌﻤﻠﻴﺎت اﻟﺤـﺴﺎﺑﻴﺔ‪ .‬ﻳﻤﻜـﻦ أَن ﻳﺤﺘـﻮي‬
‫اﻟﺘﻌﺒﻴﺮ اﻟﺤﺴﺎﺑﻲ ﻋﻠﻲ أﺳﻢ اﻟﻌﻤﻮد‪،‬او ﻗﻴﻤﺔ ﺛﺎﺑﺘﺔ‪،‬واﻟﻌﻮاﻣﻞ اﻟﺤﺴﺎﺑﻴﺔ ﻣﺜﻞ)‪. (/,+,*,-‬‬
‫اﻟﻌﻮاﻣﻞ اﻟﺤﺴﺎﺑﻴﺔ‬
‫ح اﻟﺠﺪول اﻟﺴﺎﺑﻖ اﻟﻌﻮاﻣﻞ اﻟﺤﺴﺎﺑﻴﺔ اﻟﻤﺘﻮﻓﺮة ﻓﻲ ‪ .SQL‬أﻧﺖ ﻳﻤﻜﻦ أَن ﺗﺴﺘﻌﻤﻞ‬ ‫ﻳﺸﺮ ُ‬
‫اﻟﻌﻮاﻣﻞ اﻟﺤﺴﺎﺑﻴﺔ ﻓﻲ أي ﻓﻘﺮة ‪ SQL‬ﻣﺎﻋﺪا ﻓﻰ اﻟﻔﻘﺮة ‪FROM‬‬
‫ﻣﻼﺣﻈﺔ‪:‬‬
‫ﻳﻤﻜﻦ أَن ﺗﺴﺘﻌﻤﻞ ﻣﻊ اﻟﺘﺎرﻳﺦ اﻟﻌﻮاﻣﻞ اﻟﺠﻤﻊ واﻟﻄﺮحِ ﻓﻘﻂ‪.‬‬

‫اﺳﺘﺨﺪام اﻟﻌﻤﺎﻟﻴﺎت اﻟﺤﺴﺎﺑﻴﺔ‬

‫اﻟﻤﺜﺎل ‪ :‬ﻳﻮﺿﺢ اﺳﺘﻌﻤﺎل ﻋﻤﻠﻴﺔ اﻟﺠﻤﻊ ﺣﻴﺚ ﻳﺤﺴﺐ زﻳﺎدة ﻟﻠﺮاﺗﺐ ‪ $300‬ﻣﻊ آﻞ‬
‫اﻟﻤﻮﻇﻔﻮن‬
‫و ﻳﻌﺮﺿﻮن اﻟﻤﺮﺗﺐ اﻟﺠﺪﻳﺪ ‪ 300+‬ﻓﻲ اﻟﻌﻤﻮد ‪.‬‬
‫ﻣﻼﺣﻈﺔ اﻟﻨﺎﺗﺞ ﻣﻦ ﺣﺴﺎب)راﺗﺐ اﻟﻌﻤﻮد ‪ ( 300+‬ﻟﻴﺴﺖ ﻋﻤﻮد ﺟﺪﻳﺪ ﻓﻲ ﺟﺪول‬
‫اﻟﻤﻮﻇﻔﻴﻦ إﻧﻤﺎ هﻮ ﻋﻤﻮد ﻟﻠﻌﺮض ﻓﻘﻂ‪.‬‬
 ‫‪ (300‬وهﻨﺎ ﻳﻤﻜﻦ‬ ‫أﺳﻢ اﻟﻌﻤﻮد اﻟﺠﺪﻳﺪ ﻳﺠﻲء ﻣﻦ ﻧﺎﺗﺞ ﺣﺴﺎب ‪ +‬اﻟﻤﺮﺗﺐ) راﺗﺐ ‪+‬‬
‫اﺳﺘﻌﻤﺎل‬
‫)‪ (ALIAS‬ﺣﺘﻰ ﻧﺘﻤﻜﻦ ﻣﻦ ﺗﺴﻤﻴﺔ ﺗﻠﻚ اﻟﻌﻤﻮد‪.‬‬
‫اﻟﻤﻼﺣﻈﺔ‪ ORACLE 10G :‬ﻳﻬﻤﻞ اﻟﻤﺴﺎﻓﺎت اﻟﻔﺎرﻏﺔ ﻗﺒﻞ وﺑﻌﺪ اﻟﻌﻮاﻣﻞ اﻟﺤﺴﺎﺑﻴﺔ ‪.‬‬

‫اﺳﺒﻘﻴﺔ ﻋﻤﻞ اﻟﻌﻮاﻣﻞ اﻟﺤﺴﺎﺑﻴﺔ‪:‬‬

‫*‬ ‫‪/‬‬ ‫‪+‬‬ ‫‪-‬‬

‫‪ .1‬اﻷوﻟﻮﻳﺔ ﺗﻜﻮن ﻟﻠﻀﺮب اﻷول ﺛﻢ اﻟﻘﺴﻤﺔ ﺛﻢ اﻟﺠﻤﻊ ﺛﻢ اﻟﻄﺮح‪.‬‬

‫‪ .2‬اﻷوﻟﻮﻳﺔ ﻣﻦ اﻟﻴﺴﺎر ﺁﻟﻲ اﻟﻴﻤﻴﻦ‪.‬‬
‫‪ .3‬ﺗﺴﺘﺨﺪم اﻷﻗﻮاس ﺣﺘﻰ ﺗﺘﻤﻜﻦ ﻣﻦ ﺗﻨﻔﻴﺬ اﻟﺠﻤﻊ او اﻟﻄﺮح اوﻻ ﻗﺒﻞ‬
‫اﻟﻀﺮب او اﻟﻘﺴﻤﺔ‪.‬‬

‫أﺳﺒﻘﻴﺔ اﻟﻌﻮاﻣﻞ‬

‫إذا آﺎن هﻨﺎك اآﺜﺮ ﻣﻦ ﻋﻤﻠﻴـﺔ ﻣﺨﺘﻠﻔـﺔ ‪ ،‬ﺿـﺮب وﻗـﺴﻤﺔ وﺟﻤـﻊ و ﻃـﺮح‪ .‬أﻧـﺖ ﻳﻤﻜـﻦ أَن‬
‫ﺗــﺴﺘﻌﻤﻞ اﻷﻗــﻮاس ﻟــﻀﻤﺎن ﺗﻨﻔﻴــﺬ اﻟﻌﻤﻠﻴــﺎت اﻟﺘــﻰ ﺑ ـﺪاﺧﻞ اﻷﻗــﻮاس أوﻻً ‪ .‬ﺛــﻢ اﻟﺒــﺎﻗﻲ‬
‫ﺑﺎﻟﺘﺮﺗﻴﺐ ﻣﻦ اﻟﻴﺴﺎر إﻟﻰ اﻟﻴﻤﻴﻦ‪.‬‬
‫ﺗﺴﺘﻄﻴﻊ أن ﺗﺴﺘﺨﺪم اﻷﻗﻮاس آﻲ ﺗﻨﻔﺬ اﻟﺬى ﺑﺪاﺧﻠﺔ اوﻻ‪ .‬أي اﻧﻚ ﻋﻨـﺪﻣﺎ ﺗـﻀﻌﻬﻢ ﻓـﻰ‬
‫اﻷﻗﻮاس ﻳﻨﻔﺬ اﻻﻗﻮاس اوﻻ ﺳﻮاء آﺎن ﺟﻤﻊ أو ﻃﺮح ﺣﻴﺚ ان ﺑﻴﻦ اﻷﻗﻮاس ﻳﻨﻔﺬ اوﻻ‪.‬‬

‫ﻣﺜﺎل ﻋﻠﻰ أﺳﺒﻘﻴﺔ اﻟﻌﻮاﻣﻞ‬

‫أﺳﺒﻘﻴﺔ اﻟﻌﺎﻣﻞ‪:‬‬
‫اﻟﻤﺜﺎل اﻟﺴﺎﺑﻖ ﻳﻌﺮض )اﻻﺳﻢ اﻷﺧﻴﺮِ‪ ،‬اﻟﻤﺮﺗﺐ‪ ،‬اﻟﻤﺮﺗﺐ*‪.(100+12‬‬

‫ﻣﻠﺤﻮﻇﺔ ﻋﻤﻠﻴﺔ اﻟﻀﺮب ﻳﺘﻢ ﺗﻨﻔﻴﺬهﺎ ﻗﺒﻞ إﺿﺎﻓﺔ رﻗﻢ ‪.100‬‬

‫ﻣﻼﺣﻈﺔ‪ :‬ﺗﺴﺘﺨﺪام اﻷﻗﻮاس آـﻲ ﺗﻮﺿـﺢ اوﻟﻮﻳـﺔ اﻟﻌﻤﻠﻴـﺔ اﻟﺤـﺴﺎﺑﻴﺔ وﺗـﺴﻬﻞ ﺗـﺼﺤﻴﺢ‬
‫اﻻﺧﻄﺎء‪.‬‬
‫ﻻﺣﻆ ﻳﻤﻜﻦ أَن ﻳﻜﺘﺐ ) ‪ 100+ ( salary *12‬ﻻ ﻳﺤﺪث ﺗﻐﻴﻴﺮ ﻓﻲ اﻟﻨﺘﻴﺠﺔ اﻟﺴﺎﺑﻘﺔ‬
‫ﻟﻜﻦ اﻟﺘﻌﺒﻴﺮ اﺻﺒﺢ اآﺜﺮ وﺿﻮﺣﺎً ‪.‬‬

‫‪SELECT‬‬ ‫‪EMPLOYEE_ID , SALARY *15/100‬‬

‫‪FROM‬‬ ‫;‪employees‬‬
 ‫ﻧﻼﺣﻆ ﻓﻰ هﺬا اﻟﻤﺜﺎل ان ﺗﻢ ﺿﺮب اﻟﻤﺮﺗﺐ ‪ salary‬ﻓﻰ ‪ 15‬ﺛﻢ اﻟﻘﺴﻤﺔ ‪100/‬‬

‫اﺳﺘﺨﺪام اﻷﻗﻮاس‬

‫اﺳﺘﺨﺪام اﻷﻗﻮاس‪:‬‬
‫ﻳﻤﻜﻦ أَن ﺗﺘﺠﺎوز ﻗﻮاﻋﺪ اﻷﺳﺒﻘﻴﺔ ﻓﻰ ﺗﻨﻔﻴﺬ اﻟﻌﻤﻠﻴﺎت اﻟﺤﺴﺎﺑﻴﺔ ﺑﺎﺳﺘﺨﺪام اﻷﻗﻮاس‬
‫ﻟﺘﺤﺪد ﺗﺮﺗﻴﺐ ﺣﺴﺎب اﻟﻌﻤﻠﻴﺎت اﻟﺤﺴﺎﺑﻴﺔ اﻟﺘﻲ ﺗﻨﻔﺬ اوﻻ ﺣﺴﺐ اﺣﺘﻴﺎﺟﺎﺗﻚ‪.‬‬
‫اﻟﻤﺜﺎل اﻟﺴﺎﺑﻖ ﻳﻘﻮم ﺑﻌﺮض اﻻﺳﻢ اﻷﺧﻴﺮِ‪ ،‬اﻟﻤﺮﺗﺐ‪) ،‬اﻟﻤﺮﺗﺐ‪.12*(100+‬‬
‫هﻮ ﺑﺬﻟﻚ ﻳﻘﻮم ﺑﺠﻤﻊ ‪ 100‬ﻋﻠﻰ اﻟﻤﺮﺗﺐ اوﻻ آﻞ ﻣﻮﻇﻒ ﺛﻢ ﺑﻌﺪ ذﻟﻚ ﻳﻘﻮم ﺑﻀﺮب اﻟﻨﺎﺗﺞ‬
‫ﻓﻰ ‪.12‬‬
‫ﺑﺴﺒﺐ اﻷﻗﻮاس‪،‬ﻳﻤﻜﻦ ﻟﻌﻤﻠﻴﺔ اﻟﺠﻤﻊ ان ﺗﻨﻔﺬ ﻗﺒﻞ اﻟﻀﺮب ‪.‬‬
‫ﻓﺒﺴﺒﺐ اﻷﻗﻮاس ﻳﺘﻢ ﺣﺴﺎب ) ‪ (salary+100‬أوﻻ ﺛﻢ ﻳﻀﺮب اﻟﻨﺎﺗﺞ × ‪.12‬‬

‫ﻣﺜﺎل اﺧﺮ ‪-:‬‬

‫‪SELECT‬‬ ‫) ‪EMPLOYEE_ID, 15*(SALARY +100‬‬
‫‪from‬‬ ‫;‪employees‬‬
 ‫ﻧﻼﺣﻆ ان ﻋﻤﻠﻴﺔ اﻟﺠﻤﻊ ﺗﻤﺖ اوﻻ ﺛﻢ ﻋﻤﻠﻴﺔ اﻟﻀﺮب‬

‫اﻟﺘﻌﺎﻣﻞ ﻣﻊ اﻟﻘﻴﻤﺔ ‪Null‬‬

‫‪ Null‬هﻲ ﻗﻴﻤﺔ ﻏﻴﺮ ﻣﺘﺎﺣﺔ ﻏﻴﺮ ﻣﺤﺪدة ﻏﻴﺮ ﻣﻌﺮوﻓﺔ وﻏﻴﺮ ﻗﺎﺑﻠﺔ ﻻﺟﺮاء اى‬ ‫•‬
‫ﻋﻤﻠﻴﺔ‬
‫ﺣﺴﺎﺑﻴﺔ ﻋﻠﻴﻬﺎ‪.‬‬
‫‪ Null‬ﻟﻴﺴﺖ ﻣﺴﺎوﻳﺔ ﺻﻔﺮ أو ﻣﺴﺎﻓﺔ‪.‬‬ ‫•‬

‫ﻗﻴﻢ ‪Null‬‬
‫اى ﺧﻠﻴﺔ ﻓﻰ اﻟﺠﺪول ﻓﺎرﻏﺔ ﺗﻜﻮن ‪.NULL‬‬
‫‪ Null‬ﻗﻴﻤﺔ ﻏﻴﺮ ﻣﺘﺎﺣﺔ ﻏﻴﺮ ﻣﺤﺪدة ﻏﻴﺮ ﻣﻌﺮوﻓﺔ وﻏﻴﺮ ﻗﺎﺑﻠﺔ ﻻﺟﺮاء ﻋﻤﻠﻴﺎت ﺣﺴﺎﺑﻴﺔ ﻋﻠﻴﻬﺎ‪.‬‬
‫‪ Null‬ﻻ ﺗﺴﺎوى ﺻﻔﺮ أو ﻣﺴﺎﻓﺔ ﻓﺎرﻏﺔ ‪.‬ﺣﻴﺚ ان اﻟﺼﻔﺮ ﻋﺪد‪ ،‬واﻟﻔﺮاغ ﻳﻌﺘﺒﺮ ﺣﺮف ‪.‬‬
‫‪.null‬‬ ‫أي ﻧﻮع ﻣﻦ اﻟﺒﻴﺎﻧﺎت ﻳﻤﻜﻦ أَن ﺗﺤﺘﻮي ﻋﻠﻰ‬
‫ﻋﻠــﻰ أﻳــﺔ ﺣــﺎل‪ ،‬ﻳﻤﻜــﻦ وﺿــﻊ ﺑﻌــﺾ اﻟﻘﻴــﻮد ﻋﻠــﻰ اﻟﺠــﺪول ﻣﺜــﻞ ‪ NOT NULL‬و‬
‫‪PRIMARY KEY‬‬
‫وهﺬا ﻳﻌﻨﻰ ﻋﺪم اﻣﻜﺎﻧﻴﺔ أﺣﺘﻮاء اﻟﻌﻤﻮد ‪. NULL‬‬
‫ذﻟﻚ آﻤﺎ ﺳﻮف ﻧﺮى ﻓﻴﻤﺎ ﺑﻌﺪ ‪.‬‬

‫ﻻﺣﻆ ﻓﻰ اﻟﻤﺜﺎل اﻟﺴﺎﺑﻖ ان اﻟﺬي ﻟﺪﻳﻪ ﻋﻤﻮﻟﻪ هـﻮ ﻣـﺪﻳﺮ ﻣﺒﻴﻌـﺎت أو ﻣﻨـﺪوب اﻟﻤﺒﻴﻌـﺎت‬
‫وﺑﺎﻗﻰ اﻟﻤﻮﻇﻔﻮن ﻟﻴﺲ ﻟﺪﻳﻬﻢ ﻧﺴﺒﺔ ﻋﻤﻮﻻت ﻟﺬﻟﻚ ﻗﻴﻢ اﻟﻌﻤﻮﻟﺔ ﻋﻨﺪهﻢ ‪. null‬‬

‫ﻗﻴﻤﺔ ‪ Null‬ﻓﻲ اﻟﻌﻤﻠﻴﺎت اﻟﺤﺴﺎﺑﻴﺔ‬

‫ﻻ ﻳﻤﻜﻦ اﺟﺮاء ﻋﻤﻠﻴﺎت ﺣﺴﺎﺑﻴﺔ ﻋﻠﻰ ‪.NULL‬‬ ‫•‬
 ‫ﻣﻠﺤﻮﻇﺔ‪:‬‬
‫ﻋﻨﺪﻣﺎ ﺗﺤﺎول أَن ﺗﻘﺴﻢ أي رﻗﻢ ﻋﻠﻰ ﺻﻔﺮ‪ ،‬ﺗﺼﺒﺢ اﻟﻨﺘﻴﺠﺔ ﺧﻄﺄ‪ .‬واﻳﻀﺎ ﻋﻨﺪﻣﺎ ﺗﺤﺎول‬
‫اﺟﺮاء اى‬
‫ﻋﻤﻠﻴﺔ ﺣﺴﺎﺑﻴﺔ ﻋﻠﻰ ‪ ،Null‬ﻓﺘﻜﻮن اﻟﻨﺘﻴﺠﺔ ‪.NULL‬‬
‫ﻣﻦ اﻟﻤﺜﺎل اﻟﺴﺎﺑﻖ ﻻﺣﻆ ان )‪ (KING‬ﻻ ﻳﺤﺼﻞ ﻋﻠﻰ أي ﻋﻤﻮﻟﺔ وﻟﻜﻨﺔ ﻳﺤﺼﻞ ﻋﻠﻰ‬
‫ﻣﺮﺗﺐ‪.‬وﻣﻊ ذﻟﻚ اﻟﻨﺘﻴﺠﺔ اﺻﺒﺤﺖ ‪ Null‬ﻓﻰ اﻟﺨﻠﻴﺔ اﻟﺨﺎﺻﺔ ﺑﺔ و هﺬا ﻳﺆآﺪ ان اﺟﺮاء اى‬
‫ﻋﻤﻠﻴﺔ ﺣﺴﺎﺑﻴﺔ ﻋﻠﻰ ‪ NULL‬ﺗﺆدى اﻟﻰ ‪.NULL‬‬

‫‪ -‬ﻟﻠﻤﺰﻳﺪ ﻣﻦ اﻟﻤﻌﻠﻮﻣﺎت‪ ،‬ﻳﺮى ﻣﺮﺟﻊ ‪BASIC ELEMENTS OF “ ،ORACLE 10g SQL‬‬

‫‪”SQL‬‬

‫ﻋﻼﻣﺔ اﻟﻠﺼﻖ )اﻟﻀﻢ( ) || (‬

‫‪Concatenation‬‬

‫وهﻲ ﺗﺴﺘﺨﺪم ﻟﻜﻲ ﻧﻀﻢ ﻋﻤﻮدﻳﻦ ﻓﻰ ﻋﻤﻮد واﺣﺪ ﻓﻴﺘﻢ اﺳﺘﺨﺪام ﻋﻼﻣﺔ || آﻲ‬
‫ﺗﻠﺼﻖ اﻷﻋﻤﺪة‪.‬‬
‫‪Example‬‬

‫ﺗﻢ دﻣﺞ ﻋﻤﻮد اﺳﻢ اﻟﻤﻮﻇﻒ ﻣﻊ وﻇﻴﻔﺘﺔ ﻓﻰ ﻋﻤﻮد واﺣﺪ وﺳﻤﻰ ‪.Employees‬‬
 ‫‪name of‬‬ ‫ﻧﻼﺣﻆ ﻣﻦ اﻟﻤﺜﺎل اﻟﺴﺎﺑﻖ ان اﻻﺳﻢ اﻻول واﻟﺜﺎﻧﻰ اﺻﺒﺤﺎ ﻣﻌﺎ ﺗﺤﺖ اﺳﻢ‬
‫‪employee‬‬

‫ﺳﻠﺴﻠﺔ اﻟﺤﺮوف اﻟﺤﺮﻓﻴﺔ‬

‫‪ LITERAL‬ﺗﻌﺒﺮ ﻋﻦ ﺣﺮف او ﻋﺪد أو ﺗﺎرﻳﺦ و ﺗﺘﻀﻤﻦ ﻓﻲ ﺟﻤﻠﺔ ‪.SELECT‬‬ ‫‪.1‬‬
‫‘(‪.‬‬ ‫اى ﻗﻴﻢِ ﺣﺮﻓﻴﺔ ﻳﺠِﺐ أَن ﺗﻜﻮن ﻣﺮﻓﻘﺔ ﺿﻤﻦ اﻟﻌﻼﻣﺔ ) ‘‬ ‫‪.2‬‬
‫‪ LITERAL‬ﺗﻜﻮن ﺣﺮف او ﻋﺪد أو ﺗﺎرﻳﺦ‪.‬‬ ‫‪.3‬‬
‫‘( ‪.‬‬ ‫اﻟﺤﺮوف و اﻟﺘﻮارﻳﺦ ﻳﻮﺿﻌﺎن ﺑﻴﻦ اﻟﻌﻼﻣﺔ ) ‘‬ ‫‪.4‬‬

‫اﺳﺘﺨﺪام ﻣﺠﻤﻮﻋﺔ اﻟﺤﺮوف‬

‫اﻟﺤﺮﻓﻴﺔ‬

‫ﻣﺜﺎل اﺧﺮ‬
‫‪Employee Details‬‬ ‫اﻟﻤﺜﺎل ﻳﻌﺮض اﻷﺳﻤﺎء و اﻟﻮﻇﻴﻔﺔ ﻟﻜﻞ اﻟﻤﻮﻇﻔﻮن‪ .‬وﻋﻨﻮان اﻟﻌﻤﻮد‬
‫‪.‬‬
‫اﻟﻔﺮاغ ﻳﺤﺴﻦ ﻗﺮاءة اﻟﻨﺎﺗﺞ ‪.‬‬
‫ﻋﻨﺪﻣﺎ ﻧﺮﻳﺪ ان ﻧﻀﻴﻒ آﻠﻤﺔ او اآﺜﺮ ﻣﻦ آﻠﻤﺔ ﻗﺒﻞ او ﺑﻌﺪ ﻇﻬﻮر اﻟﻌﻤﻮد ﻻﺑﺪ ﻣﻦ‪:‬‬
‫اوﻻ‪ :‬ﻳﺠﺐ وﺿﻊ اﻟﻜﻠﻤﺎت اﻟﺘﻰ ﺗﺮﻳﺪ ادراﺟﻬﺎ ﺑﻴﻦ ‪.single quotation‬‬
‫ﺛﺎﻧﻴﺎ‪ :‬ﻋﻤﻞ ‪ concatenation‬ﻣﻊ هﺬة اﻟﻜﻠﻤﺎت‪.‬‬

‫ﻓﻔﻰ اﻟﻤﺜﺎل اﻟﺘﺎﻟﻲ‪ ،‬ﺗﻢ ﺿﻢ اﻻﺳﻢ اﻷﺧﻴﺮ ﻣﻊ ﺟﻤﻠﺔ )= ‪(: 1 month salary‬ﻣﻊ‬
‫اﻟﺮاﺗﺐ ﻟﻜﻞ ﻣﻮﻇﻒ وﻻﺣﻆ اﻧﻚ ﻻﺑﺪ ﻣﻦ وﺿﻊ ﺗﻠﻚ اﻟﺠﻤﻠﺔ ﺑﻴﻦ ‪.single quotation‬‬

‫* اذا آﻨﺖ ﺗﺮﻳﺪ وﺿﻊ ﻋﻼﻣﺔ ‪ Single Quotation‬داﺧﻞ اﻟﺠﻤﻠﺔ اﻟﺘﻰ ﺗﺮﻳﺪ ﻇﻬﻮرهﺎ ﻗﺒﻞ‬
‫[‬ ‫او ﺑﻌﺪ او ﺑﻴﻦ اﻟﻌﻤﻮد ﻳﺠﺐ ﻋﻠﻴﻚ وﺿﻊ ﻋﻼﻣﺔ ‪ q‬وﺿﻊ اﻟﺠﻤﻠﺔ اﻟﻤﺮاد أﺿﺎﻓﺘﻬﺎ ﺑﻴﻦ ]‬
‫‪SELECT last_name ||’: 1 Month salary = ’||salary Monthly‬‬
‫;‪FROM employees‬‬

‫)أي أﻧﻚ ﻋﻨﺪ اﻟﺮﻏﺒﺔ ﻓﻲ وﺿﻊ ﺣﺮوف ﺑﻴﻦ ﻋﻤﻮدﻳﻦ ﻳﺮاد ﻟﺼﻘﻬﻤﺎ ﻓﺄﻧﻨﺎ ﻧﻜﺘﺐ هﺬﻩ اﻟﺤﺮوف‬
‫ﺑﻴﻦ ﻋﻼﻣﺘﻴﻦ ﺗﻨﺼﻴﺺ ﻣﻔﺮدﺗﻴﻦ )|| ‘ ‪ ( || ‘ ..‬وﻟﻮ أرﻗﺎم ﻓﻼ ﺗﻮﺿﻊ ﺑﻴﻦ ﺷﺊ‪.‬‬

‫آﻴﻔﻴﺔ ازاﻟﺔ اﻟﺼﻔﻮف اﻟﻤﺘﻜﺮرة‬

‫إنّ اﻻﺳﺘﻌﻼم ﻳﻜﻮن ﻟﻜﻞ اﻟﺼﻔﻮف ﺑﺎﻟﺠﺪول و ﻳﺸﻤﻞ اﻟﺼﻔﻮف اﻟﻤﺘﻜﺮرة ‪.‬‬

‫ﻣﻠﺤﻮﻇﺔ أﻋﺪاد اﻟﻘﺴﻢ ﺗﺘﻜﺮر ‪.‬‬

‫إزاﻟﺔ اﻟﺼﻔﻮف اﻟﻤﺘﻜﺮرة‬
‫إزاﻟﺔ اﻟﺼﻔﻮف اﻟﻤﺘﻜﺮرة ﺑﺎﺳﺘﺨﺪام ‪DISTINCT‬‬
‫‪ DISTINCT‬ﻗﺒﻞ اﺳﻢ اﻟﻌﻤﻮد اﻟﻤﺮاد‬ ‫ﻟﻜﻲ ﺗﺰﻳﻞ اﻟﺼﻔﻮف اﻟﻤﺘﻜﺮرة ﻳﺠﺐ وﺿﻊ آﻠﻤﺔ‬
‫ازاﻟﺔ اﻟﺘﻜﺮار ﻣﻨﺔ ﻓﻔﻰ اﻟﻤﺜﺎل اﻟﺴﺎﺑﻖ‪،‬ﺟﺪول اﻟﻤﻮﻇﻔﻮن اﻟﻔﻌﻠﻲ ﻳﺘﻜﻮن ﻣﻦ ‪ 20‬ﺻﻒ ﻟﻜﻨﺔ‬
‫ﻇﻬﺮ ﺑﺪون ﺗﻜﺮارات ﺑﻌﺪ اﺳﺘﺨﺪام آﻠﻤﺔ ‪. DISTINCT‬‬

‫‪Example:‬‬
‫‪SELECT DISTINCT department_id‬‬
‫;‪FROM employees‬‬

‫‪SQL‬‬ ‫اﻟﻔﺮق ﺑﻴﻦ ‪ ISQL*PLUS‬و‬

‫‪ SQL*PLUS‬هﻲ أواﻣﺮ ﺛﺎﺑﺘﺔ ﻣﺘﻌﺎرف ﻋﻠﻴﻬﺎ و ﺗﺴﺘﺨﺪم ﻓﻲ اﻟﺘﻌﺎﻣﻞ ﻣﻊ ﻗﻮاﻋﺪ اﻟﺒﻴﺎﻧﺎت ‪.‬‬

‫‪ ISQL*PlUS‬هﻲ أواﻣﺮ ﺧﺎﺻﺔ ﻟﻠﻌﻤﻞ ﻓﻲ ﻣﻜﺎن ‪isql*plus‬‬

 ‫و ‪iSQL* PLUS‬‬ ‫‪SQL*PLUS‬‬ ‫اﻟﻔﺮق ﺑﻴﻦ‬

‫‪SQL‬‬ ‫‪iSQL* PLUS‬‬

‫أواﻣﺮ ‪ sql‬هﻲ أواﻣﺮ ﺛﺎﺑﺘﺔ ﻣﺘﻌﺎرف ﻋﻠﻴﻬﺎ‬ ‫هﻲ أواﻣﺮ ﺧﺎﺻﺔ ﺑﺎﻟﻌﻤﻞ ﻓﻲ ‪isql*plus‬‬
‫وﺗﺴﺘﺨﺪم ﻓﻲ اﻟﺘﻌﺎﻣﻞ ﻣﻊ ﻗﻮاﻋﺪ اﻟﺒﻴﺎﻧﺎت‬
‫ﺑﻜﺎﻓﺔ اﺷﻜﺎﻟﻬﺎ‪.‬‬
‫ﻻ ﻳﻤﻜﻦ اﺧﺘﺼﺎر أواﻣﺮهﺎ‪.‬‬ ‫ﻳﻤﻜﻦ اﺧﺘﺼﺎر أواﻣﺮ ‪isql*plus‬‬

‫ﺗﺬهﺐ أواﻣﺮ ‪ sql‬إﻟﻰ ﺟﺰء ﻓﻲ اﻟﺬاآﺮة‬ ‫‪ isql*plus‬إﻟﻰ‬ ‫ﻻ ﻳﺬهﺐ ﺁﺧﺮ أﻣﺮ ﻓﻲ‬
‫ﻳﺴﻤﻲ ‪ buffer‬وذﻟﻚ ﻟﺤﻔﻆ ﺁﺧﺮ أﻣﺮ‬ ‫‪buffer‬‬
‫ﻟﺴﻬﻮﻟﺔ ﺗﻌﺪﻳﻠﻪ‬
‫وهﻮ ﺟﺰء ﻓﻲ اﻟﺬاآﺮة ﻳﺤﻔﻆ ﺁﺧﺮ أﻣﺮ ‪sql‬‬
‫ﻟﺴﻬﻮﻟﺔ اﻻﺳﺘﺮﺟﺎع واﻟﺘﻌﺪﻳﻞ‬
‫ﺗﺎﺗﻰ ﺑﺎﻟﺒﻴﺎﻧﺎت ﻣﻦ ﻋﻠﻰ ‪SERVER‬‬ ‫ﺗﺎﺗﻰ ﺑﺎﻟﺒﻴﺎﻧﺎت ﻣﻦ ﻋﻠﻰ ‪SERVER‬‬
‫ﻣﺒﺎﺷﺮة‬ ‫ﺑﻄﺮﻳﻘﺔ ﻏﻴﺮ ﻣﺒﺎﺷﺮة ‪.‬ﺑﻤﻌﻨﻰ ﻋﺪم وﺟﻮد‬
‫ﺑﻤﻌﻨﻰ اﻧﺔ ﻻﺑﺪ ﻣﻦ وﺟﻮد ﻗﻮاﻋﺪ ﺑﻴﺎﻧﺎت‬ ‫ﻗﺎﻋﺪ ﺑﻴﺎﻧﺎت ﻋﻠﻰ ﻧﻔﺲ اﻟﺠﻬﺎز‪.‬‬
‫ﻋﻠﻰ ﻧﻔﺲ اﻟﺠﻬﺎز ‪.‬‬

‫ﻻ ﻳﻤﻜﻨﻚ ﻣﻦ ﻣﻦ اﺳﺘﺨﺪام ﺗﻠﻚ‬ ‫ﻳﻤﻜﻨﻚ اﺳﺘﺨﺪام ﻋﻼﻣﺔ )‪ (--‬ﻟﻜﻰ ﻳﻤﻜﻨﻚ‬

‫اﻟﻌﻼﻣﺔ‪.‬‬ ‫ﻣﻦ اﻳﻘﺎف اﻟﻜﻮد اﻟﺬى ﻋﻠﻰ ﻧﻔﺲ‬
‫اﻟﺴﻄﺮ‪.‬‬

‫ﻳﻤﻜﻨﻚ ﻣﻦ ﺗﻌﺪﻳﻞ اﻟﻜﻮد اذا ﺣﺪث ﺑﺔ ﺧﻄﺄ‬ ‫ﻳﻤﻜﻨﻚ ﻣﻦ ﺗﻌﺪﻳﻞ اﻟﻜﻮد اذا ﺣﺪث ﺑﺔ ﺧﻄﺄ‬
‫ﻋﻦ ﻃﺮﻳﻖ آﺘﺎﺑﺔ ‪ ED‬ﺛﻢ اﺿﻐﻂ ‪ENTER‬‬ ‫ﺑﺴﻬﻮﻟﺔ‪.‬‬
‫ﻓﺘﻈﻬﺮ ﻟﺔ ‪ NOT PAD‬ﻳﺘﻢ ﻋﻤﻞ ﺗﻌﺪﻳﻞ‬
‫اﻟﻜﻮد ﺑﺪاﺧﻠﻬﺎ‪.‬‬

‫ﺗﺴﺠﻴﻞ اﻟﺪﺧﻮل إِﻟﻲ ‪Isql*Plus‬‬

‫ﻣﻦ ﺑﻴﺌﺔ ﻣﺴﺘﻌﺮض ﻧﻮاﻓﺬك‬

‫ﺗَﺴﺠﻴﻞ اﻟﺪﺧﻮل إِﻟﻲ ‪iSQL*Plus:‬‬

‫‪ -1‬أﻧﻘﺮ ﻋﻠﻲ ﻋﻨﻮان ) ‪ (URL‬ﻓﻲ ﺑﻴﺌﺔ ‪iSQL*Plus‬‬
‫‪ -2‬أدﺧﻞ أﺳﻢ اﻟﻤﺴﺘﺨﺪم و اﻟﺮﻗﻢ اﻟﺴﺮي ‪.‬‬
 ‫‪1-28‬‬ ‫ﺑﻴﺌﺔ ‪iSQL*Plus‬‬

‫ﻣﻠﺨﺺ اﻟﻔﺼﻞ‬

‫ﺗﻨﺎوﻟﻨﺎ ﻓﻲ هﺬا اﻟﻔﺼﻞ آﺘﺎﺑﺔ ﺟﻤﻞ ‪ SQL‬اﻟﺒﺴﻴﻄﻮ )ﺟﻤﻠﺔ ‪ (SELECT‬اﻟﺘﻲ ﺗﺴﺘﺨﺪم ﻓﻲ‬
‫اﺳﺘﺮﺟﺎع اﻟﺒﻴﺎﻧﺎت وآﺬﻟﻚ ﺑﻌﺾ اﻟﻘﻮاﻋﺪ اﻹرﺷﺎدﻳﺔ اﻟﺘﻲ ﻳﺠﺐ اﺗﺒﺎﻋﻬﺎ ﻋﻨﺪ آﺘﺎﺑﺔ وﺗﻨﻔﻴﺬ ﺟﻤﻞ‬
‫اﻟـ ‪ SQL‬آﻤﺎ ﺗﻨﺎوﻟﻨﺎ اﺳﺘﺨﺪام اﻟﻌﻤﻠﻴﺎت اﻟﺤﺴﺎﺑﻴﺔ ﻣﻊ ﺟﻤﻠﺔ ‪ SELECT‬واﻟﻌﻤﻠﻴﺔ اﻹﻟﺤﺎﻗﻴﺔ‬
‫وآﺬﻟﻚ ﻋﺒﺎرة ‪ DISTINCT‬اﻟﺘﻲ ﺗﺴﺘﺨﺪم ﻟﻤﻨﻊ ﺗﻜﺮار ﻇﻬﻮر اﻟﺴﺠﻼت‬
 ‫اﺧﺘﻴﺎر ﺻﻔﻮف ﻣﺤﺪدة‪-:‬‬

‫اﻻهﺪاف‪:‬‬
‫„ اﻣﻜﺎﻧﻴﺔ اﺳﺘﺨﻼص ﻣﺠﻤﻮﻋﺔ ﻓﻘﻂ ﻣﻦ اﻟﺒﻴﺎﻧﺎت‪.‬‬
‫„ اﻣﻜﺎﻧﻴﺔ ﺗﺮﺗﻴﺐ اﻟﺒﻴﺎﻧﺎت اﻟﻨﺎﺗﺠﺔ ﻋﻦ ﺟﻤﻠﺔ ‪. SELECT‬‬

‫ﻣﻘﺪﻣﺔ‬
‫ﻟﻘﺪ ﻗﻤﻨﺎ ﻓﻲ اﻟﻮﺣﺪة اﻟﺴﺎﺑﻘﺔ ﺑﺎﻟﺘﻌﺮف اﻟﻰ ﺟﻤﻠﺔ اﻻﺳﺘﻌﻼم اﻟﺒﺴﻴﻂ )‪(SELECT Statement‬‬
‫اﻟﺘﻲ ﻣﻦ ﺧﻼﻟﻬﺎ ﺗﻢ اﺳﺘﺮﺟﺎع اﻟﺒﻴﺎﻧﺎت ﻣﻦ اﻟﺠﺪاول ‪ .‬وﻓﻲ هﺬا اﻟﻔﺼﻞ ﺳﻨﺘﺎﺑﻊ اﻟﺤﺪﻳﺚ ﻋﻦ هﺬﻩ‬
‫اﻟﺠﻤﻠﺔ ﻳﺸﻜﻞ أوﺳﻊ ‪ ،‬ﺣﻴﺚ ﺳﻨﺴﺘﺮﺟﻊ اﻟﺒﻴﺎﻧﺎت ﻣﻦ اﻟﺠﺪاول ﺑﻨﺎء ﻋﻠﻰ ﺷﺮوط ﻣﻌﻴﻨﺔ ‪ ،‬أو ﻣﺮﺗﺒﺔ‬
‫ﺣﺴﺐ ﺑﻴﺎﻧﺎت ﺣﻘﻮل ﻣﻌﻴﻨﺔ ‪ ،‬أي ﺳﻨﺪرس اﻟﻤﻮر اﻟﻤﺘﻌﻠﻘﺔ ﺑﺠﻤﻠﺔ اﻟﺸﺮط ﻓﻲ ﺟﻤﻠﺔ اﻻﺳﺘﺮﺟﺎع ‪ ،‬ﻣﻦ‬
‫ﺣﻴﺚ اﻟﻤﻌﺎﻣﻼت اﻟﺸﺮﻃﻴﺔ وﻃﺮﻳﻘﺔ اﻟﺘﻌﺒﻴﺮ ﻋﻦ اﻟﺸﺮط واﻟﺘﺮﺗﻴﺐ اﻟﺘﺼﺎﻋﺪي واﻟﺘﺮﺗﻴﺐ اﻟﺘﺼﺎﻋﺪي‬
‫واﻟﺘﺮﺗﻴﺐ اﻟﺘﻨﺎزﻟﻲ ﻟﻠﺒﻴﺎﻧﺎت‬

‫هﻨﺎ ﻳﺘﻢ اَﺳﺘﺮﺟﺎع آﻞ اﻟﻤﻮﻇﻔﻮن ﻓﻲ اﻻدارة رﻗﻢ ‪90‬‬

‫ﻓﻰ اﻟﻤﺜﺎلِ اﻟﺴﺎﺑﻖ ‪ ،‬ﻳﺮﻳﺪ ﻋﺮض آﻞ اﻟﻤﻮﻇﻔﻴﻦ ﻓﻲ اﻻدارة رﻗﻢ ‪ 90‬وﺳﻮف ﺗﺠﺪ أﻧﻪ‬
‫اﻟﻮﺣﻴﺪ اﻟﺬي ﺗﻢ ﻋﺮﺿﻪ ‪ .‬هﺬا ﻳﺘﻢ ﻋﻦ ﻃﺮﻳﻖ اﺿﺎﻓﺔ اﻟﻌﺒﺎرة ‪ WHERE‬ﻓﻲ ﺟﻤﻠﺔ‬
‫‪.Select‬‬

‫اﻣﻜﺎﻧﻴﺔ اﺳﺘﺮﺟﺎع اﻟﺼﻔﻮف ﺑﺎﺳﺘﺨﺪام ﻓﻘﺮة ‪. WHERE‬‬ ‫•‬

‫•‬
‫}‪SELECT *|{[DISTINCT] column|expression [alias],...‬‬
‫‪FROM table‬‬
‫;])‪[WHERE condition(s‬‬
‫ﻓﻘﺮة ‪ WHERE‬ﺗﺎﺗﻰ ﺑﻌﺪ ﻓﻘﺮة ‪. FROM‬‬
‫اﺧﺘﻴﺎر ﺻﻔﻮف ﻣﺤﺪدة‪:‬‬
‫ﻳﻤﻜﻦ أَن ﺗﺤﺪد اﻟﺼﻔﻮف اﻟﺘﻰ ﺳﻮف ﺗﺴﺘﺨﻠﺼﻬﺎ ﺑﺎﺳﺘﺨﺪام آﻠﻤﺔ ‪ WHERE‬اﻟﺘﻰ‬
‫ﺗﺤﺘﻮي ﻋﻠﻰ اﻟﺸﺮط ﻻﻣﻜﺎﻧﻴﺔ ﺣﺼﺮ اﻟﺒﻴﺎﻧﺎت اﻟﺘﻲ ﺳﻴﺘﻢ اﺳﺘﺨﻼﺻﻬﺎ ﻣﻦ اﻟﺠﺪول ‪.‬‬

‫ﺗﺘﻀﻤﻦ ‪ WHERE‬ﻋﻠﻲ ﺛﻼﺛﺔ ﻋﻨﺎﺻﺮِ )ﻣﻊ ﻣﺮاﻋﺎة اﻟﺘﺮﺗﻴﺐ( ‪:‬‬

‫* أﺳﻢ اﻟﻌﻤﻮدِ اﻟﺬى ﺗﺮﻳﺪ اﺟﺮاء اﻟﻤﻘﺎرﻧﺔ ﻋﻠﻴﺔ‪.‬‬
‫* ﺷﺮط اﻟﻤﻘﺎرﻧﺔِ‪.‬‬
‫* أﺳﻢ اﻟﻌﻤﻮدِ أو اﻟﻘﻴﻤﺔ أو ﻣﺠﻤﻮﻋﺔ ﻣﻦ اﻟﻘِﻴﻢِ‪.‬‬
 ‫ﻧﺠﺪ ﻓﻰ اﻟﻤﺜﺎل اﻟﺴﺎﺑﻖ ﻇﻬﻮر اﻟﺒﻴﺎﻧﺎت اﻟﺨﺎﺻﺔ ﺑﺎﻟﻘﺴﻢ رﻗﻢ ‪ 90‬ﻓﻘﻂ ﺣﻴﺚ‬
‫ﺗﻢ اﺳﺘﺨﺪام ‪ WHERE‬ﻟﺘﺤﺪﻳﺪ اﻟﺒﻴﺎﻧﺎت اﻟﺨﺎﺻﺔ ﺑﻬﺬا اﻟﻘﺴﻢ ﻓﻘﻂ ‪.‬‬

‫ﻣﺜﺎل اﺧﺮ ‪:‬‬

‫ﺗﺴﺘﺨﺪام ‪WHERE‬‬
‫‪ WHERE‬و هﺬا اﻟﺸﺮط‬ ‫ﻋﻨﺪﻣﺎ ﻧﺮﻳﺪ ﺗﺤﺪﻳﺪ ﺻﻒ أو ﻣﺠﻤﻮﻋﺔ ﺻﻔﻮف ﻣﻌﻴﻨﻪ ﻧﺴﺘﺨﺪم‬
‫ﻳﻘﻮم ﺑﺤﺼﺮ اﻻﺧﺘﻴﺎر ﻟﺘﻠﻚ اﻟﺼﻔﻮف ﻓﻘﻂ ‪.‬‬
‫وﺗﺒﺪأ ﺟﻤﻠﺔ اﻟﺸﺮط ﺑﻜﻠﻤﺔ ‪ WHERE‬ﻳﻠﻴﻬﺎ اﻟﺸﺮط اﻟﻤﺮاد ﺗﺤﻘﻘﻪ‪.‬‬
‫ﻓﻰ اﻟﻤﺜﺎلِ اﻟﺴﺎﺑﻖ ‪ ،‬ﺟﻤﻠﺔ ) ‪ (SELECT statement‬ﺗﺴﺘﺮﺟﻊ اﻻﺳﻢ و رﻗﻢ اﻟﻘﺴﻢ‬
‫ﻟﻜﻞ ﻣﻮﻇﻒ ﻳﻌﻤﻞ ﻓﻰ اﻟﻘﺴﻢ رﻗﻢ ‪. 60‬‬
‫‪-------------------------------------------------------‬‬
‫ﻣﻼﺣﻈﺔ‪:‬‬
‫ﻣﺠﻤﻮﻋﺔ اﻟﺤﺮوف واﻟﺘﻮارﻳﺦ ﻳﻮﺿﻊ ﺣﻮﻟﻬﺎ ﻋﻼﻣﺎت اﻟﺘﺮﻗﻴﻢ اﻟﻔﺮدﻳﺔ ‘ ‘‬
‫)‪ (Single Quotation‬و اﻳﻀﺎ ﺻﻴﻐﺔ اﻟﺘﺎرﻳﺦ اﻟﻤﺨﺘﺎرةِ ‪DD-MON-RR‬‬
‫ﺑﻤﻌﻨﻰ اﻟﻴﻮم ﻳﻜﺘﺐ ﻓﻲ ﺣﺮﻓﻴﻦ واﻟﺸﻬﺮ ﻳﻜﺘﺐ ﻓﻲ ﺛﻼﺛﺔ أﺣﺮف و اﻟﺴﻨﺔ‬
‫ﺗﻜﺘﺐ ﻓﻲ ﺣﺮﻓﻴﻦ‪.‬‬
‫‪SELECT last_name, job_id, department_id‬‬
‫‪FROM employees‬‬
‫;’‪WHERE last_name = ’Whalen‬‬

‫هﻨﺎ اﻟﺤﺮف اﻷول آﺒﻴﺮ واﻟﺒﺎﻗﻲ ﺣﺮوف‬

‫ﺻﻐﻴﺮة‬

‫‪ LAST_NAME‬ﺑـﺪاﺧﻞ اﻟﺠـﺪول هـﻞ‬ ‫ﻓﻰ اﻟﻤﺜﺎل اﻟﺴﺎﺑﻖ ﻳﺠﺐ ان ﻧﻌﺮف ﺷﻜﻞ آﺘﺎﺑـﺔ‬
‫ﻣﻜﺘﻮﺑﺔ ‪ Capital‬او ‪ Small‬ﺣﻴﺚ ان ﻋﻨﺪ ﺗﺤﺪﻳـﺪ اﻟـﺸﺮط ﻻﺑـﺪ ﻣـﻦ ﻣﻌﺮﻓـﺔ ﺷـﻜﻞ آﺘﺎﺑـﺔ‬
‫اﻻﺳﻢ‪.‬‬
‫ﻗﻮاﻋﺪ ﺑﻴﺎﻧﺎت ‪ ORACLE‬ﺗﺨﺰن اﻟﺘﻮارﻳﺦ ﻓﻲ ﺻﻴﻐﺔ أﺷﻜﺎل ﻋﺪدﻳﺔ‪ ،‬ﻳﻤﺜﻞ اﻟﻘﺮن‪ ،‬اﻟﺴﻨﺔ‪،‬‬
‫اﻟﺸﻬﺮ‪ ،‬اﻟﻴﻮم ‪،‬اﻟﺴﺎﻋﺎت‪ ،‬اﻟﺪﻗﺎﺋﻖ‪ ،‬واﻟﺜﻮاﻧﻲ‪ .‬إن ﻋﺮض اﻟﺘﺎرﻳﺦ اﻟﻤﺨﺘﺎر ‪DD-MON-RR.‬‬
‫ﻣﻼﺣﻈﺔ‪ :‬ﺗﻐﻴﻴﺮ ﺻﻴﻐﺔ ﻋﺮض اﻟﺘﺎرﻳﺦ ﺗﻐﻄﻲ ﻓﻲ اﻟﻔﺼﻞ اﻟﺘﺎﻟﻰ ‪.‬‬
‫ﻣﻼﺣﻈﺔ‪:‬ﺑﻌﺾ اﻟﻄﻼب رﺑﻤﺎ ﻳﺴﺄﻟﻮن آﻴﻒ ﻳﻤﻜﻦ ﺗﻐﻴﺮ ﺷﻜﻞ اﻟﺘﺎرﻳﺦ ذﻟﻚ ﻳﻜﻮن ﻓﻲ‬
‫اﻟﻔﺼﻞِ‬
‫اﻟﺘﺎﻟﻰ ‪ ،‬ﺳﻮف ﻧﻐﻄﻲ اﺳﺘﺨﺪام ‪. single-row functions‬‬
 ‫ﺷﺮوط اﻟﻤﻘﺎرﻧﺔ )ﻣﻌﺎﻣﻼت اﻟﻤﻘﺎرﻧﺔ(‬
‫اﻟﻌﻮاﻣﻞ‬ ‫اﻟﻤﻌﻨﻰ‬
‫=‬ ‫ﻳﺴﺎوي‬
‫>‬ ‫أآﺒﺮ ﻣﻦ‬
‫= >‬ ‫أآﺒﺮ ﻣﻦ أو ﻳﺴﺎوى‬
‫<‬ ‫أﻗﻞ ﻣﻦ‬
‫= <‬ ‫أﻗﻞ ﻣﻦ أو ﻳﺴﺎوي‬
‫><‬ ‫ﻻ ﻳﺴﺎوي‬
‫ﺷﺮوط اﻟﻤﻘﺎرﻧﺔ )ﻣﻌﺎﻣﻼت اﻟﻤﻘﺎرﻧﺔ(‬
‫ﺷﺮوط اﻟﻤﻘﺎرﻧﺔ ﺗﺴﺘﻌﻤﻞ ﻻﻣﻜﺎﻧﻴﺔ ﻋﻤﻞ اﻟﻤﺮاﻗﻨﺔ ‪.‬‬
‫ﻣﺜﺎل‪:‬‬
‫’‪. . WHERE hire_date =’01-JAN-95‬‬
‫‪... WHERE salary‬‬ ‫‪>=6000‬‬
‫’‪... WHERE last_name =’Smith‬‬
‫اﻷﺳﻢ اﻟﻤﺴﺘﻌﺎر )‪ (Alias‬ﻻ ﻳﻤﻜﻦ أَن ﻳﺴﺘﻌﻤﻞ ﻓﻲ ﻓﻘﺮة ‪. WHERE‬‬

‫اﺳﺘﺨﺪام ﻣﻌﺎﻣﻼت اﻟﻤﻘﺎرﻧﺔ ‪-:‬‬

‫ﺗﺴﺘﺨﺪم ﻣﻌﺎﻣﻼت اﻟﻤﻘﺎرﻧﺔ ﻓﻲ ﺟﻤﻠﺔ اﻟﺸﺮط ﻟﻤﻘﺎرﻧﺔ ﺗﻌﺒﻴﺮ ﺑﺂﺧﺮ ﻓﻲ ﺟﻤﻠﺔ ‪WHERE‬‬
‫‪.‬‬
‫آﻤﺎ ﻓﻲ اﻟﻤﺜﺎل‪:‬‬

‫ﻓﻔﻰ اﻟﻤﺜﺎل اﻟﺴﺎﺑﻖ ﺗﻢ اﺳﺘﺨﻼص اﻟﺴﻢ اﻻﺧﻴﺮ و اﻟﻤﺮﺗﺐ ﻟﻜﺎﻓﺔ اﻟﻤﻮﻇﻔﻴﻦ اﻟﺬﻳﻦ‬
‫ﻳﺤﺼﻠﻮن ﻋﻠﻰ ﻣﺮﺗﺐ اﻗﻞ ﻣﻦ او ﻳﺴﺎوى ‪. 3000‬‬

‫ﻣﻼﺣﻈﺔ‪ :‬ﻳﻤﻜﻦ اﺳﺘﺨﺪام =^ او != ﺑﺪﻻ ﻣﻦ >< ﻟﻠﺪﻻﻟﺔ ﻋﻠﻰ اﻧﺔ ﻻ ﻳﺴﺎوى‬

‫آﻤﺎ ﻓﻰ اﻟﻤﺜﺎل اﻟﺘﺎﻟﻰ ‪:‬‬

‫ﻓﻰ اﻟﻤﺜﺎل اﻟﺴﺎﺑﻖ ﺗﻢ اﺳﺘﺨﻼص اﻟﺴﻢ اﻻﺧﻴﺮ و اﻟﻮﻇﻴﻔﺔ و اﻟﻤﺮﺗﺐ و ﺗﻢ اﻋﻄـﺎء اﺳـﻢ‬
‫ﻣﺴﺘﻌﺎر ﻟﻠﻤﺮﺗﺐ ﻟﻴﺼﺒﺢ ‪ DEPARTMENT_ID‬وذﻟﻚ ﻟﻜﻞ اﻟﻤﻮﻇﻔﻴﻦ اﻟﺬﻳﻦ ﻳﺤﺼﻠﻮن ﻋﻠﻰ‬
‫ﺔ ﺑﻔﻘﺮة ‪.WHERE‬‬ ‫ﺔ واﺿﺤ ُ‬
‫ﻣﺮﺗﺐ ﻻ ﻳﺴﺎوى ‪ . 5000‬ﻣﻼﺣﻈﺔ هﻨﺎ ﺗﻢ اﻋﻄﺎء ﻗﻴﻤ ُ‬
‫وﻳـﺴﺘﺨﻠﺺ اﻟﻤﺮﺗﺒـﺎت‬ ‫ﺑﺠـﺪول اﻟﻤـﻮﻇﻔﻴﻦ‬ ‫اى إن ‪ 5000‬ﺗﻘﺎرن ﺑﻘﻴﻢ ﻋﻤﻮد اﻟﻤﺮﺗﺒِـﺎت‬
‫اﻟﺘﻰ ﻻ ﺗﺴﺎوى ‪.5000‬‬

‫ﻣﻌﺎﻣﻼت أﺧﺮى ﻟﻠﻤﻘﺎرﻧﺔ‪:‬‬

‫ﻧﻔﻲ اﻟﻤﻌﺎﻣﻞ‬ ‫اﻟﻤﻌﺎﻣﻞ‬ ‫اﻟﻤﻌﻨﻰ‬

‫هﻞ اﻟﻘﻴﻤﺔ داﺧﻞ اﻟﻨﻄﺎق‬
‫‪BETWEEN ِsmall AND Big‬‬
‫اﻟﺬى ﻳﺒﺪأ ﺑﺎﻟﻘﻴﻤﺔ‬
‫‪NOT BETWEEN‬‬
‫‪ small‬وﻳﻨﺘﻬﻰ‬
‫ﺑﺎﻟﻘﻴﻤﺔ‪Big‬‬
‫هﻞ اﻟﻘﻴﻤﺔ ﺑﻴﻦ ﻣﺠﻤﻮﻋﺔ‬
‫)‪IN(set‬‬
‫‪NOT IN‬‬ ‫ﻣﻦ اﻟﻘﻴﻢ اﻟﺘﻰ ﺑﻴﻦ‬
‫اﻟﻘﻮﺳﻴﻦ‬
‫هﻞ اﻟﻘﻴﻤﺔ ﺷﺒﻴﻬﻪ ﺑﻘﻴﻤﺔ‬
‫‪NOT LIKE‬‬ ‫‪LIKE‬‬
‫ﻣﻌﻴﻨﺔ‬
‫‪IS NOT NULL‬‬ ‫‪IS NULL‬‬ ‫هﻞ هﻲ ﻗﻴﻤﺔ ﻓﺎرﻏﺔ‬

‫اﺳﺘﺨﺪام ﺷﺮط ‪:BETWEEN‬‬

‫ﻋﻼﻣﺔ اﻟﺤﺼﺮ ‪ BETWEEN‬ﺗﺴﺘﺨﺪم ﻟﺤﺼﺮ ﻗﻴﻤﺔ ﺑﻴﻦ ﻗﻴﻤﺘﻴﻦ وهﻲ ﺗﻜﺘﺐ آﺎﻟﺘﺎﻟﻲ‬
‫‪ BETWEEN‬ﺛﻢ ﻳﻠﻴﻬﺎ اﻟﻘﻴﻤﺔ اﻟﺼﻐﺮى اوﻻ ﺛﻢ ﻳﻠﻴﻬﺎ ‪ AND‬ﺛﻢ ﻳﻠﻴﻬﺎ اﻟﻘﻴﻤﺔ اﻟﻜﺒﺮى ‪.‬‬
‫ﺗﺴﺘﺨﺪم ﻻﺳﺘﺮﺟﺎع ﺑﻴﺎﻧﺎت اﻟﺼﻔﻮف ﻓﻰ اﻟﻤﺪي ﺑﻴﻦ اﻟﻘﻴﻤﺘﻴﻦ‪.‬‬

‫أﺻﻐﺮ ﻗﻴﻤﺔ‬ ‫أآﺒﺮ ﻗﻴﻤﺔ‬

‫اﺳﺘﺨﺪام ﺷﺮط ‪BETWEEN‬‬

‫وﻓﻲ اﻟﻤﺜﺎل ﺗﻢ ﻋﺮض ﺑﻴﺎﻧﺎت اﻟﻤﻮﻇﻔﻴﻦ اﻟﺬﻳﻦ ﺗﻨﺤﺼﺮ ﻣﺮﺗﺒﺎﺗﻬﻢ ﺑﻴﻦ ‪ 2500‬و ‪ 3500‬أي‬
‫أﻧﻪ ﻳﺘﻢ ﻋﺮض ﺑﻴﺎﻧﺎت اﻟﻤﻮﻇﻔﻴﻦ اﻟﺬﻳﻦ ﻳﺘﻘﺎﺿﻮن ﻣﺮﺗﺐ ﻗﺪرة ‪ 2500‬أو ﻳﺰﻳﺪ ﻋﻦ ذﻟﻚ وﻓﻲ‬
‫ﻧﻔﺲ اﻟﻮﻗﺖ ﻻ ﻳﺰﻳﺪ ﻋﻦ ‪.3500‬‬
‫ﻓﻲ اﻟﻤﺜﺎل اﻟﺴﺎﺑﻖ ﺗﻢ اﺳﺘﺮﺟﺎع اﻟﺼﻔﻮف ﻣﻦ ﺟﺪول اﻟﻤﻮﻇﻔﻴﻦ اﻟﺬي راﺗﺒﻪ ﻣﺎ ﺑﻴﻦ‬
‫‪ 2,500‬و ‪. 3,500‬‬
‫ﺗﺤﺪﻳﺪ اﻟﻘﻴﻢ ﻣﻊ ﺷﺮط ‪ BETWEEN‬ﻳﺠﺐ أَن ﺗﺤﺪد أﻗﻞ ﻗﻴﻤﺔ أوﻻ ﺛﻢ أآﺒﺮ ﻗﻴﻤﺔ ﺛﺎﻧﻴﺎ‬
‫‪.‬‬

‫ﻣﺜﺎل اﺧﺮ‪:‬‬
 ‫اﺳﺘﺨﺪام ﻣﻌﺎﻣﻞ اﻟﺸﺮط ‪IN‬‬

‫ﻳﺴﺘﺨﺪم هﺬا اﻟﻤﻌﺎﻣﻞ ﻟﻠﺒﺤﺚ ﻋﻦ ﻗﻴﻤﺔ داﺧﻞ ﻣﺠﻤﻮﻋﺔ ﻣﻦ اﻟﻘﻴﻢ وﺗﻮﺿﻊ ﺑﻴﻦ ﻗﻮﺳﻴﻦ‪.‬‬

‫ﻣﺜﺎل ‪:‬‬

‫ﻓﻲ اﻟﻤﺜﺎل اﻟﺴﺎﺑﻖ ﺗﻢ اﺳﺘﺨﻼص رﻗﻢ اﻟﻤﻮﻇﻒ و اﻻﺳﻢ اﻻﺧﻴﺮ و اﻟﻤﺮﺗﺐ و رﻗﻢ اﻟﻤﺪﻳﺮ‬
‫ﻻى ﻣﻮﻇﻒ ﻳﻌﻤﻞ ﻟﻠﻤﺪرﻳﻦ اﻟﺬﻳﻦ ارﻗﺎﻣﻬﻢ ﻓﻰ )‪. (100,101,201‬‬
‫وﻻﺣﻆ ﻋﻤﻮد ‪ MANAGER_ID‬ﺗﺠﺪ اﻧﺔ ﻳﺤﺘﻮى ﻋﻠﻰ ﺗﻠﻚ اﻻرﻗﺎم اﻟﻤﺤﺪدة ﺑﻴﻦ‬
‫اﻟﻘﻮﺳﻴﻦ‪.‬‬
‫ﺷﺮط ‪ IN‬ﻳﻤﻜﻦ أَن ﻳﺴﺘﻌﻤﻞ ﻣﻊ أي ﻧﻮع ﻣﻦ اﻟﺒﻴﺎﻧﺎت)ارﻗﺎم او ﺣﺮوف او ‪.(.......‬‬
‫ﻓﺎﻟﻤﺜﺎل اﻟﺘﺎﻟﻲ ﻳﺴﺘﺮﺟﻊ رﻗﻢ اﻟﻤﻮﻇﻒ و رﻗﻢ اﻟﻤﺪﻳﺮ و رﻗﻢ اﻟﻘﺴﻢ ﻟﻠﻤﻮﻇﻔﻴﻦ اﻟﺬﻳﻦ‬
‫اﺳﻤﺎﺋﻬﻢ ﻣﺜﻞ )‪ Hartstein‬او ‪(Vargas‬‬
‫‪SELECT employee_id, manager_id, department_id‬‬
‫‪FROM employees‬‬
‫;)’‪WHERE last_name IN (’Hartstein’, ’Vargas‬‬
‫ﻻﺣﻆ ﻋﻨﺪﻣﺎ ﻧﺮﻳﺪ اﻟﻤﻘﺎرﻧﺔ )ﺑﺤﺮوف أو ﺑﺘﻮارﻳﺦ( ﻓﻴﺠﺐ أَن ﻳﻜﻮﻧﻮا ﻣﺮﻓﻘﻴﻦ ﻓﻲ ﻋﻼﻣﺎت‬
‫‘( ‪. SINGLE QUOTATION‬‬ ‫اﻟﺘﻘﺪﻳﺮِ )‘‬
‫ﻣﺜﺎل ﻋﻠﻰ ذﻟﻚ‪:‬‬

‫وذﻟﻚ ﻻﻧﺔ ﻻ ﻳﻮﺟﺪ‬ ‫‪ SALARY‬آﻠﻬﺎ ‪6000‬‬ ‫ﻧﻼﺣﻆ ﻓﻰ اﻟﻤﺜﺎل اﻟﺴﺎﺑﻖ ان ﻧﺘﺎﺋﺞ‬

‫ﻣﺮﺗﺒﺎت ﺗﺴﺎوى ‪.5000‬‬

‫اﺳﺘﺨﺪام ﺷﺮط ‪LIKE‬‬

‫آﻴﻒ ﻳﻤﻜﻦ اﻟﺒﺤﺚ ﻋﻦ اﺳﻤﺎء ﻋﻦ ﻃﺮﻳﻖ اﻟﺒﺤﺚ ﺑﺤﺮف او اآﺜﺮ ﻣﻦ ﺣﺮف ؟؟؟‬

‫„ ﺗﺴﺘﺨﺪم )_( ‪ UNDER SCORL‬ﻟﺘﻔﺎدى ﺣﺮف او اآﺜﺮ ﻣﻦ ﺣﺮف ﻣﻦ اﻟﻜﻠﻤﺔ‬

‫اﻟﻤﺮاد اﻟﺒﺤﺚ ﻋﻨﻬﺎ‪.‬ﻓﻴﻌﻮض ﻋﻦ اﻟﺤﺮف اﻟﻮاﺣﺪ ﺑﻌﻼﻣﺔ)_( ‪. UNDER SCORL‬‬
‫„ ﺗﺴﺘﺨﺪم )‪ percentage (%‬ﻟﺘﻔﺎدى اآﺜﺮ ﻣﻦ ﺣﺮف ﺑﺪون اﺳﺘﺨﺪام )_( ‪.‬‬
‫„ )ﺗﺴﺘﺨﺪم ‪ LIKE‬ﻟﻠﺒﺤﺚ اﻟﻌﺸﻮاﺋﻲ اﻟﻐﻴﺮ ﻣﺤﺪد وﻳﻤﻜﻦ اﺳﺘﺨﺪاﻣﻬﺎ ﻣﻊ اﻟﺤﺮوف‬
‫واﻷرﻗﺎم وﺑﻌﺪهﺎ ﻳﺠﺐ وﺿﻊ اﻟﻘﻴﻤﺔ اﻟﺘﻲ ﺗﻠﻲ ‪ LIKE‬ﺑﻴﻦ ﻋﻼﻣﺔ ‘ ‘ ‪SINGLE‬‬
‫‪QUOTATION‬ﺣﻴﺚ ﺳﻴﺘﻢ ﻣﻄﺎﺑﻘﺔ ﺣﺮوف اﻟﻨﺺ اﻟﻤﺬآﻮرة(‬
‫* اﺳﺘﺨﺪام ﺷﺮط ‪ LIKE‬ﻟﻠﺒﺤﺚ اﻟﻌﺸﻮاﺋﻲ ﻋﻠﻲ ﻣﺠﻤﻮﻋﺔ اﻟﻘﻴﻢ اﻟﺼﺤﻴﺤﺔِ ‪.‬‬
‫)‪ Percentage (%‬ﻳﺪل ﻋﻠﻲ ﺻﻔﺮ أو اﻟﻌﺪﻳﺪ ﻣﻦ اﻟﺤﺮوف ‪.‬‬
‫)_( ‪ UNDER SCORL‬ﻳﺪل ﻋﻠﻲ ﺣﺮف واﺣﺪ ‪.‬‬

‫ﻓﻰ اﻟﻤﺜﺎل اﻟﺴﺎﺑﻖ ﺗﻢ اﺳﺘﺨﻼص اﻻﺳﻢ اﻻول ﻣﻦ ﺟﺪول اﻟﻤﻮﻇﻔﻴﻦ‪ ،‬ﻟﻠﻤﻮﻇﻔﻴﻦ‬

‫اﻟﺬﻳﻦ‬
‫ﻳﺒﺪأ اﺳﻤﺎﺋﻬﻢ ﺑﺤﺮف ‪ . S‬و هﻨﺎ ﻻ ﻳﺸﺘﺮط ﺑﺎﻗﻰ اﻻﺳﻢ و ﻻﺑﺪ هﻨﺎ ﻣﻦ اﺳﺘﺨﺪام آﻠﻤﺔ‬
‫‪. LIKE‬‬

‫وهﻨﺎ ﻓﻲ اﻟﻤﺜﺎل اﻟﺴﺎﺑﻖ ﻧﺮﻳﺪ ﻣﻌﺮﻓﺔ ﻣﺮﺗﺒﺎت اﻟﻤﻮﻇﻔﻴﻦ اﻟﺬﻳﻦ ﻟﻬﻢ ﺛﻼﺛﺔ ارﻗﺎم أﺧﻴﺮة‬
‫‪.500‬‬

‫* ‪SELECT‬‬
‫‪FROM employees‬‬
‫‘ ‪WHERE last_name LIKE ‘_A%‬‬

‫‪A‬‬ ‫اﻟﻤﺜﺎل هﻨﺎ ﻳﻄﻠﺐ ﻋﺮض ﺑﻴﺎﻧﺎت آﻞ اﻟﻤﻮﻇﻔﻴﻦ اﻟﺬﻳﻦ ﻟﻬﻢ أﺳﻤﺎء ﺑﻬﺎ اﻟﺤﺮف اﻟﺜﺎﻧﻲ‬
‫ﺣﺮف آﺒﻴﺮ واﻟﺤﺮف اﻷول ﻣﺠﻬﻮل و ﺑﺎﻗﻲ اﻟﺤﺮوف اﻳﻀﺎ ﻏﻴﺮ ﻣﻌﻠﻮﻣﺔ وﻟﺬا ﻓﺈﻧﻨﺎ ﻧﻠﺠﺄ‬
‫ﻻﺳﺘﺨﺪام ) _ ( ﺑﺪﻻ ﻣﻦ اﻟﺤﺮف اﻷول ﺛﻢ ﻧﻀﻊ ﺣﺮف ‪ A‬ﺛﻢ ‪ %‬ﻟﺘﺤﻞ ﻣﺤﻞ ﺑﺎﻗﻲ‬
‫اﻟﺤﺮوف اﻟﻤﺠﻬﻮﻟﺔ‪.‬‬

‫ﻣﺜﺎل اﺧﺮ‪:‬‬
 ‫اﻟﻤﺜﺎل اﻟﺴﺎﺑﻖ ﻳﻄﻠﺐ ﻋﺮض اﻻﺳﻢ اﻻول ﻟﻠﻤﻮﻇﻔﻴﻦ اﻟﺬﻳﻦ ﻟﻬﻢ أﺳﻤﺎء ﺑﻬﺎ اﻟﺤﺮف‬
‫اﻟﺜﺎﻧﻲ ‪ t‬ﺣﺮف ﺻﻐﻴﺮ واﻟﺤﺮف اﻷول ﻣﺠﻬﻮل وﺑﺎﻗﻲ اﻟﺤﺮوف ﻏﻴﺮ ﻣﻌﻠﻮﻣﺔ اﻳﻀﺎ وﻟﺬا ﻓﺈﻧﻨﺎ‬
‫ﻧﻠﺠﺄ ﻻﺳﺘﺨﺪام ) _ ( ﺑﺪﻻ ﻣﻦ اﻟﺤﺮف اﻷول ﺛﻢ ﻧﻀﻊ ﺣﺮف ‪ t‬ﺛﻢ ‪ %‬ﻟﺘﺤﻞ ﻣﺤﻞ ﺑﺎﻗﻲ‬
‫اﻟﺤﺮوف اﻟﻤﺠﻬﻮﻟﺔ وهﻲ ) ‪.( %‬‬
‫‪SELECT last_name, hire_date‬‬
‫‪FROM employees‬‬
‫;’‪WHERE hire_date LIKE ’%95‬‬
‫ﻓﻰ اﻟﻤﺜﺎل اﻟﺴﺎﺑﻖ ﺗﻢ اﺳﺘﺨﻼص اﻻﺳﻢ اﻻول و ﺗﺎرﻳﺦ اﻟﺘﻌﻴﻦ ﻣﻦ ﺟﺪول اﻟﻤﻮﻇﻔﻴﻦ‬
‫ﻟﻠﻤﻮﻇﻔﻴﻦ اﻟﺬﻳﻦ ﺗﻢ ﺗﻌﻴﻨﻬﻢ ﻓﻰ اى ﻳﻮم او اى ﺷﻬﺮ ﺑﺸﺮط ان ﻳﻜﻮن ﻓﻰ ﺳﻨﺔ ‪.95‬‬

‫‪UNDER SCORL‬‬ ‫ﻋﻨﺪﻣﺎ ﺗﺮﻳﺪ اﻟﺒﺤﺚ ﻋﻦ اﺳﻤﺎء ﺑﻬﺎ )_(‬

‫ﻳﻤﻜﻦ أَن ﺗﺴﺘﻌﻤﻞ اﻻﺗﻰ‪:‬‬

‫‪SELECT employee_id, last_name, job_id‬‬

‫‪FROM employees‬‬
‫;’\’ ‪WHERE job_id LIKE ’%SA\_%’ ESCAPE‬‬

‫ﻓﻔﻰ اﻟﻤﺜﺎل اﻟﺴﺎﺑﻖ ﻳﺮﻳﺪ رﻗﻢ اﻟﻤﻮﻇﻒ و اﻟﺴﻢ اﻻول و اﻟﻮﻇﻴﻔﺔ ﻟﻠﻤﻮﻇﻔﻴﻦ اﻟﺬﻳﻦ‬
‫وﻇﻴﻔﺘﻬﻢ اول ﺣﺮﻓﻴﻦ ﻣﻨﻬﺎ ‪ SA‬و ﺛﺎﻟﺚ ﺣﺮف )_(‪.‬‬

‫اﺳﺘﺨﺪام ﺷﺮط ‪IS NULL‬‬

‫ﻳﺴﺘﺨﺪم هﺬا اﻟﻌﺎﻣﻞ ﻟﻔﺤﺺ اﻟﻘﻴﻤﺔ )ﻻ ﺷﺊ ( أي ﻗﻴﻤﺔ ﻻ ﺗﺤﺘﻮي ﻋﻠﻲ ﺑﻴﺎﻧﺎت‬

‫اﻟﺸﺮط ‪ IS NULL‬ﻳﺨﺘﺎر اﻟﺨﻼﻳﺎ اﻟﺘﻰ ﻻ ﻳﻮﺟﺪ ﺑﻬﺎ ﺑﻴﺎﻧﺎت اى اﻧﻬﺎ ‪. NULL‬‬

‫ﻗﻴﻤﺔ ‪ Null‬هﻲ ﻗﻴﻤﺔ ﻏﻴﺮ ﻣﺨﺼﺼﺔ ﻏﻴﺮ ﻣﺘﻮﻓﺮة اى ﻣﺠﻬﻮﻟﺔ‪ ،‬أو ﻏﻴﺮ ﻣﻼﺋﻤﺔ‪.‬‬
‫‪. Null‬‬ ‫إذن ﻻ ﻳﻤﻜﻦ اﺳﺘﺨﺪام )=( ﻣﻊ‬
‫‪select ename from emp where comm= null‬‬ ‫ﻓﻼ ﺑﻤﻜﻦ ان ﺗﻘﻮل‬

‫ﻓﺎﻟﻤﺜﺎل اﻟﺴﺎﺑﻖ ﻳﺴﺘﺮﺟﻊ اﻷﺳﻤﺎء و ارﻗﺎم اﻟﻤﺪﻳﺮﻳﻦ ﻣﻦ ﺟﺪول اﻟﻤﻮﻇﻔﻴﻦ اﻟﺬﻳﻦ ﻻ‬

‫ﻳﻤﻠﻜﻮن ﻣﺪﻳﺮ‪.‬‬
‫)ﻓﻬﻨﺎ ﻧﺠﺪ ان ‪ KING‬هﻮ ﻣﺪﻳﺮ وﻟﻴﺲ ﻳﺮأﺳﻪ ﻣﺪﻳﺮ و ﻧﺠﺪ ان ﺧﺎﻧﺔ ‪MANAGER_ID‬‬
‫ﻓﺎرﻏﺔ (‬
‫اﻟﻤﺜﺎل اﻟﺘﺎﻟﻰ ﻳﻌﺮض اﻷﺳﻢ اﻷﺧﻴﺮ و وﻇﻴﻔﺘﺔ و اﻟﻌﻤﻮﻟﺔ ﻣﻦ ﺟﺪول اﻟﻤﻮﻇﻔﻴﻦ اﻟﺬﻳﻦ‬
‫ﻟﻴﺲ ﻟﻬﻢ ﻋﻤﻮﻟﺔ )ﺑﻤﻌﻨﻰ ﻻ ﻳﺄﺧﺬون ﻋﻤﻮﻟﺔ( ‪.‬‬
‫‪SELECT last_name, job_id, commission_pct‬‬
‫‪FROM employees‬‬
‫;‪WHERE commission_pct IS NULL‬‬
 ‫ﻣﺠﻤﻮﻋﺔ ﻣﻦ اﻟﺸﺮوط اﻟﻤﻨﻄﻘﻴﺔ‬
‫هﻨﺎك ﺛﻼث ﺷﺮوط ﻣﻨﻄﻘﻴﺔ ﻳﻤﻜﻦ اﺳﺘﺨﺪاﻣﻬﺎ ﻓﻲ ﺟﻤﻠﺔ اﻟﺸﺮط ﻣﻊ آﻠﻤﺔ ‪WHERE‬‬

‫اﻟﻌﻮاﻣﻞ‬ ‫اﻟﻤﻌﻨﻲ‬
‫‪AND‬‬ ‫ﺗﺴﺘﺨﺪم ﻟﻠﺮﺑﻂ ﺑﻴﻦ ﺷﺮﻃﻴﻦ وﺗﻌﻨﻲ‬
‫ﺗﺤﻘﻖ اﻟﺸﺮﻃﻴﻦ ﻣﻌﺎ ‪.‬‬
‫‪OR‬‬ ‫ﺗﺴﺘﺨﺪم ﻟﻠﺮﺑﻂ ﺑﻴﻦ ﺷﺮﻃﻴﻦ ﻳﺠﺐ‬
‫ﺗﺤﻘﻴﻖ أﺣﺪهﻤﺎ ﻓﻘﻂ ‪.‬‬
‫‪NOT‬‬ ‫ﺗﺴﺘﺨﺪم ﻟﻨﻔﻲ اﻟﺸﺮط اﻟﺬي ﻳﻠﻴﻬﺎ وهﻲ‬
‫ﺗﻌﻨﻲ وﺟﻮب ﻋﺪم ﺗﺤﻘﻖ هﺬا اﻟﺸﺮط‪.‬‬

‫اﺳﺘﺨﺪام اﻟﺸﺮط ‪:AND‬‬

‫ﻣﻌﺎﻣﻞ ‪ AND‬ﻳﺘﻄﻠﺐ ﺗﺤﻘﻖ آﻼ ﻣﻦ اﻟﺸﺮﻃﻴﻦ ﻣﻌﺎ‪.‬‬

‫اﻟﻤﺜﺎل اﻟﺴﺎﺑﻖ ﻳﺴﺘﺨﻠﺺ رﻗﻢ اﻟﻤﻮﻇﻒ و اﻻﺳﻢ و اﻟﻮﻇﻴﻔﺔ و اﻟﻤﺮﺗﺐ ﻟﻜﻞ اﻟﻤﻮﻇﻔﻴﻦ‬
‫اﻟﺬﻳﻦ ﻳﺄﺧﺬون ﻣﺮﺗﺐ أآﺒﺮ أو ﻳﺴﺎوى ‪ 10000‬و ﻓﻰ ﻧﻔﺲ اﻟﻮﻗﺖ اﺳﻢ اﻟﻮﻇﻴﻔﺔ ﻳﺘﻀﻤﻦ‬
‫اﻟﺤﺮوف اﻟﺘﺎﻟﻴﺔ ‪. MAN‬‬
‫ﻣﺜﺎل اﺧﺮ‪:‬‬

‫هﻨﺎ ﻓﻲ اﻟﻤﺜﺎل ﻧﺮﻳﺪ اﺳﺘﻌﺮاض ﺑﻴﺎﻧﺎت اﻟﻤﻮﻇﻔﻴﻦ اﻟﺬﻳﻦ ﻳﺘﻘﺎﺿﻮن ﻣﺮﺗﺒﺎ اآﺒﺮ ﻣﻦ ‪10000‬‬
 ‫و ﻻ ﻳﺄﺧﺬون ﻋﻤﻮﻟﺔ وهﻨﺎ ﻻﺑﺪ ﻣﻦ ﺗﺤﻘﻴﻖ اﻟﺸﺮﻃﻴﻦ ﻣﻌﺎ ‪.‬‬

‫اﺳﺘﺨﺪام اﻟﺸﺮط ‪: OR‬‬

‫‪ OR‬ﻳﺘﻄﻠﺐ ان ﻳﻜﻮن اى ﻣﻦ اﻟﺸﺮﻃﻴﻦ ﺻﺤﻴﺢ‪:‬‬

‫وهﻨﺎ ﻓﻲ اﻟﻤﺜﺎل اﻟﺴﺎﺑﻖ ﻗﻤﻨﺎ ﺑﺘﻐﻴﺮ ‪ OR‬ﺑﺪﻻ ﻣﻦ ‪ AND‬وهﺬا ﻳﻌﻨﻲ أﻧﻨﺎ ﻧﺮﻳﺪ ﻋـﺮض‬
‫ﺑﻴﺎﻧﺎت اﻟﻤـﻮﻇﻔﻴﻦ اﻟـﺬﻳﻦ ﻳﺘﻘﺎﺿـﻮن راﺗـﺐ )أآﺒـﺮ ﻣـﻦ أو ﻳـﺴﺎوي ‪ (10000‬أو ﻋـﺮض ﺑﻴﺎﻧـﺎت‬
‫اﻟﻤﻮﻇﻔﻴﻦ اﻟﺬي ﻳﻌﻤﻠﻮن ﻓﻰ وﻇﻴﻔﺔ ﺗﺤﺘﻮى ﻋﻠﻰ اﻟﺤﺮوف ‪. MAN‬‬
‫وﺑﺎﻟﻨﻈﺮ ﻓﻲ ﻋﻤﻮد اﻟﻤﺮﺗﺒﺎت ‪ SALARY‬ﻧﺠﺪ أن اﻟﻮﻇﺎﺋﻒ ﻏﻴﺮ ‪ ST_MAN‬ﻳﻘﺎﺑﻠﻬﺎ ﻣﺮﺗﺒـﺎت‬
‫أآﺒﺮ ﻣﻦ ‪. 10000‬‬

‫‪: NOT‬‬ ‫اﺳﺘﺨﺪام اﻟﺸﺮط‬

‫هﺬا اﻟﻤﺜﺎل ﻳﻮﺿﺢ اﺳﺘﺨﺪام آﻠﻤﺔ ‪ NOT‬وﻳﺆدي إﻟﻲ ﻋﻜﺲ اﻟـﺸﺮط ﺑﻤﻌﻨـﻲ أﻧﻨـﺎ ﻧﺮﻳـﺪ‬
‫ﻓﻲ هﺬا اﻟﻤﺜـﺎل اﺧﺘﻴﺎرآـﻞ اﻟﻮﻇـﺎﺋﻒ ﻣﺎﻋـﺪا اﻟـﺬﻳﻦ وﻇﻴﻔـﺘﻬﻢ ‪’IT_PROG’,’ST_CLERK’,‬‬
‫‪ ’SA_REP‬وﻓﻲ اﻟﻨـﺎﺗﺞ ﺗﺠـﺪ أن اﻟﻮﻇـﺎﺋﻒ ﻻ ﺗﺤﺘـﻮي ﻋﻠـﻲ أي ﻣﻨﻬﻤـﺎ ﻣـﻦ اﻟـﺜﻼث وﻇـﺎﺋﻒ‬
‫اﻟﺴﺎﺑﻘﺔ‪.‬‬

‫ﻣﺜﺎل اﺧﺮ‬
 ‫هﺬا اﻟﻤﺜﺎل ﻳﻮﺿﺢ اﺳﺘﺨﺪام آﻠﻤﺔ ‪ NOT‬وﻳﺆدي إﻟﻲ ﻋﻜﺲ اﻟﺸﺮط‪.‬‬
‫ﺑﻤﻌﻨﻲ أﻧﻨﺎ ﻧﺮﻳﺪ ﻓﻲ هﺬا اﻟﻤﺜﺎل اﻟﻤﻮﻇﻔﻴﻦ اﻟﺬﻳﻦ ﻻﻳﺤﺘﻮى ﺛﺎﻧﻰ ﺣﺮف ﻣﻨﻬﻢ ﻋﻠﻰ اﻟﺤﺮف‬
‫)‪.(t‬‬

‫اﻣﺜﻠﺔ ﻋﻠﻰ ‪BETWEEN, LIKE, and , null‬‬

‫‪...‬‬ ‫‪WHERE‬‬ ‫)’‪job_id NOT IN (’AC_ACCOUNT’, ’AD_VP‬‬

‫‪...‬‬ ‫‪WHERE‬‬ ‫‪salary NOT BETWEEN 10000 AND 15000‬‬
‫‪...‬‬ ‫‪WHERE‬‬ ‫’‪last_name NOT LIKE ’%A%‬‬
‫‪...‬‬ ‫‪WHERE‬‬ ‫‪commission_pct IS NOT NULL‬‬

‫أوﻟﻮﻳﺎت اﻟﻤﻌﺎﻣﻼت اﻟﻤﻨﻄﻘﻴﺔ وﻣﻌﺎﻣﻼت اﻟﻤﻘﺎرﻧﺔ‬

‫اﻟﻤﻌﺎﻣﻞ‬ ‫اﻷﺳﺒﻘﻴﺔ‬
‫اﻟﻤﻌﺎﻣﻼت اﻟﺤﺴﺎﺑﻴﺔ )اﻟﻀﺮب و اﻟﻘﺴﻤﺔ واﻟﺠﻤﻊ‬ ‫‪1‬‬
‫واﻟﻄﺮح(‬
‫ﻣﻌﺎﻣﻞ || ﻟﺼﻖ اﻷﻋﻤﺪة )ﺿﻢ اﻷﻋﻤﺪة(‬ ‫‪2‬‬
‫ﻣﻌﺎﻣﻼت اﻟﻤﻘﺎرﻧﺔ )= ‪<= , < , >= , > ,‬‬ ‫‪3‬‬
‫‪(<> ,‬‬
‫‪IS [NOT] NULL, LIKE, [NOT] IN‬‬ ‫‪4‬‬
‫‪[NOT] BETWEEN‬‬ ‫‪5‬‬
‫اﻟﻤﻌﺎﻣﻼت اﻟﻤﻨﻄﻘﻴﺔ ‪-3 (AND ) -2 (NOT ) -1‬‬ ‫‪6‬‬
‫) ‪(OR‬‬
‫ﻳﻤﻜﻦ أَن ﺗﺘﺠﺎوز اﻻوﻟﻮﻳﺔ ﻓﻰ ﺗﺮﺗﻴﺐ اﻟﻌﻮاﻣﻞ ﺑﺎﺳﺘﺨﺪام اﻷﻗﻮاس ﺣﻮل اﻟﺘﻌﺒﻴﺮات اﻟﺘﻲ‬
‫ﺗﺮﻳﺪهﺎ أَن ﺗﺘﻨﻔﺬ أوﻻ ‪.‬‬

‫ﺗﺠﺎوز ﻗﻮاﻋﺪ اﻷﺳﺒﻘﻴﺔ ﺑﺎﺳﺘﺨﺪام اﻷﻗﻮاس ‪.‬‬

‫‪. OR‬‬
‫ﻓﻰ هﺬا اﻟﻤﺜﺎل ﻳﻮﺟﺪ ﺷﺮﻃﺎن ﻳﺘﻢ ﺗﻨﻔﻴﺬ اﺣﺪاهﻤﺎ ﺑﺴﺒﺐ اﺳﺘﺨﺪام‬
‫‪. SA_REP‬‬ ‫* اﻟﺸﺮط اﻷول أن ﺗﻜﻮن اﻟﻮﻇﻴﻔﺔ‬
‫* اﻟﺸﺮط اﻟﺜﺎﻧﻲ أن ﺗﻜﻮن اﻟﻮﻇﻴﻔﺔ ‪ AD_PRES‬و ﻓﻰ ﻧﻔﺲ اﻟﻮﻗﺖ ﻳﺤﺼﻞ ﻋﻠﻰ‬
‫ﻣﺮﺗﺐ اآﺒﺮ ﻣﻦ ‪. 15000‬‬

‫اﺳﺘﺨﺪام اﻷﻗﻮاس ﻻﻟﻐﺎء اﻷوﻟﻮﻳﺔ‬

 ‫اﺳﺘﺨﺪام اﻷﻗﻮاس ﻟﻠﺘﺤﻜﻢ ﻓﻲ ﺗﺤﻘﻴﻖ اﻟﺸﺮوط واﻷوﻟﻮﻳﺔ ﺗﻜﻮن ﻟﻸﻗﻮاس ‪.‬‬
‫‪. AND‬‬ ‫ﻓﻬﻨﺎ ﻳﺘﻢ ﺗﻨﻔﻴﺬ ‪ OR‬ﻗﺒﻞ‬
‫ﻓﻔﻰ اﻟﻤﺜﺎلِ اﻟﺴﺎﺑﻖ ‪ ،‬هﻨﺎك ﺷﺮﻃﺎن ‪:‬‬
‫‪ SA_REP‬او ‪. AD_PRES‬‬ ‫* اﻟﺸﺮط اﻷول ﺑﺄن ﺗﻜﻮن اﻟﻮﻇﻴﻔﺔ اﻣﺎ‬
‫* اﻟﺸﺮط اﻟﺜﺎﻧﻲ أن ﻳﻜﻮن اﻟﺮاﺗﺐ أآﺒﺮ ﻣﻦ ‪. 15,000‬‬

‫اﻟﻔﺮز واﻟﺘﺮﺗﻴﺐ ‪ORDER BY‬‬

‫ﻟﺘﺮﺗﻴﺐ ﻧﺘﻴﺠﺔ أﻣﺮ ‪ SELECT‬ﻧﻘﻮم ﺑﺎﺳﺘﺨﺪام آﻠﻤﺔ ‪ ORDER BY‬و ﻻﺣﻆ اﻧﻬﺎ ﺗﻮﺿﻊ‬
‫ﻓﻲ ﺁﺧﺮ أﻣﺮ ‪ SELECT‬ﺛﻢ ﻳﻠﻴﻬﺎ أﺳﻢ اﻟﻌﻤﻮد اﻟﺬي ﻳﺮاد اﻟﺘﺮﺗﻴﺐ ﺑﻪ ‪.‬‬
‫*ﻓﺮز اﻟﺼﻔﻮف ﺑﻮاﺳﻄﺔ ﻓﻘﺮة ‪ORDER BY‬‬
‫‪ :ASC‬اﻟﺘﺮﺗﻴﺐ اﻟﺘﺼﺎﻋﺪي و ﻻ ﻳﺸﺘﺮط آﺘﺎﺑﺘﺔ ﺣﻴﺚ اﻧﺔ ﻳﻌﺘﺒﺮ ‪. DEFAULT‬‬
‫‪ :DESC‬اﻟﺘﺮﺗﻴﺐ اﻟﺘـــــﻨﺎزﻟﻲ )اﻻﻧﺤﺪار( ‪.‬‬

‫ﻣﻠﺤﻮﻇﺔ هﺎﻣﺔ ‪-:‬‬

‫هﻨﺎ ﻓﻲ اﻟﻤﺜﺎل ﻟﻢ ﻳﺤﺪد ‪ DESC & ASC‬وﻓﻲ هﺬﻩ اﻟﺤﺎﻟﺔ ﻳﺘﻢ ﺑﺎﻟﺘﺮﺗﻴﺐ اﻟﺘﺼﺎﻋﺪى ‪.‬‬
‫ﻟﺘﺮﺗﻴﺐ ﻧﺘﻴﺠﺔ اﻷﻣﺮ ‪ SELECT‬ﻧﻘﻮم ﺑﺎﺳﺘﺨﺪام آﻠﻤﺔ ‪ ORDER BY‬وهﻲ ﺗﻮﺿﻊ ﻓﻲ‬
‫ﺁﺧﺮ ﺟﻤﻠﺔ ‪ SELECT‬ﺛﻢ ﻳﻠﻴﻬﺎ اﺳﻢ اﻟﻌﻤﻮد اﻟﻤﺮاد اﻟﺘﺮﺗﻴﺐ ﺑﻪ وهﻨﺎ هﻮ ‪ hire_date‬وﻋﻨﺪ‬
‫اﺳﺘﺨﺪام اﻟﺤﻘﻞ ﺗﻜﻮن اﻟﻨﺘﻴﺠﺔ آﻤﺎ ﻧﺮي أﻣﺎﻣﻨﺎ‪.‬‬
‫أﻧﺖَ ﻳﻤﻜﻦ اﺳﺘﺨﺪام اﻻﺳﻢ اﻟﻤﺴﺘﻌﺎر )‪ (ALIAS‬ﻓﻰ ﺟﻤﻠﺔ ‪. ORDER BY‬‬
‫‪FROM table‬‬
‫])‪[WHERE condition(s‬‬
‫;]]‪[ORDER BY {column, expr} [ASC|DESC‬‬
‫‪ ORDER BY‬ﺗﺤﺪد أى اﻟﺼﻔﻮف اﻟﻤﺴﺘﺮﺟﻌﺔ اﻟﺘﻲ ﺳﻮف ﻳﺘﻢ اﻟﺘﺮﺗﻴﺐ ﺑﻬﺎ‪.‬‬
‫‪ ASC‬ﺗﺮﺗﻴﺐ ﺗﺼﺎﻋﺪِى‪.‬‬
‫‪ DESC‬ﺗﺮﺗﻴﺐ ﺗﻨﺎزﻟﻲ‪.‬‬

‫اﻟﺘﺮﺗﻴﺐ ﺑﺸﻜﻞ ﺗﻨﺎزﻟﻲ‬

‫ﻓﻔﻲ اﻟﻤﺜﺎل اﻟﺴﺎﺑﻖ ﻳﻘﻮم ﺑﻌﺮض اﻻﺳﻢ و اﻟﻮﻇﻴﻔﺔ و رﻗﻢ اﻟﻘﺴﻢ و ﺗﺎرﻳﺦ اﻟﺘﻌﻴﻦ‬
 ‫و ﻳﻘﻮم ﺑﺘﺮﺗﻴﺐ اﻟﻨﺎﺗﺞ ﺑﻌﻤﻮد ﺗﺎرﻳﺦ اﻟﺘﻌﻴﻦ )ﺗﻨﺎزﻟﻰ( ‪.‬‬
‫* ﻗﻴﻢ اﻻرﻗﺎم ﺗﻌﺮض ﻣﻦ اﻷﺻﻐﺮ اﻟﻰ اﻷآﺒﺮ آﻤﺜﺎلِ ‪. 999.....1‬‬
‫* ﻗِﻴَﻢ اﻟﺘﺎرﻳﺦ ﺗﻌﺮض ﺑﺎﻟﻘﻴﻤﺔِ اﻷﻗﺮب أوﻻً ﺛﻢ اﻻﺑﻌﺪ آﻤﺜﺎل ‪:‬‬
‫)‪ 01‬ﻳﻨﺎﻳﺮ ‪ (92‬ﻗﺒﻞ ) ‪ 01‬ﻳﻨﺎﻳﺮ ‪. ( 95‬‬
‫‪ B‬وهﻜﺬا اﻟﻰ ‪.Z ......‬‬ ‫ض ﺑﺘﺮﺗﻴﺐ اﻷﺑﺠﺪﻳﺔ آﻤﺜﺎل ‪ A :‬ﺛﻢ‬ ‫* ﻗﻴﻢ اﻟﺤﺮوف ﺗﻌﺮ ُ‬
‫* ﻗﻴﻤــﺔ ‪ Null‬ﺗﻌــﺮض أﺧﻴــﺮاً ﻓــﻲ اﻟﺘﺮﺗﻴــﺐ اﻟﺘــﺼﺎﻋﺪي وﺗﻌــﺮض أوﻻ ﻓــﻲ اﻟﺘﺮﺗﻴــﺐ‬
‫اﻟﺘﻨﺎزﻟﻲ ‪.‬‬

‫„ ﻟﻜﻰ ﺗﻌﻜﺲ اﻟﺼﻔﻮف اﻟﺘﻲ ﺗﻌﺮض‪ ،‬ﻳﺤﺪد آﻠﻤﺔ ‪ DESC‬ﺑﻌﺪ أﺳﻢ اﻟﻌﻤﻮد ﻓﻲ‬
‫ﻓﻘﺮة ‪ .ORDER BY‬و ﺑﻬﺬة اﻟﻜﻠﻤﺔ ﻳﺘﻢ ﻋﻜﺲ اﻟﻜﻼم اﻟﺴﺎﺑﻖ آﻠﺔ ‪.‬‬
‫ﻣﻼﺣﻈﺔ‪ :‬ﻳﻤﻜﻨﻚ أَن ﺗﻔﺮز ﺑﺮﻗﻢ اﻟﻌﻤﻮد ﻓﻲ اﻟﻘﺎﺋﻤﺔ ‪ .SELECT‬ﻓﺎﻟﻤﺜﺎل اﻟﺘﺎﻟﻲ ﻳﻮﺿﺢ‬
‫ذﻟﻚ ﺣﻴﺚ ﻳﺘﻢ اﻟﺘﺮﺗﻴﺐ ﺗﻨﺎزﻟﻲ ﻟﻠﻤﺮﺗﺒﺎت ذﻟﻚ ﻋﻦ ﻃﺮﻳﻖ ﺗﺤﺪﻳﺪ رﻗﻢ اﻟﻌﻤﻮد اﻟﻤﺮاد اﻟﺘﺮﺗﻴﺐ‬
‫ﺑﺔ ‪.‬‬
‫‪SELECT last_name,‬‬
‫‪salary‬‬
‫‪FROM employees‬‬
‫;‪ORDER BY 2 DESC‬‬

‫اﻟﺘﺮﺗﻴﺐ ﺑﺎﻻﺳﻢ اﻟﻤﺴﺘﻌﺎر ) ‪(ALIAS‬‬

‫ﻓﻲ هﺬا اﻟﻤﺜﺎل ﻗﻤﻨﺎ ﺑﻀﺮب اﻟﺮاﺗﺐ اﻟﺸﻬﺮي × ‪ 12‬وﺑﺬﻟﻚ ﻧﺤﺼﻞ ﻋﻠﻲ اﻟﺮاﺗـﺐ اﻟـﺴﻨﻮي‬
‫واﻋﻄﻴﻨﺎة اﺳﻢ ‪. annsal‬‬
‫وآﻤﺎ ﻧﺮي ﺗﻢ وﺿﻊ ‪ annsal‬ﺑﻌﺪ ‪. Order by‬‬

‫اﺳﺘﺨﺪام أآﺜﺮ ﻣﻦ ﻋﻤﻮد ﻓﻲ اﻟﺘﺮﺗﻴﺐ‬

 ‫ﻳﻤﻜﻦ اﺳﺘﺨﺪام اآﺜﺮ ﻣﻦ ﻋﻤﻮد ﻓﻲ اﻟﺘﺮﺗﻴﺐ ﺑﺤﻴﺚ ﻳﻮﺿﻊ اﻟﻌﻤـﻮد اﻷول ﺛـﻢ ﻓـﺼﻠﺔ ) ‪( ,‬‬
‫ﺛﻢ اﻟﻌﻤﻮد اﻟﺜﺎﻧﻲ وﻓﻲ اﻟﻤﺜﺎل وﺿﻌﻨﺎ رﻗﻢ اﻹدارة ﺛﻢ اﻟﻤﺮﺗﺐ ﺑﺤﻴﺚ ﻳـﺘﻢ اﻟﺘﺮﺗﻴـﺐ ﺗـﺼﺎﻋﺪﻳﺎً‬
‫ﻋﻠﻲ رﻗﻢ اﻹدارة و ﻓﻰ ﻧﻔﺲ اﻟﻮﻗﺖ ﻳﻘﻮم ﺑﺘﺮﺗﻴﺐ اﻟﻤﺮﺗﺐ ﺗﻨﺎزﻟﻴﺎ وذﻟﻚ ﻳﻜﻮن ﺑﺎﻟﻨﺴﺒﺔ ﻟﻜﻞ‬
‫ادارة‪.‬‬
‫* ﻓﺎذا ﻧﻈﺮﻧﺎ اﻟﻰ ﻋﻤﻮد اﻻﻗـﺴﺎم ﻓـﻰ اﻟﻘـﺴﻢ رﻗـﻢ ‪ 20‬وﻓـﻰ ﻧﻔـﺲ اﻟﻮﻗـﺖ ﻧﻈﺮﻧـﺎ اﻟـﻰ‬
‫ﻋﻤﻮد اﻟﻤﺮﺗﺐ ﻓﻨﺠﺪ ان اﻟﻤﺮﺗﺐ ﺑﺎﻟﻨـﺴﺒﺔ ﻟﻠﻘـﺴﻢ ‪ 20‬ﺗـﻢ ﺗﺮﺗﻴﺒـﺔ ﺗﻨﺎزﻟﻴـﺎ وهﻜـﺬا ﺑﺎﻟﻨـﺴﺒﺔ‬
‫ﻟﻠﺒﺎﻗﻰ‪.‬‬
‫ﻳﻤﻜﻦ أَن ﺗﺴﺘﺨﺪم ‪ ORDER BY‬ﺑﻌﻤﻮد ﻟﻴﺲ ﻓﻲ ﻗﺎﺋﻤﺔ ‪SELECT‬‬ ‫•‬
‫‪SELECT last_name, salary‬‬
‫‪FROM employees‬‬
‫;‪ORDER BY department_id, salary DESC‬‬

‫هﻨﺎ ﻓﻲ اﻟﻤﺜﺎل ﺣﻴﺚ ﻳﻤﻜﻨﻨﺎ اﻟﺘﺮﺗﻴﺐ ﺑﺎﺳﺘﺨﺪام اﺳﻢ ﻋﻤﻮد ﻟﻴﺲ ﻣﻮﺟﻮد ﺿﻤﻦ اﻟﻘﺎﺋﻤﺔ‬
‫اﻷﻋﻤﺪة ﻓﻲ ﺟﻤﻠﺔ ‪ SELECT‬ﻓﻜﻤﺎ ﻧﺮي ﻗﺪ ﺗﻢ اﻟﺘﺮﺗﻴﺐ ﺑﺎﺳﺘﺨﺪام اﻟﻌﻤﻮد‬
‫‪ department_id‬ﻣﻊ إﻧﻪ ﻏﻴﺮ ﻣﻮﺟﻮد ﺑﺎﻟﻘﺎﺋﻤﺔ ‪.‬‬
‫اﻟﺸﻜﻞ اﻟﺘﺎﻟﻰ ﻳﻮﺿﺢ آﻴﻔﻴﺔ ﻋﻤﻞ ﺗﺮﺗﻴﺐ )ﺗﺼﻨﻴﻒ( ﻋﻠﻰ ﻋﺪة ﺻﻔﻮف‬

‫ﻓﻬﻮ ﻳﺒﺪأ اوﻻ ﺑﺎﻟﺘﺮﺗﻴﺐ ﻋﻠﻰ اﻟﻌﻤﻮد اﻻول ﻓﻰ ﻋﺒﺎرة ‪ ORDER BY‬اذا ﺣﺪث ﺗﻜﺮار ﻳﺮﺗﺐ‬
‫اﻟﺘﻜﺮارت ﻋﻠﻰ ﺣﺴﺐ اﻟﻌﻤﻮد اﻟﺜﺎﻧﻰ وهﻜﺬا‪.‬‬
‫ﻓﻔﻰ اﻟﻤﺜﺎل ﻳﺮﺗﺐ اﻟﻤﻮﻇﻔﻴﻦ ﻋﻠﻰ اﺳﺎس اداراﺗﻬﻢ ﺛﻢ ﻳﺮﺗﺐ اﻟﻤﻮﻇﻔﻴﻦ داﺧﻞ ﻧﻔﺲ‬
‫اﻻدارة ﻋﻠﻰ اﺳﺎس ﻣﺮﺗﺒﺎﺗﻬﻢ ﺗﻨﺎزﻟﻴﺎً‪.‬‬

‫اﻷهﺪاف‪:‬‬
‫ﺑﻌﺪ إآﻤﺎل هﺬا اﻟﺪرس ﻳﺠﺐ أن ﺗﻜﻮن ﻗﺎدر ﺑﺈذن اﷲ ﻋﻠﻲ ﻋﻤﻞ اﻟﺘﺎﻟﻲ‪:‬‬
‫‪ .1‬ﺗﻘﺪﻳﻢ اﻻﺳﺘﻌﻼم اﻟﺬي ﻳﺘﻄﻠﺐ ﺑﺪﻳﻞ ﻣﺘﻐﻴﺮ‪.‬‬
‫‪ .2‬ﺣﻮل )ﺗﻔﺼﻴﻞ( ﺑﻴﺌﺔ ‪. iSQL*Plus‬‬
‫‪ .3‬ﺗﻘﺪﻳﻢ ﻣﺨﺮﺟﺎت أآﺜﺮ ﻗﺮاءة‪.‬‬
‫‪ .4‬ﻳﻨﺸﺊ وﻳﻨﻔﺬ ﻣﻠﻔﺎت ﻧﺼﻴﺔ‪.‬‬
‫هﺪف درسِ‪:‬‬
 ‫ﻣﻦ هﺬا اﻟﺪرس ﺳﻮف ﺗﺘﻌﻠﻢ اﻷواﻣﺮ ‪ iSQL*Plus‬أن ﺗﺘﻀﻤﻦ إﻧﺘﺎج أآﺜﺮ ﻗﺮاءة ﻣﻦ‬
‫ﻣﺨﺮﺟﺎت ‪. SQL‬‬
‫وﻳﻤﻜﻨﻚ أن ﺗﻨﺸﺊ ﻣﻠﻒ اﻷواﻣﺮ اﻟﺬي ﻳﺤﺘﻮي ﻋﻠﻲ ﻓﻘﺮة ‪ WHERE‬آﻲ ﺗﺤﺪد اﻟﺼﻔﻮف‬
‫اﻟﻤﻌﺮوﺿﺔ‪ .‬آﻲ ﺗﻐﻴﺮ اﻟﺸﺮط آﻞ وﻗﺖ ﻟﺘﺸﻐﻴﻞ ﻣﻠﻒ اﻷواﻣﺮ‪،‬ﻳﺠﺐ أن ﺗﺴﺘﺨﺪم ﻣﺘﻐﻴﺮات‬
‫اﻟﺒﺪﻳﻞ‪.‬‬
‫ﻣﺘﻐﻴﺮات اﻟﺒﺪﻳﻞِ ﻳﻤﻜﻦ أَن ﺗﺒﺪل ﻗﻴﻢ ﻓﻲ ﻓﻘﺮة ‪،ِWHERE‬و ﻣﺠﻤﻮﻋﺔ اﻟﻨﺼﻮص‪ ،‬وﺣﺘﻰ‬
‫ﻋﻤﻮد أو أﺳﻢ ﺟﺪول ‪.‬‬
‫ﻣﺘﻐﻴﺮات ال ﺑﺪﻳﻞ) ‪(Substitution‬‬
‫اﻟﻤﺴﺘﺨﺪم ‪6‬‬
‫ﻳﺮﻳﺪ اﻻﺳﺘﻌﻼم ﻟﻠﻘﻴﻢ اﻟﻤﺨﺘﻠﻔﺔ‪.‬‬
‫اﻟﻤﺮﺗﺐ = ؟ رﻗﻢ اﻟﻘﺴﻢ = ؟ اﻻﺳﻢ اﻷﺧﻴﺮ = ؟‬
‫اﻷﻣﺜﻠﺔ إﻟﻲ ﺣﺪ اﻵن ﻗﺪ آﺎﻧﺖ ﻣﻨﻈﻤﺔ ﺣﺴﺐ ﻗﻮاﻋﺪ ﻣﻌﻴﻨﺔ ﻣﻊ ﻧﻬﺎﻳﺔ اﻟﺘﻄﺒﻴﻖ‬
‫اﻟﻤﺴﺘﺨﺪم ﺳﻮف ﻳﺴﺒﺐ ذﻟﻚ آﺘﺎﺑﺔ اﻟﺘﻘﺮﻳﺮ‪.‬‬
‫واﻟﺘﻘﺮﻳﺮ ﻳﺠﺐ أن ﻳﺸﻐﻞ ﺑﺪون ادﺧﺎل ﻣﺘﻐﻴﺮات و ﻃﻠﺐ اى ﺑﻴﺎﻧﺎت ﻣﻦ اﻟﻤﺴﺘﺨﺪم‬
‫)ﺗﺬآﻴﺮ( ﺁﺧﺮ‪.‬‬
‫ﻣﺠﻤﻮﻋﺔ اﻟﺒﻴﺎﻧﺎت ﺳﺘﻜﻮن ﻣﺤﺪدة ﻣﺴﺒﻘﺎ ﺑﻔﻘﺮة ‪ WHERE‬اﻟﺜﺎﺑﺘﺔ ﻓﻲ اﻟﻤﻠﻒ اﻟﻨـﺼﻲ ل‬
‫‪iSQL*Plus‬‬
‫واﺳــﺘﺨﺪام ‪ ،iSQL*Plus‬أﻧــﺖ ﻳﻤﻜــﻦ أن ﺗﻨــﺸﺊ ﺗﻘــﺎرﻳﺮ اﻟﺘــﻲ ﺗﺘﻌﺎﻣــﻞ ﻣـﻊ اﻟﻤــﺴﺘﺨﺪم‬
‫ﺑﺤﻴﺚ ﻳﺠﻬﺰ ﻗﻴﻤﻬﻢ اﻟﺨﺎﺻﺔ آﻲ ﺗﺤﺪد ﻣﺠﻤﻮﻋﺔ ﻣﻦ اﻟﺒﻴﺎﻧﺎت اﻟﺘﻲ اﺳـﺘﺮﺟﻌﺖ ﺑﺎﺳـﺘﺨﺪام‬
‫ﻣﺘﻐﻴﺮات اﻟﺒﺪﻳﻞِ) ‪ .(Substitution‬ﻳﻤﻜﻨﻚ أن ﺗﻀﻤﻦ ﻣﺘﻐﻴﺮات اﻟﺒﺪﻳﻞ ﻓﻲ ﻣﻠـﻒ اﻷواﻣـﺮ أو‬
‫ﻓﻲ ﺗﻌﺒﻴﺮ ‪.SQL‬‬
‫ﻣﺘﻐﻴﺮات ﻳﻤﻜﻦ أن ﺗﻮﺿﻊ ﻣﻊ اﻟﻘﻴﻢ اﻟﺘﻲ ﺗﺨﺰن ﺑﺸﻜﻞ ﻣﺆﻗـﺖ‪ .‬و ﻋﻨـﺪ ﺗـﺸﻐﻴﻞ اﻟﺘﻌﺒﻴـﺮ‪،‬‬
‫ﺗﺠﺪ أن اﻟﻘﻴﻢ ﺳﻮف ﺗﺴﺘﺒﺪل ‪.‬‬

‫ﻣﺘﻐﻴﺮات اﻟﺒﺪﻳ ِ‬
‫ﻞ‬
‫ﻓﻮاﺋﺪ اﺳﺘﺨﺪام ‪ ISQL*Plus‬ﻣﺘﻐﻴﺮات اﻟﺒﺪﻳﻞ ‪:‬‬
‫* ﺗﻜﻮﻳﻦ ﻣﺨﺰن ﻟﻠﺒﻴﺎﻧﺎت ﺑﺸﻜﻞ ﻣﺆﻗﺖ‪ .‬وذﻟﻚ ﺑﺎﺳﺘﺨﺪام‪:‬‬
‫‪ -‬ﻋﻼﻣﺔ & اﻟﻤﻔﺮدة‬
‫‪ -‬ﻋﻼﻣﺔ && اﻟﻤﻀﺎﻋﻔﺔ‬
‫‪ -‬أﻣﺮ ‪DEFINE‬‬
‫* ﺗﻤﺮﻳﺮ )ارﺳﺎل( اﻟﻘﻴﻢِ اﻟﻤﺘﻐﻴﺮة ﺑﻴﻦ ﺗﻌﺒﻴﺮات ‪.SQL‬‬
‫* ﻳﻌﺪل ﻓﺎﻋﻠﻴﺔ ﻣﺎ ﻳﻜﺘﺐ ﻓﻲ أﻋﻠﻲ اﻟﺼﻔﺤﺔ و ﻣﺎ ﻳﻜﺘﺐ ﻓﻲ أﺳﻔﻞ اﻟﺼﻔﺤﺔ‪.‬‬
‫ﻓﻰ ‪ ،iSQL*Plus‬ﻳﻤﻜﻨﻚ أن ﺗﺴﺘﺨﺪم ﻋﻼﻣﺔ & اﻟﻤﻔﺮدة و ﻣﺘﻐﻴﺮات اﻟﺒﺪﻳﻞ آﻲ‬
‫ﺗﺨﺰن ﻗﻴﻢ ﺑﺸﻜﻞ ﻣﺆﻗﺖ ‪.‬‬
‫ﻳﻤﻜﻨﻚ أن ﺗﻌﺮف اﻟﻤﺘﻐﻴﺮات ﻓﻲ ‪ iSQL*Plus‬ﺑﺎﺳﺘﺨﺪام اﻷﻣﺮ ‪.DEFINEE‬‬
‫و ﺗﺨﺼﻴﺺ ﻗﻴﻢ إﻟﻲ هﺬﻩ اﻟﻤﺘﻐﻴﺮات‪.‬‬
‫أﻣﺜﻠﺔ ﻟﻠﺒﻴﺎﻧﺎت اﻟﻤﺤﺼﻮرة‬
‫* أﺷﻜﺎل اﻟﺘﻘﺮﻳﺮ ﻓﻘﻂ ﻟﻠﺮﺑﻊ اﻟﺤﺎﻟﻲ أو ﻟﻔﺘﺮة ﻣﻦ اﻟﺘﺎرﻳﺦ اﻟﻤﺤﺪد‪.‬‬
‫* ﻳﻜﺘﺐ اﻟﺘﻘﺮﻳﺮ إِﻟﻲ اﻟﻤﺴﺘﺨﺪم ﻋﻦ اﻟﺒﻴﺎﻧﺎت اﻟﻤﺘﻌﻠﻘﺔ ﻓﻘﻂ ﻋﻦ اﻟﻤﻮﺿﻌﺎت اﻟﻤﻄﻠﻮب‬
‫ﻓﻴﻬﺎ ﺗﻘﺮﻳﺮ ﻓﻘﻂ‪.‬‬
‫ﺗﺄﺛﻴﺮات ﺗﻔﺎﻋﻠﻴﺔ أﺧﺮي‬
‫ﺗﺄﺛﻴﺮات ﺗﻔﺎﻋﻠﻴﺔ ﻻ ﺗﺤﺪد ﺑﺎﻟﻤﻌﻠﻮﻣﺎت اﻟﻤﺴﺘﺨﺪﻣﺔ اﻟﻤﺒﺎﺷﺮة ﻣﻊ اﻟﻔﻘﺮة ‪.WHERE‬‬
‫ﻧﻔﺲ اﻟﻤﺒﺎدئ ﻳﻤﻜﻦ أن ﺗﻨﺠﺰ أهﺪاف أﺧﺮي‪ .‬آﻤﺜﺎل ‪:‬‬
‫‪ .1‬ﻳﻌﺪل ﻓﺎﻋﻠﻴﺔ ﻣﺎ ﻳﻜﺘﺐ ﻓﻲ أﻋﻠﻲ اﻟﺼﻔﺤﺔ و ﻣﺎ ﻳﻜﺘﺐ ﻓﻲ أﺳﻔﻞ اﻟﺼﻔﺤﺔ‬
‫‪ .2‬ﻳﺤﺼﻞ ﻋﻠﻲ ﻗﻴﻢ اﻟﻤﺪﺧﻠﺔ ﻣﻦ ﻣﻠﻒِ ﺑﺪﻻً ﻣﻦ ﺷﺨﺺ ‪.‬‬
‫‪ .3‬ﻣﺮور )ارﺳﺎل( اﻟﻘِ َﻴﻢِ اﻟﻤﺘﻐﻴﺮةِ ﻣﻦ اﻟﺘﻌﺒﻴﺮات ‪ SQL‬اﻟﻮاﺣﺪة إِﻟﻲ اﻵﺧﺮ‪.‬‬
‫• ‪ ISQL*Plus‬ﻻ ﻳﺪﻋﻢ ﺗﺪﻗﻴﻖ اﻟﻤﺼﺎدﻗﺔ ﻋﻠﻲ إدﺧﺎل اﻟﻤﺴﺘﺨﺪم ﻓﻴﻤﺎ ﻋﺪا أﻧﻮاع‬
‫اﻟﺒﻴﺎﻧﺎت( ‪.‬‬
‫ﻣﻼﺣﻈﺎت‬
‫اﻟﺒﺪﻳﻞ اﻟﻤﺘﻐﻴﺮ ﻳﻤﻜﻦ أن ﻳﺴﺘﺨﺪم ﻓﻲ أي ﻣﻜﺎن ﻓﻲ أواﻣﺮ ‪، iSQL*Plus , SQL‬‬
‫ﻣﺎﻋﺪا آﺎﻟﻜﻠﻤﺔ اﻷوﻟﻰ اﻟﺘﻲ أدﺧﻠﺖ ﻓﻲ اﻷﻣﺮ اﻟﺴﺮﻳﻊ ‪.‬‬
 ‫&‬ ‫اﺳﺘﺨﺪام اﻟﻤﺘﻐﻴﺮ اﻟﺒﺪﻳﻞ ﻋﻼﻣﺔ‬
‫اﺳﺘﺨﺪم اﻟﻤﺘﻐﻴﺮ ﻓﻲ اﻟﻤﻘﺪﻣﺔ ﺑﻌﻼﻣﺔ & ﻟﺴﺮﻋﺔ اﻟﻤﺴﺘﺨﺪم إﻟﻲ اﻟﻘﻴﻤﺔ ‪.‬‬

‫ﻋﻨﺪﻣﺎ ﻳﺘﻢ ﺗﺸﻐﻴﻞ اﻟﺘﻘﺮﻳﺮ‪ ،‬اﻟﻤﺴﺘﺨﺪﻣﻮن ﻳﺮﻳﺪون ﻏﺎﻟﺒﺎً أَن ﻳﺤﺪدوا اﻟﺒﻴﺎﻧﺎت اﻟﺘﻲ‬
‫اﺳﺘﺮﺟﻌﺖ ﺑﺸﻜﻞ دﻳﻨﺎﻣﻴﻜﻴﺎ‪.‬‬
‫‪ iSQL*Plus‬ﺗﺰود هﺬﻩ اﻟﻤﺮوﻧﺔِ ﺑﻮاﺳﻄﺔ ﻣﺘﻐﻴﺮات اﻟﻤﺴﺘﺨﺪم‪.‬‬
‫اﺳﺘﺨﺪم ﻋﻼﻣﺔ & أَن ﺗﻤﻴﺰ آﻞ ﻣﺘﻐﻴﺮ ﻓﻲ ﺗﻌﺒﻴﺮ ‪ .SQL‬وﻟﻜﻨﻚ ﻟﺴﺖ ﺑﺤﺎﺟﺔ إﻟﻲ أن‬
‫ﺗﻌﺮف ﻗﻴﻤﺔ آﻞ ﻣﺘﻐﻴﺮ‪.‬‬

‫ﺗﺮﻗﻴﻢ‬ ‫اﻟﻮﺻﻒ‬
‫‪&user_variable‬‬ ‫اﻟﻤﺘﻐﻴﺮ ﻓﻲ ﺗﻌﺒﻴﺮ ‪ SQL‬ﻳﺸﺮ إﻟﻲ ؛ إذا ﻻ ﻳﻮﺟﺪ‬
‫اﻟﻤﺘﻐﻴﺮ ‪ iSQL*Plus ،‬ﺗﺤﺚ اﻟﻤﺴﺘﺨﺪم ﻋﻠﻲ اﻟﻘﻴﻤﺔ‬
‫) ‪ iSQL*Plus‬ﻳﺮﻣﻲ اﻟﻤﺘﻐﻴﺮ اﻟﺠﺪﻳﺪ ﻣﺮة ﺣﻴﺚ إﻧﻪ ﺗﻢ‬
‫اﺳﺘﺨﺪاﻣﻪ(‬

‫‪ iSQL*Plus‬ﻣﺘﻐﻴـﺮ ﺑـﺪﻳﻞِ ﻟـﺮﻗﻢ اﻟﻤﻮﻇـﻒ‪ .‬ﻋﻨـﺪﻣﺎ اﻷﻣـﺮ ﻳﻨﻔـﺬ‬ ‫اﻟﻤﺜـﺎل ﻳﻨـﺸﺊ‬

‫‪ iSQL*Plus‬ﻳﺤﺚ اﻟﻤﺴﺘﺨﺪم ﻋﻠﻲ رﻗﻢ اﻟﻤﻮﻇﻒ وﺑﻌﺪ ذﻟﻚ ﻳﻌﺮض ﻋﺪد اﻟﻤﻮﻇﻒ‪ ،‬اﻻﺳﻢ‬
‫اﻷﺧﻴﺮ‪ ،‬اﻟﺮاﺗﺐ‪ ،‬ورﻗﻢ اﻟﻘﺴﻢ ﻟﺬﻟﻚ اﻟﻤﻮﻇﻒ ‪ .‬ﺑﻌﻼﻣﺔ & اﻟﻮﺣﻴﺪة‪ ،‬اﻟﻤـﺴﺘﺨﺪم ﻳﺤـﺚ آـﻞ‬
‫وﻗﺖ ﻋﻠﻲ ﺗﻨﻔﻴﺬ اﻷﻣﺮ‪ ،‬إذا اﻟﻤﺘﻐﻴﺮ ﻏﻴﺮ ﻣﻮﺟﻮد ‪.‬‬

‫ﻣﺘﻐﻴﺮ ﺑﺪﻳﻞ ﻋﻼﻣﺔ & اﻟﻤﻔﺮد‬

‫ﻋﻨﺪ ﻣﻼﺣﻈﺔ ‪ iSQL*Plus‬أن اﻟﺘﻌﺒﻴﺮ ‪ SQL‬ﻳﺤﺘﻮي ﻋﻠﻲ ﻋﻼﻣﺔ & أﻧـﺖ ﺗﺤـﺚ ﻋﻠـﻲ‬
‫إدﺧﺎل اﻟﻘﻴﻤﺔ ﻻﺳﻢ اﻟﻤﺘﻐﻴﺮ اﻟﺒﺪﻳﻞ ﻓﻲ اﻷﻣـﺮ ‪ .SQL‬ﺳـﻮف ﺗـﺪﺧﻞ اﻟﻘﻴﻤـﺔ ﻣـﺮة وﺗﻨﻘـﺮ‬
‫ﻋﻠﻲ زر ﺗﻨﻔﻴﺬ اﻟﻌﺮض وهﻮ رﻗﻢ )‪ (2‬أﻋﻠﻲ ﻓـﻲ اﻟـﺸﻜﻞ اﻟﻤﻌـﺮوض‪ ،‬اﻟﻨﺘـﺎﺋﺞ ﺗَﻌـﺮض ﻓـﻲ‬
‫ﻣﺴﺎﺣﺔ اﻟﻤﺨﺮﺟﺎت ﺑﺪورة ‪. SQL*Plus‬‬

‫ﺗﺤﺪﻳﺪ اﻟﺤﺮف وﻗﻴﻢ اﻟﺘﺎرﻳﺦ ﺑﻤﺘﻐﻴﺮات اﻟﺒﺪﻳﻞ‬

‫‘ ﻟﺘﺤﺪﻳﺪ اﻟﺤﺮف وﻗﻴﻢ اﻟﺘﺎرﻳﺦ‬ ‫اﺳﺘﺨﺪم ﻋﻼﻣﺎت ﺗﻘﺪﻳﺮ’‬
‫ﻣﻦ ﻓﻘﺮة ‪ ،WHERE‬ﻗﻴﻢ اﻟﺘﺎرﻳﺦ واﻟﺤﺮف ﻳﺠﺐ أن ﻳﻜﻮﻧﺎ ﻣﺮﻓﻘﻴﻦ ﺿﻤﻦ ﻋﻼﻣﺔ اﻟﺘﻘﺪﻳﺮ‬
‫‘ ﻧﻔﺲ اﻟﻘﺎﻋﺪة ﺗﻘﺪم ﻟﻤﺘﻐﻴﺮات اﻟﺒﺪﻳﻞِ ‪.‬‬ ‫’‬
‫‘ ﺿﻤﻦ ﺗﻌﺒﻴﺮ ‪ SQL‬ﻧﻔﺴﻪ ‪.‬‬ ‫أرﻓﻖ اﻟﻤﺘﻐﻴﺮ ﻓﻲ ﻋﻼﻣﺎت اﻟﺘﻘﺪﻳﺮ ’‬
‫ﻳﻈﻬﺮ ﻟﻨﺎ اﻻﺳﺘﻌﻼم آﻲ ﻳﺴﺘﺮﺟﻊ أﺳﻤﺎء اﻟﻤﻮﻇﻒ‪ ،‬رﻗﻢ اﻟﻘﺴﻢ‪ ،‬ورواﺗﺐ ﺳﻨﻮﻳﺔ ﻟﻜﻞ‬
‫اﻟﻤﻮﻇﻔﻴﻦ ﻣﺴﺘﻨﺪة ﻋﻠﻲ ﺗﺤﺪﻳﺪ اﻟﻌﻨﻮان اﻟﻮﻇﻴﻔﻲ ﻟﻤﺘﻐﻴﺮ اﻟﺒﺪﻳﻞ ﻓﻲ ‪iSQL* Plus‬‬
‫اﻟﻤﻼﺣﻈﺔ‪ :‬ﻳﻤﻜﻨﻚ أن ﺗﺴﺘﺨﺪم اﻟﺪوال ﻣﺜﻞ ‪ UPPER‬و ‪ LOWER‬ﻣﻊ ﻋﻼﻣﺔ &‪.‬‬
‫اﻻﺳﺘﺨﺪام )’‪ UPPER(’&job_title‬وذﻟﻚ ﻷن ﻟﻴﺲ ﻣﻦ ﺣﻖ اﻟﻤﺴﺘﺨﺪم أن ﻳﺪﺧﻞ‬
‫اﻟﻌﻨﻮان اﻟﻮﻇﻴﻔﻲ ﺑﺤﺮوف آﺒﻴﺮة‪.‬‬

‫ﺗﺤﺪﻳﺪ أﺳﻤﺎء اﻟﻌﻤﻮد ‪،‬اﻟﺘﻌﺒﻴﺮات‪ ،‬وﻧﺺ اﺳﺘﺨﺪام ﻣﺘﻐﻴﺮات اﻟﺒﺪﻳﻞ أن ﺗﻜﻤﻞ‬

‫اﻟﺘﺎﻟﻲ ‪:‬‬
‫‪ .1‬ﺷﺮط ‪WHERE‬‬
‫‪ .2‬ﻓﻘﺮة ‪ORDER BY‬‬
‫‪ .3‬ﺗﻌﺒﻴﺮات ﻋﻤﻮد‬
‫‪ .4‬أﺳﻤﺎء ﺟﺪاول‬
‫‪ .5‬ادﺧﻞ ﺗﻌﺒﻴﺮ ‪SELECT‬‬
‫ﻣﺘﻐﻴﺮات اﻟﺒﺪﻳﻞ ﻻ ﺗﺴﺘﺨﺪم ﻓﻘﻂ ﻣﻊ ﻓﻘﺮة ‪ WHERE‬ﻓﻲ ﺗﻌﺒﻴﺮ ‪ ،SQL‬ﻟﻜﻦ هﺬﻩ‬
‫اﻟﻤﺘﻐﻴﺮات ﻳﻤﻜﻦ أﻳﻀﺎ أن ﺗﺴﺘﺨﺪم ﻓﻲ اَﺳﺘﺒﺪال ﻷﺳﻤﺎء اﻟﻌﻤﻮد‪ ،‬ﺗﻌﺒﻴﺮات‪ ،‬أو ﻧﺺ ‪.‬‬
‫اﻟﻤﺜﺎل‪:‬أﻋﺮض رﻗﻢ اﻟﻤﻮﻇﻒ وأي ﻋﻤﻮد ﺁﺧﺮ وأي أﻣﺮ ﻟﻠﻤﻮﻇﻔﻴﻦ ‪.‬‬

‫إذا ﻟﻢ ﺗﺪﺧﻞ ﻗﻴﻤﺔ اﻟﻤﺘﻐﻴﺮة ﻟﻠﺒﺪﻳﻞ‪ ،‬ﺳﻮف ﺗﺤﺼﻞ ﻋﻠﻲ ﺧﻄﺄ ﻋﻨﺪﻣﺎ ﺗﻨﻔﺬ اﻟﺘﻌﺒﻴﺮ‬
‫اﻟﺴﺎﺑِﻖ ‪.‬‬
‫اﻟﻤﻼﺣﻈﺔ‪ :‬ﻣﺘﻐﻴﺮ اﻟﺒﺪﻳﻞ ﻳﻤﻜﻦ أن ﻳﺴﺘﺨﺪم ﻓﻲ أي ﻣﻜﺎن ﻓﻲ اﻷﻣﺮ ‪ ،SELECT‬ﻣﺎﻋﺪا‬
‫آﺎﻟﻜﻠﻤﺔ اﻷوﻟﻲ اﻟﻤﺪﺧﻠﺔ ﻓﻲ ﺳﺮﻋﺔ اﻷﻣﺮ ‪.‬‬
 ‫ﻳﻌﺮض اﻟﻤﺜﺎل رﻗﻢ اﻟﻤﻮﻇﻒ‪ ،‬أﺳﻢ‪ ،‬ﻋﻨﻮان وﻇﻴﻔﺔ‪ ،‬وأي ﻋﻤﻮد ﺁﺧﺮ ﺣﺪد ﻣﻦ ﻗﺒﻞ‬
‫اﻟﻤﺴﺘﺨﺪم ﻓﻲ وﻗﺖ اﻟﺘﺸﻐﻴﻞ‪ ،‬ﻣﻦ ﺟﺪول اﻟﻤﻮﻇﻔﻴﻦ‪ .‬أﻧﺖ ﻳُﻤﻜﻦ أن ﺗﺤﺪد اﻟﺸﺮط أﻳﻀﺎ‬
‫ﻻﺳﺘﺮﺟﺎع ﺻﻔﻮف وأﺳﻢ اﻟﻌﻤﻮد ﻣِﻦ ﻗﺒﻞ اﻟﺒﻴﺎﻧﺎت اﻟﻨﺎﺗﺠﺔ اﻟﺘﻲ ﻳﺠﺐ أن ﺗﺆﻣﺮ ‪.‬‬
‫ﺗﻌﺮﻳﻒ ﻣﺘﻐﻴﺮات اﻟﺒﺪﻳﻞ‬
‫* ﻳﻤﻜﻨﻚ ﺗﻌﺮﻳﻒ اﻟﻤﺘﻐﻴﺮات ﻓﻲ ‪ iSQL*Plus‬ﺑﺎﺳﺘﺨﺪام أﻣﺮ ‪.DEFINEE‬‬
‫إﻧﺸﺎء اﻟﻤﺘﻐﻴﺮ اﻟﻤﺴﺘﺨﺪم ﻣﻊ ﻧﻮع اﻟﺒﻴﺎﻧﺎت ‪.CHAR‬‬ ‫‪DEFINEE variable= Value‬‬
‫إذ اﺣﺘﺠﺖ أن ﺗﻌﺮف ﻣﺘﻐﻴﺮ ﻳﺘﻀﻤﻦ ﻓﺮاغ ‪ ، NULL‬ﻓﻴﺠﺐ أن ﺗﺮﻓﻖ اﻟﻘﻴﻤﺔ ﺿﻤﻦ ﻋﻼﻣﺔ‬
‫اﻟﺘﻘﺪﻳﺮ ‘ ‘ ﻋﻨﺪﻣﺎ ﺗﺴﺘﺨﺪم أﻣﺮ ‪.DEFINEE‬‬
‫* ﻣﺘﻐﻴﺮ ﻣﻌﺮف وﻳﻜﻮن ﻣﺘﻮﻓﺮ ﻟﻠﺪورة‪.‬‬
‫ﻳﻤﻜﻨﻚ ﺗﻌﺮﻳﻒ اﻟﻤﺘﻐﻴﺮات ﺑﺎﺳﺘﺨﺪام ﺗﻨﻔﻴﺬ ﺟﻤﻠﺔ اﻻﺳﺘﻌﻼم اﻟﺒﺴﻴﻂ ‪.‬‬
‫‪ iSQL* Plus‬ﻣﺰودة ﺑﺄﻣﺮ ‪ DEFINEE‬ﻟﺘﻌﺮﻳﻒ و وﺿﻊ ﻣﺘﻐﻴﺮات اﻟﺒﺪيﻟـ ‪:‬‬

‫اﻷﻣﺮ‬ ‫اﻟﻮﺻﻒ‬
‫‪DEFINEE variable = value‬‬ ‫إﻧـــﺸﺎء اﻟﻤﺘﻐﻴـــﺮ اﻟﻤـــﺴﺘﺨﺪم ﻣـــﻊ ﻧـــﻮع اﻟﺒﻴﺎﻧـــﺎت‬
‫‪CHAR‬‬
‫وﻳﺨﺼﺺ ﻗﻴﻢ إﻟﻴﻪ‬
‫‪DEFINEE variable‬‬ ‫ﻋﺮوض اﻟﻤﺘﻐﻴﺮ‪ ،‬ﻗﻴﻤﺘﻪ‪ ،‬وأﻧﻮاع ﺑﻴﺎﻧﺎﺗﻪ‬
‫‪DEFINEE‬‬ ‫ﻋﺮوض آﻞ ﻣﺘﻐﻴﺮات اﻟﻤﺴﺘﺨﺪم ﺑﻘِﻴﻤﻬﻢ‬
‫وﺑﻴﺎﻧﺎﺗﻬﻢ‬

‫أواﻣﺮ ‪DEFINE , UNDEFINE‬‬

‫* ﺗﻌﺮﻳﻒ ﺑﻘﺎﻳﺎ ﻣﺘﻐﻴﺮة ﺣﺘﻰ إﻧﻚ إﻣﺎ ‪:‬‬
‫‪ -‬ﺗﺴﺘﺨﺪم أﻣﺮ ‪ UNDEFINE‬أن ﻳﻮﺿﺤﺔ‬
‫‪ -‬ﺗﺨﺮج ﻣﻦ )ﺗﻐﻠﻘﻬﺎ( ‪iSQL*Plus‬‬
‫* ﻳﻤﻜﻨﻚ ﻣﻦ ﻣﻊ أﻣﺮ ‪.DEFINE‬‬

‫ﻋﻨﺪﻣﺎ ﻻ ﺗﺤﺪد اﻟﻤﺘﻐﻴﺮات‪ ،‬ﺣﻴﺚ أﻧﻚ ﻳﻤﻜﻦ أن ﺗﺤﻘﻴﻖ ﺗﻐﻴﻴﺮاﺗﻚ ﻣﻊ أﻣﺮ ‪.DEFINE‬‬
‫ﻋﻨﺪﻣﺎ ﺗﻐﻠﻖ ﻧﺎﻓﺬة ‪،iSQL*Plus‬اﻟﻤﺘﻐﻴﺮات اﻟﻤﺤﺪدة ﺧﻼل ﺗﻠﻚ اﻟﺪورة ﺗﻔﻘﺪ ‪.‬‬

‫اﺳﺘﺨﺪام أﻣﺮ ‪ DEFINE‬ﻣﻊ ﻣﺘﻐﻴﺮ ﺑﺪﻳﻞ ﻟﻠﻌﻼﻣﺔ &‬

‫*أﻧﺸﺊ ﻣﺘﻐﻴﺮ ﻣﻌﺪل ﻣﺴﺘﺨﺪم أﻣﺮ ‪:DEFINE‬‬
‫‪DEFINEE employee_num = 200‬‬
‫* اﺳﺘﺨﺪام ﻣﺘﻐﻴﺮ ﻗﺪم ﺑﻌﻼﻣﺔ & إِﻟﻲ اﻟﻘﻴﻤﺔ اﻟﺒﺪﻳﻞ ﻓﻲ ﺗﻌﺒﻴﺮ ‪SQL‬‬
‫‪SELECT employee_id, last_name, salary, department_id‬‬
‫‪FROM employees‬‬
‫; ‪WHERE employee_id = &employee_num‬‬

‫اﻟﻤﺜﺎل ﻋﻠﻲ ‪ iSQL*Plus‬إﻧﺸﺎء ﻣﺘﻐﻴﺮ ﺑﺪﻳﻞ ﻟـﺮﻗﻢ اﻟﻤﻮﻇـﻒ ﺑﻮاﺳـﻄﺔ اﻷﻣـﺮ ‪DEFINE‬‬
‫‪ ،‬و ﻋﺮوض وﻗﺖ اﻟﺘﺸﻐﻴﻞ ﻟﺮﻗﻢ اﻟﻤﻮﻇﻒ‪ ،‬أﺳﻢ اﻟﻤﻮﻇﻒ‪ ،‬راﺗﺐ اﻟﻤﻮﻇﻒ‪ ،‬رﻗـﻢ اﻟﻘـﺴﻢ‬
‫ﻟﺬﻟﻚ اﻟﻤﻮﻇﻒ ‪.‬‬
‫ﻷن اﻟﻤﺘﻐﻴﺮ أﻧﺸﺄ ﻣﺴﺘﺨﺪﻣﺎ اﻷﻣﺮ ‪ DEFINE‬ﻓﻲ ‪ ، iSQL*Plus‬اﻟﻤـﺴﺘﺨﺪم ﻻ ﻳﺤـﺚ‬
‫ﻋﻠﻲ إدﺧﺎل اﻟﻘﻴﻤﺔ ﻟﺮﻗﻢ اﻟﻤﻮﻇﻒ‪ .‬ﺑﺪﻻً ﻣﻦ‪ ،‬اﻟﻘﻴﻤﺔ اﻟﻤﺘﻐﻴﺮة اﻟﻤﻌﺮﻓﺔ ﺗـﺴﺘﺒﺪل ﺁﻟﻴـﺎً ﻓـﻲ‬
‫اﻟﺘﻌﺒﻴﺮ ‪.SELECT‬‬
‫رﻗﻢ اﻟﻤﻮﻇﻒ ﺑﺪﻳﻞ ﻣﺘﻐﻴﺮ ﺣﺎﺿﺮ ﻓﻲ اﻟﺪورة ِ ﺣﺘﻰ إذا آﺎن اﻟﻤﺴﺘﺨﺪم ﻏﻴﺮ ﻣﻌﺮف ﻓﻲ‬
‫اﻟﺪورة و ﺧﺮوﺟﻪ ﻣﻦ دورة ‪iSQL*Plus‬‬

‫اﺳﺘﺨﺪام اﻟﻤﺘﻐﻴﺮ اﻟﺒﺪﻳﻞ ﻟﻠﻌﻼﻣﺘﻴﻦ &&‬

‫اﺳﺘﺨﺪام ﻋﻼﻣﺘﺎن ﻣﻦ && ﻋﻨﺪﻣﺎ ﺗﺮﻳﺪ اﺳﺘﺨﺪام ﺛﺎﻧﻲ ﻗﻴﻤﺔ ﻣﺘﻐﻴﺮ ﺑﺪون ﺣﺚ‬
‫اﻟﻤﺴﺘﺨﺪم ﻋﻠﻲ آﻞ اﻟﻮﻗﺖ‪).‬ﻳﻘﻮم ﺑﺴﺆال اﻟﺴﺘﺨﺪم ﻋﻦ ﻗﻴﻤﺔ اﻟﻤﺘﻐﻴﺮ ﻓﻰ اﻟﻤﺮة اﻻوﻟﻰ‬
‫ﻟﻠﺘﻨﻔﻴﺬ ﻓﻘﻂ وﺑﻌﺪهﺎ ﻓﻰ ﺗﻨﻔﻴﺬات اﻟﺘﺎﻟﻴﺔ ﻳﻌﻤﻞ ﺗﻠﻘﺎﺋﻴﺎ ﻋﻠﻰ اﻟﻘﻴﻤﺔ اﻟﻤﺪﺧﻠﺔ ﻓﻰ اول ﻣﺮة‬
‫ﺑﺪون ﺳﺆال اﻟﻤﺴﺘﺨﺪم ﻣﺮة اﺧﺮى (‬

‫ﻳﻤﻜﻨﻚ ﻣﻦ اﺳﺘﺨﺪام ﻣﺘﻐﻴﺮ اﻟﺒﺪﻳﻞ ﻟﻠﺜﻨﺎﺋﻲ اﻟﻌﻼﻣﺔ ﻋﻼﻣﺘﺎن )&&( ﻋﻨﺪﻣﺎ ﺗﺮﻳﺪ أن‬
‫ﺗﺴﺘﻌﻤﻞ ﺛﺎﻧﻲ ﻗﻴﻤﺔ ﻣﻦ اﻟﻘﻴﻤﺔ اﻟﻤﺘﻐﻴﺮة ﺑﺪون ﺣﺚ اﻟﻤﺴﺘﺨﺪم آﻞ وﻗﺖ‪.‬‬
‫اﻟﻤﺴﺘﺨﺪم ﺳﻴﺮي اﻟﻘﻴﻤﺔ ﻣﺮة ﻓﻘﻂ‪ .‬ﻣﻦ اﻟﻤﺜﺎل ‪ ،‬اﻟﻤﺴﺘﺨﺪم ﻳﺴﺘﻌﻠﻢ آﻲ ﻳﻌﻄﻲ‬
‫ﻗﻴﻤﺔ اﻟﻤﺘﻐﻴﺮ ﻻﺳﻢ اﻟﻌﻤﻮد ﻣﺮة ﻓﻘﻂ‪.‬‬
‫ﺔ ﺟﻬﺰت ﻣِﻦ ﻗِﺒﻞ اﻟﻤﺴﺘﺨﺪم ) رﻗﻢ اﻟﻘﺴﻢ( ﺗﺴﺘﺨﺪم آﻠﺘﺎ ﻟﻠﻌﺮضِ وأواﻣﺮ‬‫اﻟﻘﻴﻤ ُ‬
‫اﻟﺒﻴﺎﻧﺎت ‪.‬‬
‫‪ ISQL*Plus‬ﻳﺨﺰن اﻟﻘﻴﻤﺔ اﻟﻤﺠﻬﺰة ﺑﺎﺳﺘﺨﺪام أﻣﺮ ‪DEFIN‬؛ هﻮ ﺳﻴﺴﺘﺨﺪﻣﻪ ﺛﺎﻧﻴﺔ‬
‫ﺣﻴﻨﻤﺎ ﺗﺴﺘﺮﺟﻊ اﻻﺳﻢ اﻟﻤﺘﻐﻴﺮ‪ .‬ﻣﺮة ﻣﻊ اﻟﻤﺴﺘﺨﺪم اﻟﻤﺘﻐﻴﺮ ﻓﻲ اﻟﻤﻜﺎن اﻟﺼﺤﻴﺢ‪،‬وهﻨﺎ‬
‫ﺳﻮف ﺗﺤﺘﺎج أن ﺗﺴﺘﺨﺪم أﻣﺮ ‪ UNDEFINE‬آﻲ ﺗﻠﻐﻴﻬﺎ‪.‬‬

‫اﺳﺘﺨﺪام اﻷﻣﺮ ‪) VERIFY‬ﺣﻘﻖ(‬

‫اﺳﺘﺨﺪام اﻷﻣﺮ ‪ VERIFY‬آﻲ ﺗﺜﺒﺖ اﻟﻌﺮض ﻋﻦ اﻟﻤﺘﻐﻴﺮ اﻟﺒﺪﻳﻞ ﻗﺒـﻞ وﺑﻌـﺪ ‪iSQL*Plus‬‬
‫ﺑﺪﻳﻼت ﻣﺘﻐﻴﺮات اﻟﺒﺪﻳﻞ ﻣﻊ اﻟﻘﻴﻢ ‪.‬‬
‫وهﻮ ﻳﻘﻮم ﺑﻌﻤﻠﻴﺔ ﻣﺘﺎﺑﻌﺔ ﺗﻐﻴﺮات ﻗﻴﻢ اﻟﻤﺘﻐﻴﺮات داﺧـﻞ اﻟﺘﻨﻔﻴـﺬ‪.‬وذﻟـﻚ ﻣﻔﻴـﺪ ﻓـﻰ ﻣﻌﺮﻓـﺔ‬
‫ﺳﻴﺮ اﻟﺒﺮﻧﺎﻣﺞ‪.‬‬

‫أن ﺗﺆآﺪ اﻟﺘﻐﻴﺮات ﻓﻲ ﺗﻌﺒﻴﺮ ‪ ،SQL‬اﺳﺘﺨﺪام أﻣﺮ ‪ VERIFY‬ﻓﻲ ‪iSQL*Plus‬‬

‫ﻣﺠﻤﻮﻋﺔ ‪ SET VERIFY‬ﺗﻘﻮي ﻣﻦ ‪ iSQL*Plus‬ﻟﻴﻌﺮض أﻣـﺮ ﻧـﺺ ﻗﺒـﻞ وﺑﻌـﺪﻩ آـﻲ‬
‫ﺗﺒﺪل ﻣﺘﻐﻴﺮات اﻟﺒﺪﻳﻞ ﻣﻊ اﻟﻘﻴﻢ‪.‬‬
‫اﻟﻤﺜﺎل ﻋﻠﻲ اﻟﻘﻴﻤﺔ اﻟﻘﺪﻳﻤﺔ وأﻳﻀﺎ اﻟﺠﺪﻳﺪة ﻟﻌﻤﻮد رﻗﻢ اﻟﻤﻮﻇﻒ ‪.‬‬
 ‫ﺣﻮل )ﺗﻔﺼﻴﻞ( ﺑﻴﺌﺔ ‪iSQL*Plus‬‬
‫* اﺳﺘﺨﺪام أواﻣﺮ ‪ SET‬آﻲ ﺗﺘﺤﻜﻢ ﻓﻲ اﻟﺪورة اﻟﺤﺎﻟﻴﺔ‪.‬‬
‫‪SET system_variable VALUE‬‬
‫* ﻳﺤﻘﻖ ﻣﺎ وﺿﻌﺘﻪ ﺟﺎﻧﺒﺎ ﺑﺎﺳﺘﺨﺪام أﻣﺮ ‪.SHO‬‬
 ‫‪Single row function‬‬

‫ﺳﻴﺘﻢ اﻟﺘﻌﺮف ﻓﻲ هﺬا اﻟﻔﺼﻞ إن ﺷﺎء اﷲ ﺗﻌﺎﻟﻲ ﻋﻠﻲ إﻣﻜﺎﻧﻴﺎت وآﻴﻔﻴﺔ اﺳﺘﺨﺪام ﺑﻌﺾ‬
‫‪. function‬‬

‫هﺪف اﻟﺪرسِ ‪:‬‬

‫اﻟﻘﺪرة ﻋﻠﻰ اﻟﺘﻌﺎﻣﻞ ﻣﻊ اﻷﻧﻮاع اﻟﻤﺘﻌﺪدة ﻣﻦ ‪ function‬اﻟﻤﺘﻮﻓﺮةِ ﻓﻲ ‪. SQL‬‬

‫هﻨﺎك ﻧﻮﻋﺎن ﻣﻦ ‪FUNCTION‬‬

‫‪1. SINGLE ROW FUNCTION .‬‬

‫‪2. MULTIPLE ROW FUNCTION.‬‬

‫‪:SINGLE ROW FUNCTION‬‬

‫وهﻲ ﺗﻌﻤﻞ ﻋﻠﻲ ﺑﻴﺎﻧﺎت اﻟﺼﻒ اﻟﻮاﺣﺪ اى اﻧﻨﺎ ﻧﻘﻮم ﺑﺎدﺧﺎل ﺻﻒ واﺣﺪ ﻣﻦ اﻟﺒﻴﺎﻧﺎت وﻧﻘﻮم‬
‫ﺑﻌﻤﻞ ﻋﻤﻠﻴﺔ ﻣﻌﻴﻨﺔ ﻋﻠﻴﺔ ﺛﻢ ﺗﻘﻮم ﺑﺎﺧﺮاج ﺻﻒ واﺣﺪ اﻳﻀﺎ‪.‬‬
‫وهﺬا ﺳﻮف ﻳَﻐﻄّﻲ ﻓﻲ هﺬا اﻟﻔﺼﻞ‪.‬‬

‫‪:MULTIPLE ROW FUNCTION‬‬

‫هﻲ ﺗﻌﻤﻞ ﻋﻠﻲ ﻋﺪة ﺻﻔﻮف ﻣﻌﺎ وﺗﻘﻮم ﺑﺈﺧﺮاج ﻧﺘﻴﺠﺔ واﺣﺪة ﻟﺘﻠﻚ اﻟﺼﻔﻮف‪.‬‬
‫وهﺬا ﺳﻮف ﻳَﻐﻄّﻲ ﻓﻲ اﻟﻔﺼﻞ اﻟﺨﺎﻣﺲ ‪.‬‬

‫‪:SINGLE ROW FUNCTION‬‬

‫‪ .1‬ﺗﺘﻌﺎﻣﻞ ﻣﻊ اﺟﺰاءَ ﻣﻦ اﻟﺒﻴﺎﻧﺎت‪.‬‬
‫‪َ .2‬ﻳﻌﻤﻞ ﻋﻠﻲ ارﺟﺎع ﻗﻴﻤﺔ واﺣﺪة ﻟﻜﻞ ﺻﻒ‪.‬‬
‫ل ﻓﻰ ﺷﻜﻞ ﻋﺮض اﻟﺒﻴﺎﻧﺎتَ ‪.‬‬ ‫‪ .3‬ﻳُﻌﺪّ ُ‬
‫ن ﻋﻤﻮدَ أو ﺗﻌﺒﻴﺮ‪.‬‬
‫ﻞ ) ‪ َ (argument‬اﻟﺘﻲ ﻳﻤﻜﻦ ان ﺗَﻜُﻮ َ‬ ‫‪ .4‬ﻳَﻘْﺒ ُ‬
 ‫اﻟﺸﻜﻞ اﻟﻌﺎم ﻟﻠﺼﻴﻐﺔ ‪:‬‬

‫‪ :function_name‬اﺳﻢ )‪ (function‬اﻟﻤﺴﺘﺨﺪﻣﺔ‪.‬‬
‫ن ﻳﻜﻮن أﺳﻢ ﻋﻤﻮدِ أو ﻗﻴﻤﺔ ‪.‬‬
‫ﻦ أَ ْ‬
‫‪ ( argument ): arg 1, arg 2‬هﺬا ﻳُﻤﻜ ُ‬
‫ﻣﻤﻴﺰاﺗﻬﺎ ‪:‬‬
‫‪ .1‬ﺗﻌﻤﻞ ﻋﻠﻲ اﺳﺘﺮﺟﺎع ﻟﻜﻞ ﺻﻒ ‪.‬‬
‫‪ .2‬اﺳﺘﺮﺟﺎع ﻧﺘﻴﺠﺔ واﺣﺪة ﺑﻮاﺳﻄﺔ اﻟﺼﻔﻮف‪.‬‬
‫‪ WHERE‬او ﻓﻰ‬ ‫• ‪ Single row function‬ﻳﻤﻜﻦ أَن ﺗﺴﺘﺨﺪم ﻓﻲ ﺟﻤﻠﺔ ‪ SELECT‬او‬
‫ﻓﻘﺮة ‪.ORDER BY‬‬

‫اﻟﺸﻜﻞ اﻟﺴﺎﺑﻖ ﻳﻮﺿﺢ اﻧﻮاع ‪. single row function‬‬

‫‪. CARACTER FUNCTION‬‬ ‫‪R‬‬ ‫اوﻻً ‪:‬‬

‫ﻳﻤﻜﻦ اﺳﺘﺨﺪام ‪ single row function‬ﻟﻠﺤﻔﺎظ ﻋﻠﻲ أﺳﻠﻮب اﻟﻜﺘﺎﺑﺔ‪.‬‬

‫ﻳﻤﻜﻦ اﺳﺘﺨﺪام ‪ single row function‬ﻟﻤﻌﺮﻓﺔ ﻃﻮل أو ﺣﺠﻢ اﻟﻜﻠﻤﺎت ‪.‬‬

‫اﻟﺪوال‬ ‫اﻟﻐﺮض‬
‫‪LOWER(column /‬‬
‫)‪expression‬‬
‫‪UPPER(column‬‬
‫)‪|expression‬‬
‫‪INITCAP(column‬‬
‫)‪|expression‬‬
‫‪CONCAT(column1|ex‬‬
‫‪pression1,‬‬
‫‪column2|expression2‬‬ ‫اﻟﻔﺎرق أن اﺳﺘﺨﺪاﻣﻬﺎ ﻻ ﻳﺴﻤﺢ ﺑﺎﻟﺘﻌﺎﻣﻞ ﻣﻊ أآﺜﺮ ﻣﻦ ﻋﻤﻮدﻳﻦ ‪.‬‬
‫)‬
‫| ‪SUBSTR(column‬‬
‫)]‪expression ,m [,n‬‬
‫واﻟﻤﻌﺎﻣﻞ ‪ n‬ﻳﺪل ﻋﻠﻲ ﻋﺪد اﻟﺤﺮوف اﻟﻤﻄﻠﻮب ان ﻳﺼﻞ اﻟﻴﻬﺎ ‪.‬‬
‫‪ m‬ﺑﺎﻟﺴﺎﻟﺐ ﻓﺎﻟﻌﺪ ﺳﻮف ﻳﺒﺪأ ﻣﻦ ﻧﻬﺎﻳﺔ اﻟﻜﻠﻤﺔ او اﻟﻌﻤﻮد‬
‫وﻟﻮ ‪ n‬ﻣﺤﺬوﻓﺔ ﻓﻬﺬا ﻳﻌﻨﻰ اﻧﺔ ﺳﻮف ﻳﺼﻞ اﻟﻰ اﺧﺮ ﺣﺮف‬
‫‪LENGTH(column‬‬
‫)‪|expression‬‬
‫| ‪INSTR(column‬‬
‫‪expression ,’string’ ,‬‬
‫) ]‪[,m], [n‬‬
‫‪LPAD(column‬‬
‫‪|expression , n,‬‬
‫)’‪’string‬‬
‫‪RPAD(column‬‬
‫‪|expression , n‬‬
‫)’‪,’string‬‬
‫| ‪TRIM( character‬‬
‫‪expression FROM‬‬
‫) ‪column‬‬
‫‪REPLACE(text ,‬‬
‫‪search_string‬‬
‫)‪,replacement_string‬‬
‫‪FUNCTION‬‬
‫)’‪1- LOWER(’SQLCourse‬‬
‫)’‪2-PPER(’SQLCourse‬‬
‫)’‪3-INITCAP(’SQL Course‬‬
‫ﺗﻘﻮم ﺑﺘﺤﻮﻳﻞ اﻟﺤﺮوف إﻟﻲ ﺣﺮوف ﺻﻐﻴﺮة ﺑﻐﺾ اﻟﻨﻈﺮ ﻋﻦ ﻃﺮﻳﻘﺔ‬
‫آﺘﺎﺑﺘﻬﺎ‪.‬‬
‫ﺗﻘﻮم ﺑﺘﺤﻮﻳﻞ اﻟﺤﺮوف إﻟﻲ ﺣﺮوف آﺒﻴﺮة ﺑﻐﺾ اﻟﻨﻈﺮ ﻋﻦ ﻃﺮﻳﻘﺔ‬
‫آﺘﺎﺑﺘﻬﺎ‪.‬‬
‫ﺗﻘﻮم ﺑﺘﺤﻮﻳﻞ اﻟﺤﺮف اﻷول ﻓﻘﻂ إﻟﻲ ﺣﺮف آﺒﻴﺮ وﺑﻘﻴﺔ اﻟﻜﻠﻤﺔ‬
‫ﺣﺮوف ﺻﻐﻴﺮة‪.‬‬
‫هﻲ ﺗﻘﻮم ﺑﻀﻢ ﻋﻤﻮدﻳﻦ أو آﻠﻤﺘﻴﻦ ﻓﻲ آﻠﻤﺔ واﺣﺪة وﻳﻼﺣﻆ‬
‫اﻧﻬﺎ ﻧﻔﺲ )‪ || (Concatenation‬اﻟﺘﻲ آﺎﻧﺖ ﻓﻲ اﻟﺒﺪاﻳﺔ ﻣﻊ‬
‫ﺗﻘﻮم ﺑﺄﺧﺬ ﺟﺰء ﻣﻦ ﺣﺮوف اﻟﻜﻠﻤﺔ أو اﻟﻌﻤﻮد اﻟﻤﺮاد اﺳﺘﺨﺪاﻣﻪ ‪.‬‬
‫ﻓﺎﻟﻤﻌﺎﻣﻞ ‪ m‬ﻳﺪل ﻋﻠﻲ ﻣﻮﻗﻊ اﻟﺤﺮف اﻟﺬي ﺳﻮف ﻧﺒﺪأ ﻣﻦ‬
‫ﻋﻨﺪﻩ‪.‬‬
‫ﻟﻮ‬
‫‪.‬‬
‫ﺑﺎﻟﻜﻠﻤﺔ او ﺑﺎﻟﻌﻤﻮد‪.‬‬
‫ﺗﻘﻮم ﺑﻌﺮض ﻋﺪد اﻟﺤﺮوف ﻟﻠﻌﻤﻮد او اﻟﻜﻠﻤﺔ‪.‬‬
‫ﺗﻘﻮم ﺑﺘﺤﺪﻳﺪ رﻗﻢ ﻣﻮﻗﻊ ﺣﺮف ﻣﻌﻴﻦ داﺧﻞ اﻟﻜﻠﻤﺔ او اﻟﻌﻤﻮد‪.‬‬
‫) ‪ (LEFT PAD‬وهﻲ ‪ LPAD‬ﺗﻘﻮم ﺑﻀﺒﻂ ﻋﺮض اﻟﻌﻤﻮد ﺑﺈزاﺣﺔ‬
‫اﻟﻜﻠﻤﺔ ﻣﻦ اﻟﻴﺴﺎر إﻟﻲ اﻟﻴﻤﻴﻦ‪.‬‬
‫ا) ‪ (RIGHT PAD‬وهﻲ ‪ RPAD‬ﺗﻘﻮم ﺑﻀﺒﻂ ﻋﺮض اﻟﻌﻤﻮد‬
‫ﺑﺈزاﺣﺔ اﻟﻜﻠﻤﺔ ﻣﻦ اﻟﻴﻤﻴﻦ إﻟﻲ اﻟﻴﺴﺎر‪.‬‬
‫ﺗﻘﻮم ﺑﺤﺬف ﺣﺮف ﻣﻌﻴﻦ ﻣﻦ آﻠﻤﺔ او ﻋﻤﻮد و ﻳﻈﻬﺮ اﻟﻨﺎﺗﺞ ﺑﻌﺪ‬
‫ذﻟﻚ وﻗﺪ ﺣﺬف ﻣﻨﻪ ﺗﻠﻚ اﻟﺤﺮف اﻟﻤﺤﺪد ‪.‬‬
‫ﻳﺒﺤﺚ ﻋﻠﻲ ﺣﺮف ﻣﻌﻴﻦ ﻣﻦ ﻣﺠﻤﻮﻋﺔ ﻣﻦ اﻟﺤﺮوف و ﻟﻮ وﺟﺪة‬
‫ﻳﻌﻤﻞ ﻟﻪ ﺗﻐﻴﻴﺮ ﺑﺎﻟﺤﺮف اﻟﻤﺮاد وﺿﻌﺔ ﺑﺪﻻ ﻣﻨﺔ ‪.‬‬
‫دوال ﻣﻌﺎﻟﺠﺔ اﻟﺤﺎﻟﺔ‬
‫اﻟﻨﺘﻴﺠﺔ‬ ‫اﻟﻮﺻﻒ‬
‫‪ -1‬ﺗﺤﻮﻳﻞ اﻟﺤﺮوف آﻠﻬﺎ‬
‫إﻟﻲ ﺣﺮوف ﺻﻐﻴﺮة‬
‫‪1- sqlcourse‬‬ ‫‪ -2‬ﺗﺤﻮﻳﻞ اﻟﺤﺮوف آﻠﻬﺎ‬
‫‪2-SQL COURSE‬‬ ‫إﻟﻲ ﺣﺮوف آﺒﻴﺮة‬
‫‪3-Sql Course‬‬ ‫‪ -3‬ﺗﺤﻮﻳﻞ أول ﺣﺮف ﻓﻘﻂ‬
‫إﻟﻲ ﺣﺮف آﺒﻴﺮ واﻟﺒﺎﻗﻲ‬
‫ﺣﺮوف ﺻﻐﻴﺮة‬
‫' ‪SELECT 'The job id for ' || UPPER(last_name) || ' is‬‬
‫"‪|| LOWER(job_id) AS "EMPLOYEE DETAILS‬‬
‫;‪FROM employees‬‬

‫ﻓﻲ اﻟﻤﺜﺎل اﻟﺴﺎﺑﻖ ﺗﻢ اﺳﺘﻌﺮاض اﻻﺳﻢ ﺑﺤﺮوف آﺒﻴﺮة و ﺑﺎﻟﺘﺎﻟﻲ ﻇﻬﺮ ‪ KING‬و‬
‫‪ KOCHHAR‬و ‪ HANN‬و ‪ HIGGINS‬و ‪ GITZ‬ﺑﺤﺮوف آﺒﻴﺮة ﻋﻜﺲ اﻷول ﻓﻜﺎﻧﺖ ﺗﺮي‬
‫‪ King‬أي اﻟﺤﺮف اﻷول آﺒﻴﺮ ﻓﻘﻂ و ‪ Kochhar‬و هﻜﺬا وﻟﻜﻦ ﺑﻌﺪ وﺿﻊ ‪UPPER‬‬
‫ﻗﺒﻞ اﺳﻢ اﻟﻌﻤﻮد ﺗﻢ ﺗﻐﻴﺮ اﻟﺤﺮوف آﻠﻬﺎ و أﺻﺒﺤﺖ ﺣﺮوف آﺒﻴﺮة )‪.(Capital‬‬
‫و ﻻﺣﻈﻨﺎ اﺳﺘﺨﺪام ‪ LOWER‬ﻗﺒﻞ اﺳﻢ ﻋﻤﻮد اﻟﻮﻇﻴﻔﺔ ﺗﻢ ﺗﻐﻴﺮ اﻟﺤﺮوف آﻠﻬﺎ و أﺻﺒﺤﺖ‬
‫ﺣﺮوف ﺻﻐﻴﺮة )‪.(Small‬‬
‫و ﻻﺣﻈﻨﺎ اﻳﻀﺎ اﺳﺘﺨﺪام )‪ (Concatenation‬ﻓﻘﺪ ﺗﻢ دﻣﺞ ﺟﻤﻠﺔ )‪(The job id for‬‬
‫ﻣﻊ ﻋﻤﻮد اﻻﺳﻤﺎء ﺛﻢ ﺑﻌﺪ ذﻟﻚ ﺗﻢ دﻣﺞ آﻤﻠﺔ )‪ (is‬ﻣﻊ ﻋﻤﻮد اﻟﻮﻇﻴﻔﺔ‪.‬‬

‫ﻣﻠﺤﻮﻇﺔ هﺎﻣﺔ‪ :‬ﻋﻨﺪﻣﺎ ﺗﺮﻳﺪ اﺿﺎﻓﺔ آﻠﻤﺔ او ﺟﻤﻠﺔ ﻋﻠﻰ ﻋﻤﻮد ﻣﻌﻴﻦ ﻳﺠﺐ وﺿﻌﻬﺎ‬
‫ﺑﻴﻦ )‪ (Single quotation‬آﻤﺎ ﺣﺪث ﻓﻰ اﻟﻤﺜﺎل اﻟﺴﺎﺑﻖ وﻗﺪ ﺗﻢ ﺗﺴﻤﻴﺔ ﺗﻠﻚ اﻟﻌﻤـﻮد ﺑﺎﺳـﻢ‬
‫ﻣﺴﺘﻌﺎر )‪ (Alias‬و اﺳﺘﺨﺪم )‪ (Dabble quotation‬ﻻن اﻻﺳﻢ اﻟﻤﺴﺘﻌﺎر اﻟـﺬى اﺧﺘـﺎرة آـﺎن‬
‫ﺑﺔ ﻣﺴﺎﻓﺔ‪.‬‬

‫ﻣﺜﺎل اﺧﺮ‪:‬‬

‫‪ select‬واﻟﻔﺮق ﺑﻴﻦ ‪ lower‬و ‪upper‬‬ ‫ﻧﺮى اﻟﻨﺎﺗﺞ ﻣﻦ ﺟﻤﻠﺔ‬

 ‫ﻓﻰ اﻟﻤﺜﺎل اﻟﺴﺎﺑﻖ ﻳﺮﻳﺪ ﻋﺮض رﻗﻢ اﻟﻤﻮﻇﻒ و اﻻﺳﻢ و رﻗﻢ اﻟﻘﺴﻢ ﻟﻠﻤﻮﻇﻒ ‪ .Higgins‬و‬
‫ﻻﺣﻈﻨﺎ اﻧﺔ ﻟﻢ ﻳﺠﺪ ﺗﻠﻚ اﻟﻤﻮﻇﻒ ﻣﻊ اﻧﺔ ﻣﻮﺟﻮد وهﺬا ﺑﺴﺒﺐ ان ذﻟﻚ‬
‫اﻟﻤﻮﻇﻒ ﻣﺴﺠﻞ ﺑـﺎﺣﺮف آﺒﻴـﺮة )‪ (Capital‬ﻓﻬﻨـﺎ ﻻﺑـﺪ ﻣـﻦ ﺗﺤﻮﻳـﻞ ﺗﻠـﻚ اﻻﺳـﻢ اﻟـﻰ اﺣـﺮف‬
‫ﺻﻐﻴﺮة )‪ (Small‬آﻤﺎ ﺗﻢ ﺗﻌﺪﻳﻞ ﺗﻠﻚ اﻟﻤﺜﺎل ﻓﻴﻤﺎ ﻳﻠﻰ‪.‬‬

‫‪SELECT employee_id, UPPER(last_name), department_id‬‬

‫‪FROM employees‬‬
‫;’‪WHERE INITCAP (last_name) = ’Higgins‬‬
‫ﻣﻼﺣﻈﺔ‪:‬‬
‫)‪ (INITCAP‬ﺗﺤﻮل اول ﺣﺮف اﻟﻰ ‪ capital‬واﻟﺒﺎﻗﻰ ﻳﻈﻞ ‪small‬‬

‫هﺬﻩ ‪ Function‬ﻟﻤﻌﺎﻟﺠﺔ ﻣﺠﻤﻮﻋﺔ اﻟﺤﺮوف‬

‫اﻟﺪوال‬ ‫اﻟﻨﺘﻴﺠﺔ‬ ‫اﻟﻮﺻﻒ‬

‫)’‪CONCAT(’Hello’,’World‬‬
‫)‪SUBSTR(’HelloWorld’,1,5‬‬
‫)’‪LENGTH(’HelloWorld‬‬
‫)’‪--INSTR(’HelloWorld’, ’W‬‬
‫)‪--INSTR(’HelloWorld’, ’o’,1,2‬‬
‫)’*’‪LPAD(salary,10,‬‬
‫)’‪RPAD(salary, 10, ’ #‬‬
‫)’‪TRIM(’H’ FROM’HelloWorld‬‬
‫‪HelloWorld‬‬ ‫ﺗﻘﻮم ﺑﻀﻢ ﻋﻤﻮدﻳﻦ أو ﻗﻴﻤﺘﻴﻦ ﻣﻌﺎ‬
‫‪Hello‬‬ ‫وهﻨﺎ ﺗﻘﻮم ﺑﻌﺮض ﺣﺮوف اﻟﻜﻠﻤﺔ ﻣﻦ‬
‫ﺑﺪاﻳﺔ اﻟﺤﺮف ‪ H‬ﺣﻴﺚ ذآﺮ رﻗﻢ ‪1‬‬
‫ﺣﺘﻰ اﻟﺤﺮف رﻗﻢ ‪5‬‬
‫‪--‬ﺗﻘﻮم ﺑﻌﺮض ﻋﺪد اﻟﺤﺮوف و ﻋﺪدهﻢ‬
‫‪10‬‬ ‫‪ 10‬ﺣﺮوف‪.‬‬
‫‪6‬‬ ‫‪--‬ﺗﻘﻮم ﺑﺘﺤﺪﻳﺪ ﻣﻮﻗﻊ ﺣﺮف ‪W‬‬
‫داﺧﻞ‬
‫اﻟﻜﻠﻤﺔ وهﻲ ﻣﻮﻗﻌﻬﺎ رﻗﻢ ‪.6‬‬
‫ﻧﻼﺣﻆ ﻓﻰ اﻟﻤﺜﺎل اﻟﺜﺎﻧﻰ اﻧﺔ‬ ‫•‬
‫ﻳﺮﻳــﺪ ﻣﻌﺮﻓــﺔ ﻣﻮﻗــﻊ ﺣــﺮف ) ‪(O‬‬
‫اﻟﺜﺎﻧﻰ وﻟﺬﻟﻚ اﺿﻔﻨﺎ ‪ 1‬ﺑﻤﻌﻨـﻰ اﻧـﺔ‬
‫ﻳﺘﺠﺎهﻞ اﻻول ﺛﻢ ﻳﺎﺧﺬ اﻟﺜﺎﻧﻰ‬
‫‪*****24000‬‬ ‫ﺗﻘﻮم ﺑﻤﺤﺎذاة اﻟﺒﻴﺎﻧﺎت ﺟﻬﺔ اﻟﻴﺴﺎر‬
‫ﺣﻴﺚ ﻳﺘﻢ ﻣﻠﺊ ﺣﺮف ﻣﻌﻴﻦ آﺎﻟﻨﺠﻤﺔ *‬
‫ﻣﺜﻼ وﺗﻜﻮن ﻳﺴﺎر اﻟﺒﻴﺎﻧﺎت‪.‬‬
‫‪24000#####‬‬ ‫ﺗﻘﻮم ﺑﻤﺤﺎذاة اﻟﺒﻴﺎﻧﺎت ﺟﻬﺔ اﻟﻴﻤﻴﻦ‬
‫ﺣﻴﺚ ﻳﺘﻢ ﻣﻠﺊ ﺣﺮف ﻣﻌﻴﻦ ﻣﺜﻼ ‪#‬‬
‫وﺗﻜﻮن ﻳﻤﻴﻦ اﻟﺒﻴﺎﻧﺎت‪.‬‬
‫‪elloWorld‬‬ ‫ﻳﻘﻮم ﺑﺤﺬف ﺣﺮف ‪ H‬ﻣﻦ اﻟﻜﻠﻤﺔ‪.‬‬

‫’‪LTRIM(salesman ,’sale‬‬ ‫‪man‬‬ ‫‪ sale‬ﻣﻦ اﻟﻜﻠﻤﺔ‬ ‫ﻳﻘﻮم ﺑﺤﺬف‬

‫)‬
‫‪RTRIM‬‬ ‫‪sales‬‬ ‫‪ man‬ﻣﻦ اﻟﻜﻠﻤﺔ‬ ‫ﻳﻘﻮم ﺑﺤﺬف‬
‫)’‪(salesman ,’man‬‬
 ‫اﻣﺜﻠﺔ اﺧﺮى ‪:‬‬

‫ﻣﻼﺣﻈﺔ‪:‬‬
‫اﻟﺠﺪول ) ‪ (DUAL‬هﻮ ﺟﺪول وهﻤﻰ ﺧﺎص ﻟﻠﻮراآﻞ ﻳﺴﺘﺨﺪم ﻻﺟﺮاء اﻟﻌﻤﻠﻴﺎت اﻟﺘﻰ ﻻ ﻳﺪﺧﻞ‬
‫ﻓﻴﻬﺎ اى ﺟﺪول ﻣﻦ داﺧﻞ ﻗﺎﻋﺪة اﻟﺒﻴﺎﻧﺎت ‪.‬‬
‫اﻟﻤﺜﺎل اﻟﺴﺎﺑﻖ ﻳﻌﺮض اﻷﺳﻤﺎء اﻷوﻟﻲ ﻣﻊ اﻷﺳﻤﺎء اﻷﺧﻴﺮة ﻋﻦ ﻃﺮﻳﻖ ‪ Concat‬رﺑﻄـﺎ ﻣﻌـﺎ‪،‬‬
‫وداﻟﺔ ‪ LENGTH‬ﻟﻸﺳﻤﺎء اﻷﺧﻴﺮة ﻟﻠﻤﻮﻇﻔﻴﻦ )أي ﻋﺪد اﻟﺤﺮوف ﻟﻼﺳﻢ اﻷﺧﻴﺮ(‪ .‬وﺗﺤﺪﻳـﺪ ﻣﻮﻗـﻊ‬
‫ﺣﺮف ‪.a‬و ذﻟﻚ ﻟﻠﻤﻮﻇﻔﻴﻦ اﻟﺬﻳﻦ ﻳﺤﺘﻮى اﺳﻢ وﻇﻴﻔـﺘﻬﻢ ﻣـﻦ اﻟﺤـﺮف اﻟﺮاﺑـﻊ اﻟـﻰ اﻻﺧـﺮ ﻋﻠـﻰ‬
‫اﻟﺤﺮوف اﻟﺘﺎﻟﻴﺔ )‪.(REP‬‬

‫‪SELECT employee_id, CONCAT(first_name, last_name) NAME,‬‬

‫"?’‪LENGTH (last_name), INSTR(last_name, ’a’) "Contains ’a‬‬
‫‪FROM employees‬‬
‫;’‪WHERE SUBSTR(last_name, -1, 1) = ’n‬‬

‫ﻓﻰ اﻟﻤﺜﺎل اﻟﺴﺎﺑﻖ ﻳﻘﻮم ﺑﻌﺮض رﻗﻢ اﻟﻤﻮﻇﻒ و ﻗﺎم ﺑﺪﻣﺞ اﻻﺳﻢ اﻻول ﻣﻊ اﻻﺳﻢ اﻻﺧﻴﺮ‬
‫واﻋﻄﻰ ﻟﻬﺬا اﻟﻌﻤﻮد اﺳﻢ ﻣﺴﺘﻌﺎر وهﻮ )‪ (NAME‬وﻗﺎم ﺑﺘﺤﺪﻳﺪ ﻋﺪد اﺣﺮف ‪LAST_NAME‬‬
‫وﺗﺤﺪﻳﺪ ﻣﻮﻗﻊ ﺣﺮف) ‪ ( a‬ﻣﻦ ‪.LAST_NAME‬‬
‫وذﻟﻚ ﻓﻘﻂ ﻟﻠﻤﻮﻇﻔﻴﻦ اﻟﺬﻳﻦ ﺗﻨﺘﻬﻰ اﺳﻤﺎﺋﻬﻢ ﺑﺤﺮف )‪. (n‬‬

‫ﺑﻌﺾ ‪ FUNCTION‬اﻟﺨﺎﺻﺔ ﺑﺎﻻرﻗﺎم و اﻳﻀﺎ ﺑﺎﻟﺘﻮارﻳﺦ‬

‫‪ROUND‬‬
‫ﺗﺴﺘﺨﺪم ﻟﺘﻘﺮﻳﺐ اﻷرﻗﺎم اﻟﻌﺸﺮﻳﺔ‬
‫‪EXAMPLE‬‬

‫)‪ROUND (45.926, 2‬‬ ‫‪45.93‬‬

‫هﻨﺎ ﺗﻢ اﻟﺘﻘﺮﻳﺐ إﻟﻲ رﻗﻤﻴﻦ ﻋﺸﺮي آﻤﺎ ﺣﺪدﻧﺎ ﻟﺔ ﻓﻰ اﻟﻤﺜﺎل‪.‬‬

‫‪TRUNC‬‬
‫ﺗﻘﻮم ﺑﺎﺧﺘﺼﺎر اﻟﺮﻗﻢ اﻟﻌﺸﺮي ﺑﺪون ﺗﻘﺮﻳﺐ‬
‫‪EXAMPLE‬‬

‫)‪TRUNC (45.926, 2‬‬ ‫‪45.92‬‬

‫ﻳﻜﺘﺐ اﻟﺮﻗﻢ اﻟﻤﺮاد اﺧﺘﺼﺎرﻩ ﺛﻢ ﻋﺪد اﻷرﻗﺎم اﻟﻌﺸﺮﻳﺔ اﻟﺘﻲ ﺗﺮﻳﺪ ان ﺗﻈﻬﺮ ﺑﺪون ﺗﻘﺮﻳﺐ‪.‬‬
‫)ﻣﻠﺤﻮﻇﺔ ﻻﺣﻈﺎﻟﻔﺮق ﺑﻴﻦ ‪ TRUNC‬وﺑﻴﻦ ‪( ROUND‬‬
 ‫‪MOD‬‬
‫ﺗﻘﻮم ﺑﻘﺴﻤﺔ رﻗﻢ ﻋﻠﻲ رﻗﻢ ﺁﺧﺮ و ﺗﻨﺘﺞ ﻟﻨﺎ ﻓﺎرق اﻟﻘﺴﻤﺔ ان وﺟﺪ‬

‫‪EXAMPLE‬‬

‫)‪MOD (1600, 300‬‬ ‫‪100‬‬

‫وهﻨﺎ ‪ 5 = 300 / 1600‬واﻟﺒﺎﻗﻲ ‪ 100‬واﻟﻤﻄﻠﻮب هﻨﺎ هﻮ اﻟﺒﺎﻗﻲ ﻓﻘﻂ ‪.100‬‬

‫‪EXAMPLE 2‬‬

‫)‪MOD (1500, 300‬‬ ‫‪0‬‬

‫وهﻨﺎ ‪ 5 = 300 / 1500‬وﻻ ﻳﻮﺟﺪ ﺑﺎﻗﻲ‪ .‬وﺑﺎﻟﺘﺎﻟﻰ اﻟﻨﺎﺗﺞ ﻳﻜﻮن ‪0‬‬

‫اﻟﺪاﻟﺔ‬ ‫اﻟﻐﺮض‬
‫)‪ROUND (column |expression , n‬‬ ‫ﺗﻘﺮب اﻷرﻗﺎم اﻟﻌﺸﺮﻳﺔ ‪.‬‬
‫وﻟﻮ ‪ n‬ﺣﺬﻓﺖ ﺗﻌﻨﻰ ان اﻟﺮﻗﻢ ﻳﻈﻬﺮ ﻣﻦ‬
‫ﻏﻴﺮ آﺴﻮر‪.‬‬
‫وﻟﻮ ‪ n‬ﺑﺎﻟﺴﺎﻟﺐ‪:‬‬
‫اﻟﺮﻗﻢ اﻟﺬي ﻋﻠﻲ ﻳﺴﺎر ﻧﻘﻄﺔ اﻟﻌﻼﻣﺔ‬
‫اﻟﻌﺸﺮﻳﺔ هﻮ اﻟﺬى ﻳﻘﺮب‪.‬‬
‫)‪TRUNC (column |expression ,n‬‬ ‫ﺗﻘﻮم ﺑﺎﺧﺘﺼﺎر اﻟﺮﻗﻢ اﻟﻌﺸﺮي‬
‫ﻟﻮ ‪ n‬ﻣﺤﺬوﻓﺔ ﻳﻜﻮن اﻟﻌﺮض ل ‪ n‬ﺑﺼﻔﺮ‬
‫أي ﻳﻜﺘﺐ اﻟﺮﻗﻢ ﻓﻘﻂ ﻣﻦ ﻏﻴﺮ آﺴﻮر‪.‬‬
‫)‪MOD (m , n‬‬ ‫ﺗﺤﺴﺐ ﻗﻴﻤﺔ اﻟﻤﺘﺒﻘﻴﺔ ﻣﻦ ﻗﺴﻤﺔ رﻗﻢ‬
‫ﻋﻠﻲ ﺁﺧﺮ‪.‬‬

‫اﺳﺘﺨﺪام ‪ROUND‬‬

‫ﻻﺣﻆ ﻓﻰ اﻟﻤﺜﺎل اﻟﺴﺎﺑﻖ )‪ ROUND(45.923,-1‬آﺎن اﻟﻨﺎﺗﺞ ‪ 50‬ﺣﻴﺚ اﻧﺔ ﺗﻢ اﻟﺘﻘﺮﻳﺐ ﻣﻦ‬

‫‪ 5‬وﺑﺎﻟﺘﺎﻟﻰ اﺻﺒﺢ اﻟﺮﻗﻢ‬ ‫‪0‬و ‪4‬‬ ‫ﺑﻌﺪ اﻟﻌﻼﻣﺔ اﻟﻌﺸﺮﻳﺔ ﻓﺎﺻﺒﺤﺖ ‪5‬‬
‫‪. 50‬‬

‫اﺳﺘﺨﺪام ‪TRUNC‬‬
 ‫ﻧﻼﺣﻆ هﻨﺎ ﻓﻰ ‪ TRUNC‬اﻧﻬﺎ ﺗﻘﻮم ﺑﺎﺧﺘﺼﺎر اﻟﺮﻗﻢ اﻟﻌﺸﺮي ﺑﺪون ﺗﻘﺮﻳﺐ ﻟﺔ‪.‬‬

‫‪MOD‬‬ ‫اﺳﺘﺨﺪام‬

‫اﺣﺴﺐ اﻟﺒﺎﻗﻲ ﻣﻦ اﻟﻤﺮﺗﺐ ﺑﻌﺪ ﻗﺴﻤﺘﻪ ﻋﻠﻲ ‪ 5000‬ﻟﻜﻞ ﻣﻮﻇﻒ وﻇﻴﻔﺘﺔ ﻣﻨﺪوب ﻣﺒﻴﻌﺎت ‪.‬‬

‫داﻟﺔ ‪ MOD‬ﺗﻘﻮم ﺑﺤﺴﺎب ﺑﺎﻗﻲ اﻟﻘﺴﻤﺔ‪.‬‬

‫اﻟﻤﺜﺎل اﻟﺴﺎﺑﻖ ﻳﻌﺮض اﻟﺒﺎﻗﻲ ﻣﻦ ﻗﺴﻤﺔ اﻟﻤﺮﺗﺐ ﻋﻠﻲ ‪ 5000‬ﻟﻜﻞ ﻣﻮﻇﻒ واﻟﺬي ﺗﻜﻮن‬
‫وﻇﻴﻔﺘﻪ ﻣﻨﺪوب ﻣﺒﻴﻌﺎت ‪.‬‬

‫أﻧﺖ ﻳﻤﻜﻦ أَن ﺗﻐﻴﺮ ﻋﺮض اﻟﺘﺎرﻳﺦ ﺑﺘﻨﻔﻴﺬ اﻷﻣﺮ ‪:‬‬

‫;’‪ALTER SESSION SET NLS_DATE_FORMAT = ’date format model‬‬

‫اﻟﻌﻤﻞ ﺑﺎﻟﺘﻮارﻳﺦ‬
‫ﻗﺎﻋﺪة ﺑﻴﺎﻧﺎت ‪ ORACLE‬ﺗﺨﺰن ﺗﻮارﻳﺦ ﻓﻲ ﺻﻴﻐﺔ أﻋﺪاد داﺧﻠﻴﺔ ‪:‬‬ ‫•‬
‫ﻗﺮن‪ ،‬ﺳﻨﺔ‪ ،‬ﺷﻬﺮ‪ ،‬ﻳﻮم‪ ،‬ﺳﺎﻋﺎت‪ ،‬اﻟﺪّﻗﺎﺋﻖ‪ ،‬ﺛﻮاﻧﻲ ‪.‬‬
‫ﺻﻴﻐﺔ ﻋﺮضِ اﻟﺘﺎرﻳﺦ اﻟﻤﺨﺘﺎرة‬ ‫•‬
‫‪DD-MON-RR.‬‬
‫ﻳﺴﻤﺢ ﻟﻚ أَن ﺗﺨﺰن ﺑﻴﺎﻧﺎت اﻟﻘﺮن ‪ 21‬ﻓﻲ اﻟﻘﺮن ‪ 20‬ﺑﺘﺤﺪﻳﺪ ﻓﻘﻂ اﻟﺮﻗﻤﺎن اﻷﺧﻴﺮان ﻣﻦ‬
‫اﻟﺴﻨﺔ ‪.‬‬
 ‫‪-‬‬
‫داﻟﺔ اﻟﻘﻴﻤﺔ اﻟﻤﻄﻠﻘﺔ ‪ABS Function‬‬

‫ﺗﺴﺘﺨﺪم هﺬﻩ اﻟﺪاﻟﺔ ﻹﻳﺠﺎد اﻟﻘﻴﻤﺔ اﻟﻤﻄﻠﻘﺔ ﻟﺮﻗﻢ ﻣﻌﻴﻦ وﻏﺎﻟﺒﺎ ﻳﺘﻢ اﺳﺘﺨﺪان هﺬﻩ اﻟﺪاﻟﺔ ﻣﻊ ﺟﻤﻞ أﺧﺮى‬
‫اﻟﺸﻜﻞ اﻟﻌﺎم‬

‫)‪ABS (COL|VALUE‬‬
‫ﺣﻴﺚ أن‬

‫اﺳﻢ اﻟﺤﻘﻞ أو اﻟﻌﻤﻮد‬ ‫‪COL‬‬

‫اﻟﻘﻴﻤﺔ اﻟﺒﺪﻳﻠﺔ ﻟﻠﻌﻤﻮد )اﻟﺒﻴﺎﻧﺎت(‬ ‫‪VALUE‬‬
‫ﻣﺜﺎل‬
‫; ‪SELECT ename, job, and hiredate-sysdate FROM EMP‬‬

‫;‪SELECT ename, job, ABS (hiredate-sysdate) FROM EMP‬‬

‫‪ -‬اﻟﺪاﻟﺔ اﻷﺳﻴﺔ ‪POWER Function‬‬

‫ﺗﺴﺘﺨﺪم هﺬﻩ اﻟﺪاﻟﺔ ﻹﻳﺠﺎد ﻗﻴﻤﺔ رﻗﻢ ﻣﺮﻓﻮع ﻷس‬

‫اﻟﺸﻜﻞ اﻟﻌﺎم‬

‫)‪POWER (COL|VALUE,P‬‬

‫ﺣﻴﺚ أن‬

‫اﺳﻢ اﻟﺤﻘﻞ أو اﻟﻌﻤﻮد‬ ‫‪COL‬‬

‫اﻟﻘﻴﻤﺔ اﻟﺒﺪﻳﻠﺔ ﻟﻠﻌﻤﻮد )اﻟﺒﻴﺎﻧﺎت(‬ ‫‪VALUE‬‬
‫ﻗﻴﻤﺔ اﻷس‬ ‫‪P‬‬
‫ﻣﺜﺎل‬
‫‪SELECT ENAME, SAL, POWER (SAL, 2) FROM EMP‬‬
 ‫‪-‬‬
‫داﻟﺔ اﻟﺠﺬر اﻟﺘﺮﺑﻴﻌﻲ ‪SQRT Function‬‬

‫ﺗﺴﺘﺨﺪم هﺬﻩ اﻟﺪاﻟﺔ ﻹﻳﺎد اﻟﺠﺬر اﻟﺘﺮﺑﻴﻌﻲ ﻟﺮﻗﻢ ﻣﻌﻴﻦ‬

‫اﻟﺸﻜﻞ اﻟﻌﺎم‬

‫)‪SQRT (COL|VALUE‬‬

‫ﺣﻴﺚ أن‬

‫اﺳﻢ اﻟﺤﻘﻞ أو اﻟﻌﻤﻮد‬ ‫‪COL‬‬

‫اﻟﻘﻴﻤﺔ اﻟﺒﺪﻳﻠﺔ ﻟﻠﻌﻤﻮد )اﻟﺒﻴﺎﻧﺎت(‬ ‫‪VALUE‬‬
‫ﻣﺜﺎل‬

‫‪SELECT ENAME, SAL, SQRT (SAL) FROM EMP‬‬

‫داﻟﺔ اﻹﺷﺎرة ‪SIGN Function‬‬

‫ﺗﺴﺘﺨﺪم هﺬﻩ اﻟﺪااة ﺑﻔﺤﺺ إﺷﺎرة اﻟﺮﻗﻢ ﻓ ﺈذا آﺎﻧ ﺖ اﻹﺷ ﺎؤة ﻣﻮﺟﺒ ﺔ ﺗﻌ ﻮد ﺑﺎﻟﻘﻴﻤ ﺔ )‪ (1‬أﻣ ﺎ اذا آﺎﻧ ﺖ اﻹﺷ ﺎرة ﺳ ﺎﻟﺒﺔ ﻓﺘﻌ ﻮد‬
‫ﺑﺎﻟﻘﻴﻤﺔ )‪(-1‬‬

‫اﻟﺸﻜﻞ اﻟﻌﺎم اﻧﻈﺮ اﻟﻤﺜﺎل اﻟﺘﺎﻟﻲ ‪:‬‬

‫‪SELECT ENAME, SAL, SIGN (SAL) FROM EMP‬‬
 ‫اﻟﻌﻤﻞ ﺑﺎﻟﺘﻮارﻳﺦِ‬
‫‪EXAMPLE‬‬

‫‪ SYSDATE‬ﻓﻰ اﻟﻤﺜﺎل اﻟﺴﺎﺑﻖ ﺗﻌﻨﻰ ﺗﺎرﻳﺦ اﻟﻴﻮم وﺗﺄﺗﻰ ﺑﺔ ﻣﻦ ﻋﻠﻰ ‪.SERVER‬‬

‫اﻟﺤﺴﺎب ﺑﺎﻟﺘﻮارﻳﺦِ‬

‫اﻟﻮﺻﻒ‬ ‫ﻧﺘﻴﺠﺔِ‬ ‫اﻟﻤﻌﺎﻣﻞ‬

‫ﻳﻀﻴﻒ ﻋﺪد ﻣﻦ اﻷﻳﺎمِ ﻋﻠﻰ ﺗﺎرﻳﺦ‬ ‫ﺗﺎرﻳﺦ‬ ‫ﺗﺎرﻳﺦ ‪ +‬رﻗﻢ‬
‫ﻳﻄﺮح ﻋﺪد اﻷﻳﺎمِ ﻣﻦ ﺗﺎرﻳﺦ‬ ‫ﺗﺎرﻳﺦ‬ ‫ﺗﺎرﻳﺦ – رﻗﻢ‬
‫ﻋﺪد ﻣﻦ‬
‫ﻳﻄﺮح ﺗﺎرﻳﺦ واﺣﺪ ﻣﻦ اﻵﺧﺮِ‬ ‫ﺗﺎرﻳﺦ ‪ -‬ﺗﺎرﻳﺦ‬
‫اﻷﻳﺎم‬
‫ﻳﻀﻴﻒ ﻋﺪد ﻣﻦ اﻟﺴّﺎﻋﺎت ﻋﻠﻰ ﺗﺎرﻳﺦ‬ ‫ﺗﺎرﻳﺦ‬ ‫ﺗﺎرﻳﺦ ‪ +‬رﻗﻢ‪24/‬‬

‫اﺳﺘﺨﺪام اﻟﻤﻌﺎﻣﻼت اﻟﺤﺴﺎﺑﻴﺔ ﺑﺎﻟﺘﻮارﻳﺦِ‬

‫‪SYSDATE‬‬ ‫‪ HIRE_DATE‬واﻟﺘﺎرﻳﺦ اﻟﺤﺎﻟﻲ‬ ‫ﻣﻠﺤﻮﻇﺔ ﺗﺎرﻳﺦ اﻟﺘﻌﻴﻦ‬

‫اﻟﻤﺜــﺎل اﻟــﺴﺎﺑﻖ ﻳﻌــﺮض اﻻﺳــﻢ وﻋــﺪدِ اﻷﺳــﺎﺑﻴﻊ ﻟﻠﻤــﻮﻇﻔﻴﻦِ ﻋــﻦ ﻃﺮﻳــﻖ ﻃــﺮح ﺗــﺎرﻳﺦ اﻟﻴــﻮم‬
‫اﻟﺤﺎﻟﻰ) ‪ (SYSDATE‬ﻣﻦ ﺗﺎرﻳﺦ ﺗﻌﻴﻦ اﻟﻤﻮﻇﻒ ) ‪ (HIRE_DATE‬وﻳﻘﺴﻢ اﻟﻨﺎﺗﺞ ﻋﻠﻰ ‪ 7‬ﺣﺘـﻰ‬
‫ﻳﻈﻬﺮ اﻟﻨﺎﺗﺞ ﺑﺎﻻﺳﺎﺑﻴﻊ ‪.‬‬

‫اﻟﻤﻼﺣﻈﺔ‪ SYSDATE :‬ﺗﺴﺘﺮﺟﻊ اﻟﺘﺎرﻳﺦ اﻟﺤﺎﻟﻲ ‪.‬‬

‫ﺑﻌﺾ ‪ FUNCTION‬اﻟﻤﺴﺘﺨﺪﻣﺔ ﻓﻰ اﻟﻌﻤﻠﻴﺎت اﻟﺤﺴﺎﺑﻴﺔ ﻋﻠﻰ اﻟﺘﺎرﻳﺦ‬

‫‪FUNCTION‬‬ ‫اﻟﻮﺻﻒ‬
‫‪MONTHS_BETWEEN‬‬ ‫ﻟﺤﺴﺎب ﻓﺮق ﻋﺪد اﻟﺸﻬﻮر ﺑﻴﻦ ﺗﺎرﻳﺨﻴﻴﻦ‬
‫‪ADD_MONTHS‬‬ ‫ﺗﺴﺘﺨﺪم ﻷﺿﺎﻓﻪ ﻋﺪد ﻣﺤﺪد ﻣﻦ اﻟﺸﻬﻮر‬
‫إﻟﻲ اﻟﺘﺎرﻳﺦ اﻟﻤﺤﺪد‬
‫‪NEXT_DAY‬‬ ‫ﻟﺘﺤﺪﻳﺪ اﻟﺘﺎرﻳﺦ اﻟﺘﺎﻟﻲ ﻟﻠﻴﻮم اﻟﻤﺤﺪد‬
‫‪LAST_DAY‬‬ ‫ﻟﻤﻌﺮﻓﺔ اﻟﻴﻮم اﻷﺧﻴﺮ ﻓﻲ ﺷﻬﺮ ﻣﻌﻴﻦ‬
‫‪ROUND‬‬ ‫ﻟﺘﻘﺮﻳﺐ اﻟﺘﺎرﻳﺦ‬
‫أي ﻋﺮض اﻗﺮب ﺑﺪاﻳﺔ ﺷﻬﺮ أو ﺳﻨﻪ ﻟﺘﺎرﻳﺦ‬
‫ﻣﻌﻴﻦ ﺗﺤﺪدﻩ‬
‫‪TRUNC‬‬ ‫ﺗﻘﻮم ﺑﺈﻋﺎدة اﻟﺘﺎرﻳﺦ إﻟﻲ اﻟﺒﺪاﻳﺔ‬
‫أي ﺗﻌﺮض ﺗﺎرﻳﺦ أول ﻳﻮم ﻓﻲ ﺷﻬﺮ أو ﺳﻨﺔ‬
‫ﻟﺘﺎرﻳﺦ ﻣﻌﻴﻦ ﺗﺤﺪدﻩ‬

‫‪1-MONTHS_BETWEEN (date1, date2) :‬‬

‫‪ -1‬ﻳﺤﺪد ﻋﺪد اﻟﺸﻬﻮرِ ﺑﻴﻦ اﻟﺘﺎرﻳﺦ اﻻول واﻟﺘﺎرﻳﺦ اﻟﺜﺎﻧﻰ واﻟﻨﺘﻴﺠﺔ ﻳﻤﻜﻦ أَن ﺗﻜﻮن ﻣﻮﺟﺒﺔ أو‬
‫ﺳﻠﺒﻴﺔ‪.‬‬
‫)‪2-ADD_MONTHS (date, n‬‬

‫‪ n‬ﻳﺠِﺐ أن ﺗﻜﻮن ﻋﺪد ﺻﺤﻴﺢ وﻳﻤﻜﻦ‬ ‫‪ n‬ﻣﻦ اﻷﺷﻬﺮ ﻟﻠﺘﺎرﻳﺦ اﻟﻤﺤﺪد‪ .‬ﻗﻴﻤﺔ‬ ‫‪ -2‬إﺿﺎﻓﺔ ﻋﺪد‬
‫أَن ﻳﻜﻮن ﺳﺎﻟﺐ ‪.‬‬
‫)'‪3-NEXT_DAY (date, 'char‬‬

‫‪ -3‬إﻳﺠﺎد اﻟﺘﺎرﻳﺦ ﻟﻠﻴﻮمِ اﻟﻤﺤﺪد ﻓﻰ اﻷﺳﺒﻮعِ اﻟﺘﺎﻟﻰ‪.‬‬

‫)'‪ :('char‬وﺗﻌﻨﻰ اﺳﻢ اﻟﻴﻮم ﻓﻰ اﻻﺳﺒﻮع ‪.‬‬
‫)‪4-LAST_DAY (date‬‬
‫‪ -4‬إﻳﺠﺎد اﻟﺘﺎرﻳﺦ ﻟﻠﻴﻮم اﻷﺧﻴﺮ ﻓﻲ ﺷﻬﺮ ﻣﻌﻴﻦ ‪.‬‬
‫)]'‪5-ROUND (date[,'fmt‬‬
‫‪ fmt‬اى )ﺷﻬﺮ او ﺳﻨﺔ(‪.‬‬ ‫‪ -5‬ﻳﺴﺘﺮﺟﻊ اﻟﺘﺎرﻳﺦ اﻟﻤﻘﺮب إِﻟﻲ اﻟﻮﺣﺪةِ اﻟﻤﺤﺪدة ﻓﻰ‬
‫‪ fmt‬ﺣﺬﻓﺖ‪ ،‬اﻟﺘﺎرﻳﺦ ﺳﻮف ﻳﻘﺮب إِﻟﻲ اﻟﻴﻮمِ اﻷﻗﺮبِ ‪.‬‬ ‫إذا‬
‫)]'‪6-TRUNC (date[, 'fmt‬‬
‫‪ -6‬ﻳﺴﺘﺮﺟﻊ ﺗﺎرﻳﺦ أول ﻳﻮم ﻓﻲ اﻟﺸﻬﺮ أو اﻟﺴﻨﺔ ﻟﺘﺎرﻳﺦ ﻣﻌﻴﻦ ‪.‬‬

‫‪EXAMPLES:‬‬

‫واﻟﻤﺜﺎل اﻟﺘﺎﻟﻲ ﻳﻌﺮض رﻗﻢ اﻟﻤﻮﻇﻒ ‪ ،‬ﺗﺎرﻳﺦ اﻟﺘﻌﻴﻦِ‪ ،‬ﻋﺪد ﺷﻬﻮر اﻟﺘﻮﻇﻴﻒ‪ ،‬وﻳـﺘﻢ اﺿـﺎﻓﺔ ﺳـﺘﺔ‬
‫ﺷﻬﻮر ﻟﺘﺎرﻳﺦ اﻟﺘﻌﻴﻴﻦ وﺳﻤﻰ ‪ ،REVIEW‬وﻣﻌﺮﻓـﺔ اﻟﺠﻤﻌـﺔ اﻷوﻟـﻲ ﺑﻌـﺪ ﺗـﺎرﻳﺦ اﻟﺘﻌﻴـﻴﻦ أي‬
‫ﺗﺤﺪﻳﺪ ﺗﺎرﻳﺦ أول ﻳﻮم اﻟﺠﻤﻌﺔ ﻳﻠﻲ ﺗﺎرﻳﺦ اﻟﺘﻌﻴـﻴﻦ واﻟﻨـﺎﺗﺞ ﻳﻮﺿـﺢ ﻟﻨـﺎ اﻟﺘـﺎرﻳﺦ اﻟﻤﻮاﻓـﻖ ﻷول ﻳـﻮم‬
‫اﻟﺠﻤﻌﺔ وﻳﻠﻴﻪ ﺗﺎرﻳﺦ اﻟﺘﻌﻴﻴﻦ ﻟﻜﻞ ﻣﻮﻇﻒ ‪ ،‬واﻟﻴﻮم اﻷﺧﻴﺮ ﻣﻦ ﺷﻬﺮِ اﻟﺘﻌﻴﻴﻦ )أي اﻟﻤﻄﻠﻮب ﻣﻌﺮﻓـﺔ‬
‫اﻟﻴﻮم اﻷﺧﻴﺮ ﻓﻲ اﻟﺸﻬﺮ وهﻨﺎ ﻓﻲ اﻟﻤﺜﺎل ﻳﺤﺪد اﻟﻴﻮم اﻷﺧﻴـﺮ ﻓـﻲ ﺷـﻬﺮ اﻟﺘﻌﻴـﻴﻦ واﻟﻨـﺎﺗﺞ ﻳﻮﺿـﺢ‬
‫هﺬا ﺣﻴﺚ ﻳﻌﺮض ﺁﺧﺮ ﻳﻮم ﻓﻲ اﻟﺸﻬﺮ( ﻣﻊ آﻞ اﻟﻤـﻮﻇﻔﻴﻦ‪.‬وذﻟـﻚ ﻟﻠﻤـﻮﻇﻔﻴﻦ اﻟـﺬﻳﻦ ﻻﻳﺘﻌـﺪوا ‪36‬‬
‫ﺷﻬﺮ‪.‬‬

‫‪SELECT employee_id, hire_date,‬‬

‫‪MONTHS_BETWEEN (SYSDATE, hire_date) TENURE,‬‬
‫‪ADD_MONTHS (hire_date, 6) REVIEW,‬‬
‫)‪NEXT_DAY (hire_date, ’FRIDAY’), LAST_DAY(hire_date‬‬
‫‪FROM employees‬‬
‫;‪WHERE MONTHS_BETWEEN (SYSDATE, hire_date) < 36‬‬

‫اﻟﻤﺜﺎل اﻟﺴﺎﺑﻖ ﻳﻘﻮم ﺑﻌﺮض رﻗﻢ اﻟﻤﻮﻇﻒ وﺗﺎرﻳﺦ ﺗﻌﻴﻨﺔ واﻟﻤﺪة اﻟﺬى ﻋﻤﻞ ﺑﻬﺎ ﻓﻰ اﻟﺸﺮآﺔ‬
‫ﻋﻦ ﻃﺮﻳﻖ ﻣﻌﺮﻓﺔ اﻟﻔﺮق ﺑﻴﻦ اﻟﻴﻮم اﻟﺤﺎﻟﻰ ‪ SYSDATE‬و ﺗﺎرﻳﺦ ﺗﻌﻴﻨﺔ ‪ HIRE_DATE‬ذﻟﻚ‬
‫ﺑﺎﺳﺘﺨﺪام ‪ MONTHS_BETWEEN‬واﻳﻀﺎ ﻳﺮﻳﺪ ﻣﻌﺮﻓﺔ اﻟﺘﺎرﻳﺦ ﺑﻌﺪ ‪ 6‬ﺷﻬﻮر ﻣﻦ ﺗﺎرﻳﺦ ﺗﻌﻴﻦ‬
‫اﻟﻤﻮﻇﻔﻴﻦ و ﻳﺮﻳﺪ ﻣﻌﺮﻓﺔ ﺗﺎرﻳﺦ ﻳﻮم اﻟﺠﻤﻌﺔ اﻟﻘﺎدم ﻓﻰ اﻻﺳﺒﻮع اﻟﻘﺎدم و ﺗﺎرﻳﺦ اﺧﺮ ﻳﻮم ﻓﻰ‬
‫ﺳﻨﺔ ﺗﻌﻴﻴﻦ آﻞ ﻣﻮﻇﻒ‪.‬وذﻟﻚ ﻟﻠﻤﻮﻇﻔﻴﻦ اﻟﺬﻳﻦ ﻋﻤﻠﻮا ﺑﺎﻟﺸﺮآﺔ اﻗﻞ ﻣﻦ ‪ 36‬ﺷﻬﺮ ‪.‬‬

‫’‪’25-JUL-95‬‬ ‫ﻧﻔﺘﺮض أن اﻟﺘﺎرﻳﺦ )اﻟﺤﺎﻟﻲ( هﻮ ‪:‬‬

‫‪EXAMPLE‬‬

‫اﻟﻤﺜﺎل اﻟﺴﺎﺑﻖ ﻳﻌﺮض ﺑﻴﺎﻧﺎت اﻟﻤﻮﻇﻔﻴﻦ وﻳﻘﻮم ﺑﺘﻘﺮﻳﺐ ﺗﺎرﻳﺦ اﻟﺘﻌﻴﻦ ﻟﻤﺪة ﺷﻬﺮ‬
‫وﻳﻘﻮم ﺑﻘﻄﻊ ﺗﺎرﻳﺦ اﻟﺘﻌﻴﻦ ﻟﻤﺪة ﺷﻬﺮ ﺑﻤﻌﻨﻰ اﻇﻬﺎر اول اﻟﺸﻬﺮ ﺑﺪون ﺗﻘﺮﻳﺐ‪.‬‬

‫اﻟﺸﻜﻞ اﻟﺬي أﻣﺎﻣﻨﺎ ﻳﻮﺿﺢ اﻟﺘﻐﻴﺮات اﻟﺘﻲ ﻳﻘﻮم ﺑﻬﺎ أوراآﻞ ﺁﻟﻴﺎ ﻋﻨﺪ اﻟﺤﺎﺟﺔ إﻟﻴﻬﺎ واﻟﻤﺘﺒﻊ‬
‫اﻟﺘﺎﻟﻲ‪:‬‬
 ‫اﻟﺘﺤﻮﻳﻼت اﻟﺨﺎرﺟﻴﺔ‬

‫وهﻲ اﻟﺘﺤﻮﻳﻼت اﻟﺘﻲ ﻳﻘﻮم ﺑﻬﺎ اﻟﻤﺴﺘﺨﺪم‬

‫‪SQL‬ﻳﺰود ﺑﺜﻼث وﻇﺎﺋﻒ أَن ﺗﺤﻮل ﻗﻴﻤﺔ ﻣﻦ اﻟﺒﻴﺎﻧﺎتِ واﺣﺪة إِﻟﻲ اﻷﺧﺮى ‪:‬‬

‫اﻟﺪوال‬
‫‪TO_CHAR( number‬‬
‫‪|date,[ fmt],‬‬
‫)]‪[nlsparams‬‬
‫‪TO_CHAR(number‬‬
‫‪|date,[ fmt],‬‬
‫)]‪[nlsparams‬‬
‫[‪TO_NUMBER(char,‬‬
‫‪fmt],‬‬
‫)]‪[nlsparams‬‬
‫]‪TO_DATE(char,[fmt‬‬
‫)]‪,[nlsparams‬‬
‫اﻟﻐﺮض‬
‫ﺗﺤﻮﻳﻞ ﻗﻴﻢ اﻟﺘﺎرﻳﺦ اواﻟﺮﻗﻢ إﻟﻲ ﻣﺠﻤﻮﻋﺔ ﻣﻦ اﻟﺤﺮوف‬
‫‪ VARCHAR2‬ﺑﺎﻟﻨﻤﻮذج اﻟﺸﻜﻞ ‪.fmt‬‬
‫ﺗﺤﻮﻳﻞ اﻟﺮﻗﻢ ‪ :‬إﻟﻲ ﻧﺺ‬
‫ﺗﺤﻮل اﻟﺘﺎرﻳﺦ إﻟﻲ ﻧﺺ‬
‫ﺗﺤﻮﻳﻞ اﻟﺤﺮوف‬
‫ﺗﻘﻮم ﺑﺘﺤﻮﻳﻞ اﻟﺤﺮوف إﻟﻲ أرﻗﺎم‬
‫ﺗﺤﻮﻳﻞ اﻟﺤﺮوف‬
‫ﺗﻘﻮم ﺑﺘﺤﻮﻳﻞ اﻟﺤﺮوف إﻟﻲ ﺗﺎرﻳﺦ‬
 ‫‪ TO_CHAR‬ﻣﻊ اﻟﺘﻮارﻳﺦ‪.‬‬ ‫‪R‬‬ ‫اﺳﺘﺨﺪام‬
‫)’‪TO_CHAR (date, ’format_model‬‬

‫ﻓﻔﻰ اﻟﻤﺜﺎل اﻟﺴﺎﺑﻖ ﻳﻘﻮم ﺑﻌﺮض رﻗﻢ اﻟﻤﻮﻇﻒ وﻳﻘﻮم ﺑﺘﺤﻮﻳﻞ ﺷﻜﻞ ﺗﺎرﻳﺦ اﻟﺘﻌﻴﻦ ﻣﻦ ‪(DD-‬‬
‫)‪ MON-RR‬اﻟﻰ )‪ .(MM/YY‬وﻓﻴﻤﺎ ﻳﻠﻰ ﺑﻌﺾ اﻻﺷﻜﺎل ﻟﻠﺘﺎرﻳﺦ‪:‬‬

‫‪YYYY‬‬ ‫ﺳﻨﺔ آﺎﻣﻠﺔ ﻣﻦ اﻷرﻗﺎم ﻣﺜﻼ ‪1999‬‬

‫‪YEAR‬‬ ‫اﻟﺴﻨﺔ ﻣﻜﺘﻮﺑﺔ ﺣﺮﻓﻴﺎ‬
‫‪MM‬‬ ‫ﺗﻤﺜﻞ رﻗﻤﻴﻦ ﻟﻠﺸﻬﺮ ﻣﺜﻞ)ﻳﻨﺎﻳﺮ= ‪(1‬‬
‫‪MONTH‬‬ ‫أﺳﻢ اﻟﺸﻬﺮ ﺑﺎﻟﻜﺎﻣﻞ‬
‫‪MON‬‬ ‫اول ﺛﻼﺛﺔ ﺣﺮوف ﻣﻦ اﻟﺸﻬﺮ‬
‫‪DY‬‬ ‫ﺛﻼﺛﺔ ﺣﺮوف ﻣﺨﺘﺼﺮة ﻟﻠﻴﻮم واﻷﺳﺒﻮع‬
‫‪DAY‬‬ ‫أﺳﻢ اﻟﻴﻮم ﺑﺎﻟﻜﺎﻣﻞ‬
‫‪DD‬‬ ‫)أﻳﺎم اﻟﺸﻬﺮ( ‪31-1‬‬

‫ﻧﻤﻮذجِ ﺻﻴﻐﺔِ اﻟﺘﺎرﻳﺦ‬

‫ﻋﻨﺎﺻﺮ ﺻﻴﻎ اﻟﺘﺎرﻳﺦ اﻟﻮﻗﺖ ﺟﺰء ﻳﻘﺴﻢ ﻣﻦ اﻟﺘﺎرﻳﺦ ‪.‬‬

‫‪ : HH24‬اﻟﺴﺎﻋﺔ ﻓﻲ اﻟﻴﻮم )‪(23-0‬‬

‫‪ :‬اﻟﺪﻗﺎﺋﻖ )‪(59-0‬‬ ‫‪MI‬‬
‫‪ :‬اﻟﺜﻮاﻧﻲ )‪(59-0‬‬ ‫‪SS‬‬
‫‪ : PM‬ﺑﻌﺪ اﻟﻈﻬﺮ‬ ‫‪ :‬ﻗﺒﻞ اﻟﻈﻬﺮ‬ ‫‪AM‬‬

‫" ﻓﻤﺜﻼ ‪:‬‬ ‫أﺿﻒ ﻣﺠﻤﻮﻋﺔ اﻟﺤﺮوف ﻣﺸﺘﻤﻠﺔ ﻋﻠﻲ ﻋﻼﻣﺔ "‬ ‫*‬

‫‪ : DD‬أﻳﺎم اﻟﺸﻬﺮ )ﻣﻦ ‪(31 -1‬‬

‫اﻟﻌﻨﺎﺻﺮ‬ ‫وﺻﻒ‬
‫‪AM OR PM‬‬ ‫ﻣﺆﺷﺮ ﻗﺒﻞ اﻟﻈﻬﺮ أو ﺑﻌﺪ اﻟﻈﻬﺮ )ﻣﻦ ﻏﻴﺮ‬
‫ﻣﺪة(‬
‫‪A.M. OR P.M.‬‬ ‫ﻣﺆﺷﺮ ﻗﺒﻞ اﻟﻈﻬﺮ أو ﺑﻌﺪ اﻟﻈﻬﺮ) ﺑﻤﺪة(‬
‫‪HH OR HH12 OR HH24‬‬ ‫اﻟﺴﺎﻋﺎت اﻟﻴﻮﻣﻴﺔ )‪ (12-1‬و)‪(23-1‬‬
‫‪MI‬‬ ‫اﻟﺪﻗﺎﺋﻖ )‪(59-0‬‬
‫‪SS‬‬ ‫اﻟﺜﻮاﻧﻲ )‪(59-0‬‬

‫اﺳﺘﺨﺪام داﻟﺔ ‪ TO_CHAR‬ﻣﻊ اﻟﺘﻮارﻳﺦ‬

 ‫اﻟﻤﺜﺎل هﻨﺎ ﻳﻌﺮض اﻷﺳﻤﺎء اﻷﺧﻴﺮةِ وﺗﺎرﻳﺦِ اﻟﺘﻌﻴﻴﻦ ﻟﻜﻞ اﻟﻤﻮﻇﻔﻴﻦ‪ .‬وﻟﻜﻦ ﺳﻴﺘﻢ ﺗﻐﻴﻴﺮ‬
‫أﺳﻠﻮب ﻋﺮض اﻟﺘﺎرﻳﺦ ﺣﻴﺚ ﻳﻌﺮض هﻜﺬا ‪.17 June 1987‬‬
‫‪SELECT last_name,‬‬
‫)’‪TO_CHAR (hire_date,’fmDdspth "of" Month YYYY fmHH:MI:SS AM‬‬
‫‪HIREDATE‬‬
‫;‪FROM employees‬‬

‫ﻓﻰ اﻟﻤﺜﺎل اﻟﺴﺎﺑﻖ ﻳﺮﻳﺪ ﻋﺮض اﻻﺳﻢ وﺗﺎرﻳﺦ اﻟﺘﻌﻴﻦ وﻟﻜﻦ ﺑﺎﻟﺸﻜﻞ اﻟﻤﻌﺮوض ﻓﻰ اﻟﻤﺜﺎل‪.‬‬
‫وﻟﻤﻌﺮﻓﺔ اﻟﻔﺮق ﺑﻴﻦ ﺷﻜﻠﻴﻦ ﻋﺮض اﻟﺘﺎرﻳﺦ ﻗﻢ ﺑﺎﻻﺗﻰ ﺑﺪون ﺗﻌﺪﻳﻞ ﺷﻜﻞ ﻋﺮض اﻟﺘﺎرﻳﺦ وﻻﺣﻆ‬
‫اﻟﻔﺮق‪.‬‬
‫;‪Select last_name,hire_date from employees‬‬

‫‪ TO_CHAR‬ﻣﻊ اﻷرﻗﺎم‬ ‫إﺳﺘﺨﺪام داﻟﺔ‬

‫ﻣﺜﺎل ﺗﺴﺘﺨﺪم ‪ TO_CHAR‬هﻨﺎ ﻣﻊ اﻷرﻗﺎم‬

‫اﻟﺼﻮرة اﻟﻤﺮاد اﻇﻬﺎر اﻟﺮﻗﻢ ﺑﻬﺎ هﻰ ‘ ‪’$99,999.00‬‬
‫واﻟﻨﺎﺗﺞ ﻳﻈﻬﺮ ﻟﻨﺎ ﺑﺎﻟﺸﻜﻞ اﻟﺠﺪﻳﺪ ﻟﻠﺘﻨﺴﻴﻖ ‪. $6,000.00‬‬
‫ض ‪ ORACLE‬ﻣﺠﻤﻮﻋﺔ اﻟﻌﻼﻣﺎت ) ‪ ( #‬ﺑﺪﻻ ﻣﻦ اﻟﻌﺪد اﻟﺼﺤﻴﺢ ﻋﻨﺪ ﺗﺠﺎو ْز ﻋﺪدَ اﻷرﻗﺎ ِ‬
‫م‬ ‫* ﻳَﻌْﺮ ُ‬
‫اﻟﻤﺰودة ﻓﻲ ﻧﻤﻮذج اﻟﺼﻴﻐﺔ ﻣﻦ )‪0‬إﻟﻲ ‪.( 9‬‬
‫‪EXAMPLE‬‬

‫ﻣﺜﺎل ﺁﺧﺮ‪-:‬‬

‫‪No rows selected‬‬

‫ﻣﺠﻤﻮﻋﺔ ﻣﻦ ‪FUNCTION‬‬

‫اﻟﺪوال‬ ‫اﻟﻮﺻﻒ‬
‫)‪NVL (expr1, expr2‬‬ ‫ﻳﺤﻮل ﻗﻴﻤﺔ ‪ Null‬إِﻟﻲ ﻗﻴﻤﺔ ﺣﻘﻴﻘﻴﺔ‬
‫اذا آﺎن ‪ exp1‬ﺑﺴﺎوى ‪ null‬ﻳﺘﻢ ﺗﺒﺪﻳﻠﺔ ب ‪exp2‬‬
‫)‪NVL2 (expr1, expr2, expr3‬‬ ‫ﻟﻮ اﻟﺘﻌﺒﻴﺮ اﻷول ‪ expr1‬ﺑﻘﻴﻤﺔ ‪,‬ﻳﺘﻢ اﺳﺘﺮﺟﺎع‬
‫‪. expr2‬وﻟﻮ اﻟﺘﻌﺒﻴﺮ اﻷول ‪ , null‬ﻳﺘﻢ اﺳﺘﺮﺟﺎع‬
‫‪. expr3‬‬
‫اﻟﺘﻌﺒﻴﺮ ‪ expr1‬ﻳﻤﻜﻦ أَن ﻳﺄﺧﺬ أي ﻧﻮعِ ﺑﻴﺎﻧﺎت‪.‬‬
‫)‪NULLIF (expr1, expr2‬‬ ‫ﻳﻘﺎرن ﺗﻌﺒﻴﺮﻳﻦ وﻳﺴﺘﺮﺟﻊ ‪ Null‬إذا اﻟﺘﻌﺒﻴﺮﻳﻦ‬
‫ﻣﺘﺴﺎوﻳﻴﻦ‪ ،‬و ﻳﺴﺘﺮﺟﻊ اﻟﺘﻌﺒﻴﺮ اﻷول إذا اﻟﺘﻌﺒﻴﺮﻳﻦ‬
‫ﻏﻴﺮ ﻣﺘﺴﺎوﻳﻴﻦ‪.‬‬
‫‪COALESCE‬‬ ‫ﻳﺴﺘﺮﺟﻊ أول ﺗﻌﺒﻴﺮ ﻏﻴﺮ ‪ Null‬ﻓﻲ ﻗﺎﺋﻤﺔ اﻟﺘﻌﺒﻴﺮ‪.‬‬
‫أوﻟﻮﻳﺎت ﺗﻨﻔﻴﺬ ‪FUNCTION‬‬
‫ﻳﻤﻜﻦ ان ﺗﺴﺘﺨﺪم اآﺜﺮ ﻣﻦ ‪ FUNCTION‬ﻓﻰ اﻟﻜﻮد وﺗﻜﻮن اﺳﺒﻘﻴﺔ اﻟﺘﻨﻔﻴﺬ ﻣﻦ اﻟﺪاﺧﻞ‬
‫اﻟﻰ اﻟﺨﺎرج ‪.‬‬

‫اﻟﺪاﺧﻞ‪...‬ﻓﺎﻟﺨﺎرج‪......‬ﻓﺎﻟﺨﺎرج‬
 ‫‪FUNCTION‬‬ ‫ﻣﺜﺎل ﻋﻠﻰ أوﻟﻮﻳﺎت ﺗﻨﻔﻴﺬ‬

‫ﻓﻔﻲ اﻟﻤﺜﺎل ﻧﺠﺪ أن أوﻟﻮﻳﺎت اﻟﺘﻨﻔﻴﺬ ﺗﻜﻮن ﺑﺎﻟﺘﺮﺗﻴﺐ ‪-:‬‬

‫‪NVL -2‬‬ ‫‪TO_CHAR -1‬‬

‫ﻳﻬﺪف اﻟﻤﺜﺎل اﻟﺴﺎﺑﻖ اﻟﻰ‪:‬‬

‫ﻋﺮض ﻋﻤﻮد ‪ Manager_ID‬ﺑﺤﻴﺚ ﻟﻮ ‪ Manager_ID‬ب ‪ NULL‬ﻳﺘﻢ ادراج آﻠﻤﺔ ‪No‬‬
‫‪Manager‬ﺑﺪﻻ ﻣﻦ ‪. NULL‬وذﻟﻚ ﺑﺎﺳﺘﺨﺪام ‪. NVL‬‬
‫ﻓﻰ هﺬا‬ ‫ارﻗﺎم وﻧﺤﻦ ﻧﺮﻳﺪ آﺘﺎﺑﺔ ﺣﺮوف‬ ‫وﺣﻴﺚ ان ﻧﻮع اﻟﺒﻴﺎﻧﺎت ﻟﻠﻌﻤﻮد ‪Manager_ID‬‬
‫اﻟﻌﻤﻮد ﻓﻼﺑﺪ ﻣﻦ ﺗﺤﻮﻳﻞ اﻻرﻗﺎم اﻟﻰ ﺣﺮوف وذﻟﻚ ﺑﺎﺳﺘﺨﺪام ‪TO_CHAR‬‬

‫ﻣﺜﺎل‪:‬‬
‫ﻳﺮﻳﺪ هﺬا اﻟﻤﺜﺎل ﻋﺮض ﺗﺎرﻳﺦ ﻳﻮم اﻟﺠﻤﻌﺔ اﻟﻘﺎدﻣﺔ ﺑﻌﺪ ﺳﺘﺔ ﺷﻬﻮر ﻣﻦ ﺗﺎرﻳﺦ اﻟﺘﻌﻴﻴﻦ‪.‬‬
‫و ﻳﺠِﺐ أَن ﻳﻜﻮن اﻟﺘﺎرﻳﺦ اﻟﻤﻌﺮوض ﺑﺎﻟﺸﻜﻞ اﻟﺘﺎﻟﻰ‬
‫) ﻳﻮم اﻟﺠﻤﻌﺔ‪13 ،‬أﻏﺴﻄﺲ ‪. (1999‬‬
‫‪SELECT TO_CHAR(NEXT_DAY(ADD_MONTHS‬‬
‫‪(hire_date, 6), 'FRIDAY'),‬‬
‫)'‪'fmDay, Month DDth, YYYY‬‬
‫"‪"Next 6 Month Review‬‬
‫‪FROM employees‬‬
‫;‪ORDER BY hire_date‬‬
‫ﻻﺣﻆ ﺗﺮﺗﻴﺐ ‪: FUNCTIONS‬‬
‫„ ﻳﺘﻢ اﺿﺎﻓﺔ ﺳﺘﺔ ﺷﻬﻮر اﻟﻰ ﺗﺎرﻳﺦ اﻟﺘﻌﻴﻦ اوﻻ‪.‬‬
‫„ ﻳﺘﻢ ﻣﻌﺮﻓﺔ ﻳﻮم اﻟﺠﻤﻌﺔ اﻟﻘﺎدم ﻣﻦ اﻟﺘﺎرﻳﺦ اﻟﺬى ﺗﻢ اﻟﺘﻮﺻﻞ اﻟﻴﺔ‪.‬‬
‫„ ﻳﺘﻢ ﻋﺮض اﻟﺘﺎرﻳﺦ ﺑﺎﻟﺸﻜﻞ اﻟﻤﻄﻠﻮب‪.‬‬

‫‪ FUNCTIONS‬اﻟﺴﺎﺑﻘﺔ ‪:‬‬ ‫ﺷﺮح ﻟﻤﺠﻤﻮﻋﺔ‬

‫)‪NVL (Exp1, Exp2‬‬
‫ﺗﻘﻮم ‪ NVL‬ﺑﻔﺤﺺ اﻟﻘﻴﻤﺔ اﻻوﻟﻰ واذا وﺟﺪت ب ‪ NULL‬ﻳﺘﻢ ﺗﺤﻮﻳﻠﻬﺎ اﻟﻰ اﻟﻘﻴﻤﺔ اﻟﺜﺎﻧﻴﺔ‬
‫واذا وﺟﺪت ﺑﻘﻴﻤﺔ ﺗﻈﻞ ﺗﻠﻚ اﻟﻘﻴﻤﺔ آﻤﺎ هﻰ ﺑﺪون ﺗﻐﻴﺮ ‪.‬‬
‫اﻣﺜﻠﺔ‪:‬‬
‫)‪– NVL(commission_pct,0‬‬
‫)’‪– NVL(hire_date,’01-JAN-97‬‬
‫)’‪– NVL(job_id,’No Job Yet‬‬

‫)‪NVL2 (Exp1, Exp2, Exp3‬‬

‫ﺗﻘﻮم ‪ NVL2‬ﺑﻔﺤﺺ اول ﻗﻴﻤﺔ واذا وﺟﺪت ب ‪ NULL‬ﻳﺘﻢ ﺗﺤﻮﻳﻠﻬﺎ اﻟﻰ اﻟﻘﻴﻤﺔ اﻟﺜﺎﻟﺜﺔ واذا‬
‫وﺟﺪت ﺑﻘﻴﻤﺔ ﻳﺘﻢ ﺗﺤﻮﻳﻠﻬﺎ اﻟﻰ اﻟﻘﻴﻤﺔ اﻟﺜﺎﻧﻴﺔ ‪.‬‬
‫)‪NULLIF (Exp1, Exp2‬‬

‫ﺗﻘﻮم ‪ NULLIF‬ﺑﻤﻘﺎرﻧﺔ اﻟﻘﻴﻤﺔ اﻻوﻟﻰ ﺑﺎﻟﻘﻴﻤﺔ اﻟﺜﺎﻧﻴﺔ واذا ﺗﺴﺎوى اﻟﻘﻴﻤﺘﻴﻦ ﻳﻜﻮن اﻟﻨﺎﺗﺞ ب‬
‫‪ NULL‬واذا ﻟﻢ ﺗﺘﺴﺎوى اﻟﻘﻴﻤﺘﻴﻦ ﻳﻈﻬﺮ اﻟﻨﺎﺗﺞ ﺑﺎﻟﻘﻴﻤﺔ اﻻوﻟﻰ‪.‬‬
‫)…………………‪COALESCE (Exp1, Exp2, Exp3,Exp4,‬‬

‫ﺗﻘﻮم ‪ COALESCE‬ﺑﺎﺳﺘﺮﺟﺎع اول ﻗﻴﻤﺔ ﻻﺗﺴﺎوى ‪. NULL‬‬

‫‪NVL‬‬ ‫إﺳﺘﺨﺪام‬

‫وﻓﻰ هﺬا اﻟﻤﺜﺎل ﻳﺮﻳﺪ ﺗﺤﻮﻳﻞ ﻗﻴﻤﺔ ‪ COMM‬اﻟﻰ ‪ Zero‬اذا وﺟﺪت ب ‪ NULL‬وذﻟﻚ ﻟﻜﻰ‬
‫ﻳﺘﻤﻜﻦ ﻣﻦ ﺟﻤﻊ اﻟﻤﺮﺗﺐ ﻋﻠﻰ ‪ COMM‬ﻟﻜﻰ ﻳﻌﺮف ﻣﺠﻤﻞ اﻟﺪﺧﻞ ﻟﻠﻤﻮﻇﻔﻴﻦ‪.‬‬

‫و ﺗﺴﺘﺨﺪم ‪ NVL‬ﻻﺳﺘﺒﺪال اﻟﻘﻴﻤﺔ ‪ NULL‬ﺑﻘﻴﻤﺔ أﺧﺮي ﻟﻠﺴﻤﺎح ﺑﺎﻟﻘﻴﺎم ﺑﺎﻟﻌﻤﻠﻴﺎت‬

‫اﻟﺤﺴﺎﺑﻴﺔ‪.‬وﻓﻲ اﻟﻤﺜﺎل اﻟﺮﻗﻢ ﺻﻔﺮ هﻮ اﻟﺬى ﺳﻮف ﻳﺤﻞ ﻣﺤﻞ ‪ NULL‬ﺣﻴﺚ أن ‪COMM‬‬
‫ﻳﺤﺘﻮي ﻋﻠﻲ ﻗﻴﻤﺔ ‪ NULL‬وآﻤﺎ ﻧﺮي ﺗﻢ اﻋﺘﺒﺎر ﻗﻴﻤﺔ ‪ commission‬اﻟﻌﻤﻮﻟﺔ‬
‫اﻟﺘﻲ ﺗﻤﺜﻞ ‪ NULL‬ﺑﺼﻔﺮ ﻟﺬا ﻓﻘﺪ أﻣﻜﻦ إﺗﻤﺎم ﻋﻤﻠﻴﺔ اﻟﺠﻤﻊ‪.‬‬
 ‫‪NVL2‬‬ ‫اﺳﺘﺨﺪام‬

‫ﻳﻬﺪف اﻟﻤﺜﺎل اﻟﺴﺎﺑﻖ اﻟﻰ ﻣﻌﺮﻓﺔ اﻟﺪﺧﻞ اﻟﺸﻬﺮى ﻟﻜﻞ ﻣﻮﻇﻒ‬

‫)‪NVL(expr1, expr2, expr3‬‬

‫ﻓﻲ هﺬا اﻟﻤﺜﺎل ﻋﻨﺪﻣﺎ ﻳﺠﺪ ‪ COMM‬ب ‪ NULL‬ﻳﻘﻮم ﺑﺘﺤﻮﻳﻠﻬﺎ اﻟﻰ اﻟﻘﻴﻤﺔ اﻟﺜﺎﻟﺜﺔ وهﻰ‬
‫اﻟﻤﺮﺗﺐ اﻣﺎ اذا آﺎن اﻟﻤﻮﻇﻒ ﻳﺎﺧﺬ ‪ COMM‬ﻓﺘﻜﻮن اﻟﻨﺘﻴﺠﺔ ﺟﻤﻊ اﻟﻌﻤﻮﻟﺔ‬
‫و اﻟﻤﺮﺗﺐ ﻟﻤﻌﺮﻓﺔ اﻟﺪﺧﻞ اﻟﺸﻬﺮى ‪.‬‬

‫‪NULLIF‬‬ ‫اﺳﺘﺨﺪام‬

‫وهﻨﺎ ﻳﺘﻢ ﻣﻘﺎرﻧﺔ ﻃﻮل اﻻﺳﻢ اﻻول ﺑﻄﻮل اﻻﺳﻢ اﻻﺧﻴﺮ وﺗﻜﻮن اﻟﻨﺘﻴﺠﺔ ب ‪ NULL‬اذا آﺎن‬
‫اﻻﺳﻤﻴﻦ ﻣﺘﺴﺎوﻳﺎن ﻓﻰ اﻟﻄﻮل‪ .‬واذا ﻟﻢ ﻳﺘﺴﺎوى ﻳﺘﻢ ﻋﺮض ﻃﻮل اﻻﺳﻢ اﻻول‪.‬‬

‫‪COALESCE‬‬ ‫اﺳﺘﺨﺪام‬
 ‫هﺬا اﻟﻤﺜﺎل ﻳﻮﺿﺢ ان إذا آﺎﻧﺖ ﻗﻴﻤﺔ اﻟﻌﻤﻮﻟﺔ ﻟﻴﺴﺖ ‪ NULL‬ﻓﺴـــﻮف‬
‫ﺗﻌــﺮض‪ COALESCE .‬ﺗﺒﺤﺚ ﻋﻦ اول ﻗﻴﻤﺔ ﻻﺗﺴﺎوى ‪.NULL‬‬
‫اﻟﺘﻌﺒﻴﺮات اﻟﺸﺮﻃﻴﺔ ‪IF-THEN-ELSE‬‬

‫‪1‬‬ ‫‪CASE‬‬
‫‪2‬‬ ‫‪DECODE‬‬
‫‪CASE‬‬
‫اﻟﺸﻜﻞ اﻟﻌﺎم ﻟﻞ ‪CASE‬‬

‫‪ CASE‬ﻻﻣﻜﺎﻧﻴﺔ اﺳﺘﺨﺪام )ﻟﻮ( اى اﻧﻬﺎ ﺗﻌﺘﺒﺮ اداة ﺷﺮط ‪.‬‬ ‫ﺗﺴﺘﺨﺪم‬

‫ﻓﻔﻰ اﻟﻤﺜﺎل اﻟﺴﺎﺑﻖ ﻳﺴﺘﺨﺪم ‪ CASE‬آﺄداة ﺷﺮط ﻋﻠﻰ اﻟﻮﻇﻴﻔﺔ ﻓﻌﻨﺪﻣﺎ ﺗﻜﻮن اﻟﻮﻇﻴﻔﺔ‬
‫‪ IT_PROG‬ﻣﺜﻼ ﻳﻘﻮم ﺑﻀﺮب اﻟﻤﺮﺗﺐ ﻓﻰ ﻧﺴﺒﺔ ﻣﻌﻴﻨﺔ وآﻠﻤﺎ اﺧﺘﻠﻔﺖ اﻟﻮﻇﻴﻔﺔ اﺧﺘﻠﻔﺖ ﺗﻠﻚ‬
‫اﻟﻨﺴﺒﺔ اﻟﻤﻀﺮوﺑﺔ ﻓﻰ اﻟﻤﺮﺗﺐ ‪.‬‬
‫ﺑﻤﻌﻨﻲ ‪-:‬‬
‫إذا آﺎﻧﺖ اﻟﻮﻇﻴﻔﺔ ‪ IT_PROG‬اﻟﻤﺮﺗﺐ ﻳﺰﻳﺪ ﺑﻨﺴﺒﺔ ‪, %10‬‬
‫إذا آﺎﻧﺖ اﻟﻮﻇﻴﻔﺔ ‪ ST_CLERK‬اﻟﻤﺮﺗﺐ ﻳﺰﻳﺪ ﺑﻨﺴﺒﺔ ‪, %15‬‬
‫إذا آﺎﻧﺖ اﻟﻮﻇﻴﻔﺔ ‪ SA_REP‬اﻟﻤﺮﺗﺐ ﻳﺰﻳﺪ ﺑﻨﺴﺒﺔ ‪. %20‬وﻟﺒﺎﻗﻰ اﻟﻮﻇﺎﺋﻒ اﻷﺧﺮى ﻻ ﻳﻮﺟﺪ‬
‫زﻳﺎدة ﻓﻲ اﻟﻤﺮﺗﺐ ‪ .‬ﻧﻔﺲ اﻟﻤﺜﺎل اﻟﺴﺎﺑﻖ ﻳﻤﻜﻦ ﺗﻨﻔﻴﺬة ﺑﺎل ‪.DECODE‬‬
‫واﻟﺸﻜﻞ اﻟﻤﺴﺘﺨﺪم ﻟﻞ ‪DECODE‬‬

‫‪DECODE‬‬ ‫اﺳﺘﺨﺪام‬
 ‫اﻟﻤﺮﺗﺐ ﻳﺰﻳﺪ ﺑﻨﺴﺒﺔ ‪, %10‬‬ ‫إذا آﺎﻧﺖ اﻟﻮﻇﻴﻔﺔ ‪IT_PROG‬‬
‫إذا آﺎﻧﺖ اﻟﻮﻇﻴﻔﺔ ‪ ST_CLERK‬اﻟﻤﺮﺗﺐ ﻳﺰﻳﺪ ﺑﻨﺴﺒﺔ ‪, %15‬‬
‫اﻟﻤﺮﺗﺐ ﻳﺰﻳﺪ ﺑﻨﺴﺒﺔ ‪ . %20‬وﻟﺒﺎﻗﻰ اﻟﻮﻇﺎﺋﻒ اﻷﺧﺮى ﻻ‬ ‫إذا آﺎﻧﺖ اﻟﻮﻇﻴﻔﺔ ‪SA_REP‬‬
‫ﻳﻮﺟﺪ زﻳﺎدة ﻟﻬﻢ ﻓﻲ اﻟﻤﺮﺗﺐ ﻓﻴﺒﻘﻰ اﻟﻤﺮﺗﺐ آﻤﺎ هﻮ‪ DECODE .‬ﺗﺴﺘﺨﺪم ﺑﺪﻻ ﻣﻦ ‪IF-‬‬
‫‪THEN-ELSE‬‬

‫‪IF job_id = ’IT_PROG’ THEN salary = salary*1.10‬‬

‫‪IF job_id = ’ST_CLERK’ THEN salary = salary*1.15‬‬
‫‪IF job_id = ’SA_REP’ THEN salary = salary*1.20‬‬
‫‪ELSE salary = salary‬‬

‫ﻣﺜﺎل ‪:‬‬
‫أﻋﺮض ﻧﺴﺒﺔَ اﻟﻀّﺮﻳﺒﺔَ اﻟﻘﺎﺑﻠﺔ ﻟﻠﺘﻄﺒﻴﻖَ ﻟﻜﻞ ﻣﻮﻇﻒ ﻓﻲ ﻗﺴﻢ ‪. 80‬‬

‫ﺳﻮف ﻧﺤﺪد ﻧﺴﺒﺔ اﻟﻀﺮﻳﺒﺔ ﻟﻜﻞ ﻣﻮﻇﻒ ﻓﻲ اﻟﻘﺴﻢ ‪ 80‬ﺣﺴﺐ ﻗﻴﻤﺔ اﻟﺮاﺗﺐ اﻟﺸﻬﺮي ﻟﻜﻞ‬
‫ﻣﻮﻇﻒ‪.‬‬

‫ﻣﺪي اﻟﺮاﺗﺐ اﻟﺸﻬﺮي‬ ‫اﻟﻨﺴﺒﺔ‬

‫‪$0.00 - 1999.99‬‬ ‫‪00%‬‬
‫‪$2,000.00 - 3,999.99‬‬ ‫‪09%‬‬
‫‪$4,000.00 - 5,999.99‬‬ ‫‪20%‬‬
‫‪$6,000.00 - 7,999.99‬‬ ‫‪30%‬‬
‫‪$8,000.00 - 9,999.99‬‬ ‫‪40%‬‬
‫‪$10,000.00 - 11,999.99‬‬ ‫‪42%‬‬
‫‪$12,200.00 - 13,999.99‬‬ ‫‪44%‬‬
‫‪$14,000.00 or greater‬‬ ‫‪45%‬‬

‫ﻣﻠﺨﺺ اﻟﻔﺼﻞ‬

‫ﺗﻨﺎوﻟﻨﺎ ﻓﻲ هﺬا اﻟﻔﺼﻞ اﻟﺪوال اﻟﺮﻗﻤﻴﺔ ﻓﻲ ﻟﻐﺔ اﻻﺳﺘﻌﻼم واﻻﺳﺘﻔﻬﺎم ﻓﻲ ﻧﻈﺎم ﻗﻮاﻋ ﺪ اﻟﺒﻴﺎﻧ ﺎت اوراآ ﻞ وﻗ ﺪ ﻗ ﺴﻤﻨﺎ ه ﺬﻩ‬
‫اﻟ ﺪوال ﺣ ﺴﺐ وﻇﺎﺋﻔﻬ ﺎ ﻓﻤﻨﻬ ﺎ ﻣﺎﻳﺘﻌﺎﻣ ﻞ ﻣ ﻊ ﺳ ﺠﻞ أو ﺻ ﻒ ﻣ ﻦ اﻟﺒﻴﺎﻧ ﺎت وﻣﻨﻬ ﺎ ﻣﺎﻳﺘﻌﺎﻣ ﻞ ﻣ ﻊ ﻣﺠﻤﻮﻋ ﺔ ﻣ ﻦ اﻟ ﺴﺠﻼت‬
‫‪ RECORDS‬او اﻷﻋﻤﺪة ‪ )COLUMNS‬اﻟﺤﻘﻮل(‬
‫ﺣﻴ ﺚ ﺗﻄﺮﻗﻨ ﺎ اﻟ ﻰ داﻟ ﺔ اﻟﻘﻴﻤ ﺔ اﻟﻤﻄﻠﻘ ﺔ واﻟﺪاﻟ ﺔ اﻻﺳ ﻴﺔ واﻟﺠ ﺬر اﻟﺘﺮﺑﻴﻌ ﻲ وآ ﺬﻟﻚ دوال اﻟﺘﻘﺮﻳ ﺐ وداﻟ ﺔ ﺑ ﺎﻗﺲ اﻟﻘ ﺴﻤﺔ‬
‫واﻻﺷﺎرة‬
 ‫‪Multiable Row Function‬‬
‫ﻣﺎذا ﻳﻌﻨﻲ ب " ‪"Grouping Function‬؟‬
‫هﻲ ﻋﺒﺎرة ﻋﻦ ﻣﺠﻤﻮﻋﺔ ﻣﻦ ‪ Functions‬ﺗﻌﻤﻞ ﻋﻠﻲ ﻣﺠﻤﻮﻋﺔ ﻣﻦ اﻟﺼﻔﻮف ﻟﺘﻌﺮض‬
‫ﻧﺘﻴﺠﺔ واﺣﺪة‪.‬‬
‫وﻳﻤﻜﻦ أن ﺗﻌﻤﻞ ﻋﻠﻲ آﻞ ﺑﻴﺎﻧﺎت اﻟﺠﺪول أو ﻋﻠﻲ ﺟﺰء ﻓﻘﻂ ﻣﻦ ﺑﻴﺎﻧﺎت اﻟﺠﺪول‪.‬‬

‫‪Group Functions‬‬ ‫أﻧﻮاع‬

‫اﻟﺪوال‬ ‫اﻟﻮﺻﻒ‬
‫ﺗﻘــﻮم ﺑﺤــﺴﺎب اﻟﻤﺘﻮﺳــﻂ اﻟﺤــﺴﺎﺑﻰ ﻟﻤﺠﻤﻮﻋــﺔ ﻣــﻦ )‪AVG([DISTINCT|ALL]n‬‬
‫اﻷرﻗﺎم و ﺗﻘﻮم ﺑﺘﺠﺎهﻞ اﻟﻘﻴﻤﺔ اﻟﻔﺎرﻏﺔ ‪. NULL‬‬
‫‪COUNT({*|[DISTINCT|A‬‬ ‫ﺗﻘﻮم ﺑﺤﺴﺎب ﻋﺪد اﻟﺤﻘﻮل ﻓﻲ ﻋﻤﻮد ﻣﻌﻴﻦ اﻟﺘﻲ ﻻ‬
‫)}‪LL]expr‬‬ ‫ﺗﺤﻤﻞ ﻗﻴﻤﺔ ‪.NULL‬‬
‫‪MAX([DISTINCT|ALL]exp‬‬ ‫وهﻲ اﺧﺘﺼﺎر آﻠﻤﺔ ‪ MAXIMUM‬وهﻲ ﺗﻘﻮم ﺑﺎﻟﺒﺤﺚ‬
‫)‪r‬‬ ‫ﻋﻦ أآﺒﺮ ﻗﻴﻤﺔ ﻟﻤﺠﻤﻮﻋﺔ ﻣﻦ اﻟﻘﻴﻢ ﻓﻲ ﻋﻤﻮد ﻣﻌﻴﻦ ‪.‬‬
‫‪MIN([DISTINCT|ALL]exp‬‬ ‫وهﻲ اﺧﺘﺼﺎر آﻠﻤﺔ ‪ MINIMUM‬وهﻲ ﺗﻘﻮم ﺑﺎﻟﺒﺤﺚ‬
‫)‪r‬‬ ‫ﻋﻦ أﻗﻞ ﻗﻴﻤﺔ ﻣﻮﺟﻮدة ﻓﻲ ﻋﻤﻮد ﻣﻌﻴﻦ‪.‬‬
‫]‪STDDEV([DISTINCT|ALL‬‬ ‫داﻟﺔ اﻻﻧﺤﺮاف اﻟﻤﻌﻴﺎري وهﻲ اﺧﺘﺼﺎر ﻟﻜﻠﻤﺔ‬
‫)‪x‬‬ ‫‪. Stander deviation‬‬
‫)‪SUM([DISTINCT|ALL]n‬‬ ‫ﺗﻘﻮم ﺑﺤﺴﺎب ﻣﺠﻤﻮع آﻞ اﻟﻘﻴﻢ اﻟﻤﻮﺟﻮدة ﻓﻲ ﻋﻤﻮد‬
‫ﻣﻌﻴﻦ او ﻓﻰ ﻣﺠﻤﻮﻋﺔ ﺻﻔﻮف ﻓﻘﻂ‪.‬‬
‫‪VARIANCE([DISTINCT|A‬‬ ‫ﺗﺴﺘﺨﺪم ﻟﺤﺴﺎب ﻣﻌﺪل اﻻﺧﺘﻼف او اﻟﻤﻌﻴﺎر‬
‫)‪LL]x‬‬ ‫ﻟﻤﺠﻤﻮﻋﺔ ﻣﺸﺎهﺪات أو ﻗﺮاءات ‪.‬‬

‫ﻣﻠﺤﻮﻇﺔ هﺎﻣﺔ ﺟﺪا‬

‫آﻞ ‪ Group Function‬ﺗﺘﺠﺎهﻞ ‪ NULL‬ﻓﻴﻤﺎ ﻋﺪا داﻟﺔ ‪ COUNT‬اذا اﺳﺘﺨﺪﻣﺖ ﻣﻊ *‪.‬‬
‫ﺣﻴﺚ ﻋﻨﺪ اﺳﺘﺨﺪاﻣﻬﺎ ﻣﻊ اﻟﻨﺠﻤﺔ * اى ) *( ‪ COUNT‬ﻓﻬﻨﺎ ﻻ ﺗﺘﺠﺎهﻞ ﻗﻴﻤﺔ ‪.NULL‬‬
 ‫اﻟﺼﻴﻐﺔ اﻟﻌﺎﻣﺔ ﻟﻞ ‪Group Function‬‬
‫‪SELECT‬‬ ‫‪[column,] group function (column), ...‬‬
‫‪FROM‬‬ ‫‪table‬‬
‫‪[WHERE‬‬ ‫]‪condition‬‬
‫‪[GROUP BY‬‬ ‫]‪column‬‬
‫‪[ORDER BY‬‬ ‫;]‪column‬‬

‫ﻣﻼﺣﻈﺔ ‪:‬‬
‫ﺔ ﺑﺘﺮﺗﻴﺐ ﺗﺼﺎﻋﺪىِ ﻋﻨﺪﻣﺎ ﺗﺴﺘﺨﺪم ﻓﻘﺮة ‪ .GROUP BY‬وﻟﻠﺘﺮﺗﻴﺐ‬
‫*ت رﺗﺐ ُ اﻟﻨّﺘﻴﺠ َ‬
‫اﻟﺘﻨﺎزﻟﻰ ﻧﺴﺘﺨﺪم ‪ DESC‬ﻓﻰ ﻓﻘﺮة ‪.ORDER BY‬‬

‫اﺳﺘﺨﺪام ‪ AVG‬و ‪SUM‬‬

‫ﻳﻤﻜﻨﻚ اﺳﺘﺨﺪام دوال ‪ AVG‬و ‪ SUM‬ﻟﻠﺒﻴﺎﻧﺎت اﻟﺮﻗﻤﻴﺔ‪.‬‬

‫اﻟﻤﺜﺎل اﻟﺴﺎﺑﻖ ﻳﺮﻳﺪ ﻣﻌﺮﻓﺔ اﻟﻤﺘﻮﺳﻂ اﻟﺤﺴﺎﺑﻰ ﻟﻤﺮﺗﺒﺎت اﻟﻤﻮﻇﻔﻴﻦ و اﻋﻠﻰ ﻣﺮﺗﺐ و‬
‫اﻗﻞ ﻣﺮﺗﺐ و ﻣﺠﻤﻮع اﻟﻤﺮﺗﺒﺎت ﻟﻠﻤﻮﻇﻔﻴﻦ ‪.‬‬
‫ﻦ أﺗﺴﺘﺨﺪام ‪ AVG‬و ‪ SUM‬و ‪ MIN‬و ‪ MAX‬ﻣﻊ اﻷﻋﻤﺪةِ اﻟﺘﻲ ﻳﻤﻜﻦ أن‬ ‫* ﻳُﻤﻜ ُ‬
‫ﺗﺨﺰن ﺑﻴﺎﻧﺎت رﻗﻤﻴﺔ‪.‬‬

‫ﻣﺜﺎل اﺧﺮ‪:‬‬
‫اﺳﺘﺨﺪام ‪ MIN‬و ‪MAX‬‬
‫‪ MIN‬و ‪ MAX‬ﻷي ﻧﻮع ﻣﻦ اﻟﺒﻴﺎﻧﺎت‪.‬‬ ‫ﻳﻤﻜﻨﻚ اﺳﺘﺨﺪام‬

‫ﻳﻌﺮض اﻟﻤﺜﺎل اﻟﺴﺎﺑﻖ اﻗﺪم ﻣﻮﻇﻒ ﻓﻰ اﻟﺸﺮآﺔ ذﻟﻚ ﻋﻦ ﻃﺮﻳﻖ اﺳﺘﺨﺪام ‪ MIN‬ﻣﻊ‬
‫ﺗﺎرﻳﺦ اﻟﺘﻌﻴﻦ و ﻳﻌﺮض اﻳﻀﺎ اﺣﺪث ﻣﻮﻇﻒ ﻓﻰ اﻟﺸﺮآﺔ ﻋﻦ ﻃﺮﻳﻖ اﺳﺘﺨﺪام ‪. MAX‬‬

‫وﻳﻌﺮض اﻟﻤﺜﺎل اﻟﺴﺎﺑﻖ اﺳﻤﺎء اﻟﻤﻮﻇﻔﻴﻦ وذﻟﻚ ﻋﻦ ﻃﺮﻳﻖ اﺳﺘﺨﺪام‬

‫‪MAX‬و ‪ MIN‬ﻓﺘﻘﻮم ال ‪ MAX‬ﺑﺄﻇﻬﺎر اﻻﺳﻢ اﻟﺬى ﻳﺒﺪأ ﺑﺄﺧﺮ ﺣﺮف هﺠﺎﺋﻴﺎ )‪.(Z‬‬
‫و ﺗﻘﻮم ال ‪ MIN‬ﺑﺄﻇﻬﺎر اﻻﺳﻢ اﻟﺬى ﻳﺒﺪأ ﺑﺄول ﺣﺮف هﺠﺎﺋﻲ )‪.(A‬‬

‫ﻻﺣﻆ ‪ :‬آﻞ ‪ FUNCTIONS‬ﺗﻌﻤﻞ ﻋﻠﻲ اﻟﻘﻴﻢ اﻟﺮﻗﻤﻴﺔ ﻓﻘﻂ ﻣﺎﻋﺪا ‪ MAX‬و ‪MIN‬‬
‫ﻓﻤﻦ اﻟﻤﻤﻜﻦ أن ﻳﻌﻤﻼن ﻣﻊ اﻟﺘﻮارﻳﺦ ‪.‬‬

‫اﺳﺘﺨﺪام داﻟﺔ ‪COUNT‬‬

‫)*( ‪ COUNT‬ﺗﻘﻮم ﺑﺤﺴﺎب ﻋﺪد اﻟﺼﻔﻮف ﻓﻲ اﻟﺠﺪول‬
‫ﻋﻨﺪ اﺳﺘﺨﺪام اﻟﻨﺠﻤﺔ )*( ﻣﻊ ‪ COUNT‬ﺑﺪﻻ ﻣﻦ اﺳﻢ اﻟﻌﻤﻮد ﻓﺈﻧﻬﺎ ﺗﻘﻮم ﺑﺤﺴﺎب ﻋﺪد‬
‫اﻟﺼﻔﻮف اﻟﻤﻮﺟﻮدة ﻓﻰ اﻟﺠﺪول ‪.‬‬
‫‪ COUNT‬ﻟﻬﺎ ﺛﻼث أﺷﻜﺎل ‪:‬‬ ‫وﻣﻦ هﻨﺎ ﻧﺠﺪ أن‬
‫)*(‪1- COUNT‬‬ ‫ﻳﻘﻮم ﺑﺤﺴﺎب ﻋﺪد اﻟﺼﻔﻮف ﻓﻲ اﻟﺠﺪول‬
‫وﻳﺘﻀﻤﻦ اﻟﺼﻔﻮف اﻟﺘﻲ ﺗﺤﺘﻮي ﻗﻴﻤﺔ ﻓﺎرﻏﺔ‬
‫‪.NULL‬‬
‫)‪2- COUNT(expr‬‬ ‫ﻓﺴﻮف ﺗﻘﻮم ﺑﺤﺴﺎب ﻋﺪد اﻟﻘﻴﻢ اﻟﺘﻲ ﻻ‬
‫ﺗﺤﺘﻮي ﻋﻠﻲ ﻗﻴﻢ ﻓﺎرﻏﺔ ‪ NULL‬ﻓﻲ‬
‫اﻷﻋﻤﺪة اﻟﺘﻲ ﺣﺪدت ﺑﻮاﺳﻄﺔ ‪.expr‬‬

‫)‪3- COUNT ( DISTINCT expr‬‬ ‫ﻳﻘﻮم ﺑﺤﺴﺎب ﻋﺪد اﻟﻘﻴﻢ اﻟﻔﺮﻳﺪة اى اﻟﻐﻴﺮ‬
‫ﻣﻜﺮرة ﻓﻲ اﻷﻋﻤﺪة اﻟﻤﺤﺪدة‪.‬‬

‫ﻳﻌﺮض اﻟﻤﺜﺎل ﻋﺪدِ اﻟﻤﻮﻇﻔﻴﻦ ﻓﻲ اﻟﻘﺴﻢِ ‪ 80‬اﻟﺬﻳﻦ ﻳﺄﺧﺬون ﻋﻤﻮﻟﺔ ‪.‬‬

‫ﻋﻨﺪ ﺗﺤﺪﻳﺪ اﺳﻢ ﻋﻤﻮد )‪ COUNT(commission_pct‬ﻣﻊ ‪ COUNT‬ﻓﺈﻧﻬﺎ ﺗﻘﻮم‬
‫ﺑﺤﺴﺎب ﻋﺪد اﻟﺼﻔﻮف اﻟﺘﻲ ﻻ ﺗﺤﺘﻮي ﻋﻠﻲ ﻗﻴﻢ ﻓﺎرﻏﺔ ‪ NULL‬ﻟﻬﺬا اﻟﻌﻤﻮد وﻋﺪد‬
‫اﻟﺼﻔﻮف اﻟﻤﻮﺟﻮدة واﻟﺘﻲ ﻻ ﺗﺤﺘﻮي ﻋﻠﻲ ‪ NULL‬هﻢ ﺛﻼﺛﺔ ‪.‬‬

‫أﻋﺮض ﻋﺪد اﻷﻗﺴﻢِ اﻟﻤﻮﺟﻮدة ﻓﻰ ﺟﺪول اﻟﻤﻮﻇﻔﻴﻦ ‪.‬‬

‫وﺗﻌﺘﺒﺮ ﺗﻠﻚ اﻟﻨﺘﻴﺠﺔ اﻟﺴﺎﺑﻘﺔ ﺧﺎﻃﺌﺔ ﻷﻧﺔ ﻗﺎم ﺑﺤﺴﺎب اﻟﺘﻜﺮارت ﻓﻰ ﻋﻤﻮد‬
‫‪ . DEPARTMENT_ID‬وﻟﻤﻌﺎﻟﺠﺔ ذﻟﻚ ﻧﻘﻮم ﺑﺎﺳﺘﺨﺪام ‪DISTINCT‬‬
‫آﻤﺎ ﻓﻰ اﻟﻤﺜﺎل اﻟﺘﺎﻟﻰ ‪.‬‬

‫اﺳﺘﺨﺪام ‪DISTINCT‬‬

‫)‪ COUNT (DISTINCT expr‬ﺗﺴﺘﺨﺪم ﻟﻤﻨﻊ اﺣﺘﺴﺎب اﻟﺤﻘﻮل اﻟﺘﻲ ﺗﺘﻜﺮر ‪.‬اى ﺗﻘﻮم‬
‫ﺑﻤﻨﻊ ‪. Duplicate‬‬

‫ﻣﻼﺣﻈﺔ‪:‬اﺳﺘﺨﺪام ‪ DISTINCT‬ﻟﻜﻰ ﺗﻤﻨﻊ ﺣِﺴﺎب أي ﻗِﻴَﻢِ ﻣﻜﺮرة ﻓﻰ اﻟﻌﻤﻮدِ ‪.‬‬

‫آﻤﺎ ذآﺮﻧﺎ ان ﺟﻤﻴﻊ ‪ GROUP FUNTIONS‬ﺗﺘﺠﺎهﻞ ﻗﻴﻢ ‪ NULL‬ﻓﻴﻤﺎ ﻋﺪا‬

‫)*(‪ COUNT‬وﻋﻨﺪ ﺣﺴﺎب اﻟﻤﺘﻮﺳﻂ ﻟﻘﻴﻢ اﻟﻌﻤﻮد )‪AVG(commission_pct‬‬
‫ﻳﺘﻢ ﺗﺠﺎهﻞ ﻗﻴﻢ ‪ NULL‬ﻟﺒﻘﻴﺔ اﻟﻘﻴﻢ و ﻳﺘﻢ ﺣﺴﺎب اﻟﻤﺘﻮﺳﻂ ﻋﻦ ﻃﺮﻳﻖ ﺟﻤﻊ ﻗﻴﻢ‬
‫اﻟﻌﻤﻮد و ﻗﺴﻤﺘﻪ ﻋﻠﻲ ﻋﺪد اﻟﺤﻘﻮل اﻟﺘﻰ ﺑﻬﺎ ﻗﻴﻤﺔ ﻓﻘﻂ و ﺑﺬﻟﻚ ﻳﺘﻢ اﻋﻄﺎء ﻧﺘﻴﺠﺔ ﻏﻴﺮ‬
‫ﺻﺤﻴﺤﺔ ﻟﻠﻤﺘﻮﺳﻂ اﻟﺤﺴﺎﺑﻰ ﻟﻠﻌﻤﻮﻻت ‪ commission‬وﻟﻠﺘﻐﻠﺐ ﻋﻠﻲ هﺬﻩ اﻟﻤﺸﻜﻠﺔ‬
‫ﻧﺴﺘﺨﺪم ‪.NVL‬‬
 ‫‪GROUP FUNCTIONS‬‬ ‫‪ NVL‬ﻣﻊ‬ ‫اﺳﺘﺨﺪام‬

‫وﺑﺬﻟﻚ ﻳﺘﻢ اﻟﻘﺴﻤﺔ ﻋﻠﻰ ﻋﺪد اﻟﺤﻘﻮل آﻠﻬﺎ وﻟﻴﺲ اﻟﺤﻘﻮل اﻟﺘﻰ ﺑﻬﺎ ﻗﻴﻤﺔ ﻓﻘﻂ‪.‬‬

‫داﻟﺔ اﻻﻧﺮاف اﻟﻤﻌﻴﺎري ‪STDDEV‬‬

‫ﺗﻘﻮم هﺬﻩ اﻟﺪاﻟﺔ ﺑﺈﻳﺠﺎد اﻻﻧﺤﺮاف اﻟﻤﻌﻴﺎري ﻟﻤﺠﻤﻮﻋﺔ ﻣﺸﺎهﺪات أو ﻗﺮاءات‬

‫اﻟﺸﻜﻞ اﻟﻌﺎم‬
‫)‪STDDEV (DISTINCT|ALL‬‬

‫ﻣﺜﺎل‬
‫ﻹﺑﺠﺎد اﻻﻧﺤﺮاف اﻟﻤﻌﻴﺎري ﻟﻸرﻗﺎم اﻟﻮاردة ﻓﻲ ﺣﻘﻞ اﻟﺮواﺗﺐ ﻓﻲ ﺟﺪول اﻟﻤﻮﻇﻔﻴﻦ ‪EMP‬‬

‫‪SELECT STDDEV (SAL) FROM EMP‬‬

‫داﻟﺔ اﻟﻤﻌﻴﺎر ‪VARIANCE‬‬

‫ﺗﻘﻮم هﺬﻩ اﻟﺪاﻟﺔ ﺑﺈﻳﺠﺎد اﻟﻤﻌﻴﺎر ﻟﻤﺠﻤﻮﻋﺔ ﻣﺸﺎهﺪات أو ﻗﺮاءات‬

‫ﻣﺜﺎل‬
‫;‪SELECT VARIANCE (SAL) FROM EMP‬‬
 ‫‪GROUP BY‬‬ ‫اﺳﺘﺨﺪام‬

‫ﺣﺘﻰ اﻵن آﻞ ‪ GROUP FUNCTIONS‬ﺗﺘﻌﺎﻣﻞ ﻣﻊ اﻟﺠﺪول آﻤﺠﻤﻮﻋﺔ واﺣﺪة‪.‬‬

‫وﻟﻜﻦ ﺑﺎﺳﺘﺨﺪام ‪ GROUP BY‬ﻳﻤﻜﻨﻚ ﻣﻦ ﺗﻘﺴﻴﻢ اﻟﺒﻴﺎﻧﺎت‪.‬ﻓﻴﻤﻜﻦ ﺣﺴﺎب اﻟﻤﺘﻮﺳﻂ‬
‫ﻟﻠﻤﺮﺗﺒﺎت ﺑﺠﺪول اﻟﻤﻮﻇﻔﻴﻦ ﻟﻜﻞ ﻗﺴﻢ ﻣﻦ اﻻﻗﺴﺎم ﻋﻠﻰ ﺣﺪة ‪.‬‬

‫اﺳﺘﺨﺪام ‪GROUP BY‬‬

‫ﺗﻘﺴﻢ ﺻﻔﻮف اﻟﺠﺪول إﻟﻲ ﻣﺠﻤﻮﻋﺎت ﺻﻐﻴﺮة ﺑﻮاﺳﻄﺔ ‪. GROUP BY‬‬

‫‪ GROUP BY‬آﻲ ﺗﻘﺴﻢ ﺻﻔﻮف اﻟﺠﺪاول إﻟﻲ ﻣﺠﻤﻮﻋﺎت‪.‬‬ ‫ﻳﻤﻜﻨﻚ اﺳﺘﺨﺪام‬

‫ﺑﻌﺾ اﻟﺸﺮوط ﻻﺳﺘﺨﺪام ‪: GROUP BY‬‬

‫‪ .1‬اذا ﺗﻢ ادراج ﻋﻤﻮد ﻓﻰ ﺟﻤﻠﺔ ‪ SELECT‬و أردت اﺳﺘﺨﺪام ‪ GROUP BY‬ﻓﻼﺑﺪ ﻣﻦ‬
‫ادراج ﺗﻠﻚ اﻟﻌﻤﻮد اﻟﻤﺪرج ﻓﻰ ﺟﻤﻠﺔ ‪ SELECT‬ﻓﻰ ﻓﻘﺮة ‪ GROUP BY‬وﺑﻐﻴﺮ ذﻟﻚ‬
‫ﻳﺤﺪث ‪. Error‬‬
‫‪ .2‬ﻳﻤﻜﻦ ان ﺗﺴﺘﺨﺪم ﻓﻘﺮة ‪ WHERE‬ﻟﺘﺤﺪﻳﺪ اﻟﺼﻔﻮف اﻟﻤﺮاد ﻋﺮﺿﻬﺎ ذﻟﻚ ﻗﺒﻞ‬
‫اﺳﺘﺨﺪام ﻓﻘﺮة ‪. GROUP BY‬‬
‫‪ .3‬ﻻ ﻳﻤﻜﻦ اﺳﺘﺨﺪام اﻻﺳﻢ اﻟﻤﺴﺘﻌﺎر )‪ (Alias‬ﻓﻰ ﻓﻘﺮة ‪. Group By‬‬
‫‪ .4‬ﻳﺘﻢ ﺗﺮﺗﻴﺐ اﻟﻨﺎﺗﺞ ﺗﺼﺎﻋﺪﻳﺎ ‪.‬وﻳﻤﻜﻦ أن ﺗﺘﺠﺎوز هﺬا ﺑﺎﺳﺘﺨﺪام اﻟﻔﻘﺮة ‪.ORDER BY‬‬

‫‪GROUP BY‬‬ ‫اﺳﺘﺨﺪام‬

 ‫ﻓﻔﻰ اﻟﻤﺜﺎل اﻟﺴﺎﺑﻖ ﻳﻘﻮم ﺑﺤﺴﺎب اﻟﻤﺘﻮﺳﻂ اﻟﺤﺴﺎﺑﻰ ﻟﻠﻤﺮﺗﺒﺎت ﻟﻜﻞ ﻗﺴﻢ ﻋﻠﻰ‬
‫ﺣﺪة‪ .‬وذﻟﻚ ﺑﺎﺳﺘﺨﺪام ‪. Group by‬‬
‫ﻻﺣﻆ اﺳﺘﺨﺪام ﻧﻔﺲ اﻟﻌﻤﻮد ﺑﺠﻤﻠﺔ ‪ SELECT‬ﻓﻰ ﺟﻤﻠﺔ ‪. GROUP BY‬‬
‫و ﻟﻴﺲ ﻣﻦ اﻟﻀﺮوري ﺗﻮاﺟﺪ اﺳﻢ اﻟﻌﻤﻮد اﻟﻤﺴﺘﺨﺪم ﺑﺠﻤﻠﺔ ‪ GROUP BY‬ﺑﺠﻤﻠﺔ‬
‫‪ SELECT‬آﻤﺎ ﻓﻰ اﻟﻤﺜﺎل اﻟﺘﺎﻟﻰ ‪:‬‬

‫ﻳﻤﻜﻦ اﺳﺘﺨﺪام ‪ GROUP BY‬ﻣﻊ أآﺜﺮ ﻣﻦ ﻋﻤﻮد‪.‬‬

‫ﻳﺠﺐ ذآﺮ ﺟﻤﻴﻊ أﺳﻤﺎء اﻷﻋﻤﺪة اﻟﻤﺪرﺟﺔ ﻓﻲ ﺟﻤﻠﺔ ‪ SELECT‬ﺑﺠﻤﻠﺔ‬
‫‪.GROUP By‬‬
‫ﻋﻨﺪ إﻏﻔﺎل ذآﺮ أﺣﺪ اﻷﻋﻤﺪة ﻓﻲ ﻋﺒﺎرة ‪ GROUP BY‬ﻓﺘﻈﻬﺮ رﺳﺎﻟﺔ ﺧﻄﺄ وﻻ ﻳﺘﻢ ﺗﻨﻔﻴﺬ‬
‫اﻵﻣﺮ‪.‬‬

‫ﻣﺜﺎل ﻋﻠﻰ ذﻟﻚ‪:‬‬

‫‪ GROUP BY‬وذﻟﻚ ﻟﻌﺪم ادراج ‪JOB_ID‬‬ ‫ﻧﻼﺣﻆ ان هﻨﺎك ﺧﻄﺎ ﻋﻨﺪ اﺳﺘﺨﺪام ﺟﻤﻠﺔ‬
‫داﺧﻞ ﻓﻘﺮة ‪. GROUP BY‬‬

‫‪ GROUP BY‬ﻣﻊ ﻣﺠﻤﻮﻋﺔ ﻣﻦ اﻷﻋﻤﺪة‬ ‫اﺳﺘﺨﺪام‬

 ‫اﺳﺘﻌﻼﻣﺎت ﻏﻴﺮ ﺻﺤﻴﺤﺔ ﺗﺴﺘﺨﺪم ‪ Group Function‬أي ﻋﻤﻮد أو ﺗﻌﺒﻴﺮ ﻓﻲ ﻗﺎﺋﻤﺔ‬
‫‪ SELECT‬ﻳﺠﺐ أن ﻳﻜﻮن ﺑﻔﻘﺮة ‪.GROUP BY‬‬

‫)‪SELECT department_id, COUNT (last_name‬‬

‫;‪FROM employees‬‬

‫)‪SELECT department_id, COUNT (last_name‬‬

‫*‬
‫‪ERROR at line 1:‬‬
‫‪ORA-00937: not a single-group group function‬‬

‫‪ GROUP BY‬ﻣﺘﻀﻤﻨﺔ اﻟﻌﻤﻮد اﻟﺬى ﻓﻰ‬ ‫وﻟﻤﻌﺎﻟﺠﺔ اﻟﺨﻄﺄ اﻟﺴﺎﺑﻖ ﻳﺠﺐ ادراج ﻓﻘﺮة‬
‫ﺟﻤﻠﺔ ‪ SELECT‬آﻤﺎ ﻓﻰ اﻟﻤﺜﺎل اﻟﺘﺎﻟﻰ ‪.‬‬

‫‪ Having‬ﻟﺘﺤﺪﻳﺪ )ﺷﺮط( ﻋﻠﻰ اﻟﻤﺠﻤﻮﻋﺎت‬ ‫اﺳﺘﺨﺪام‬

‫ﺗﺴﺘﺨﺪم ‪ HAVING‬ﻻﻣﻜﺎﻧﻴﺔ اﺳﺘﺨﺪام ﺷﺮط ﻣﻊ ‪.Group Functions‬‬

‫ﺣﻴﺚ ﻻﻳﻤﻜﻦ اﺳﺘﺨﺪام ‪ WHERE‬آﺸﺮط ﻣﻊ ‪. Group Functions‬‬
‫آﻤﺎ ﺳﻮف ﻧﺮى ﻓﻰ اﻟﻤﺜﺎل اﻟﺘﺎﻟﻰ‪:‬‬

‫ﻻ ﻳﻤﻜﻦ اﺳﺘﺨﺪام ‪ WHERE‬ﻣﻊ ‪ . Group Functions‬ﺣﻴﺚ ان ‪ where‬ﺗﻌﻤﻞ‬

‫ﻋﻠﻰ ﺗﺤﺪﻳﺪ اﻟﺼﻔﻮف ﻗﺒﻞ ﺗﺠﻤﻴﻌﻬﺎ ﻓﻰ ﺷﻜﻞ ﻣﺠﻤﻮﻋﺎت ‪ .‬ﻟﺬﻟﻚ ﻧﺴﺘﺨﺪم ‪ Having‬وهﻰ‬
 ‫ﺗﻌﻤﻞ داﺧﻞ ﺻﻔﻮف ﻟﻜﻞ ﻣﺠﻤﻮﻋﺔ ﻋﻠﻰ ﺣﺪى وﻳﻤﻜﻦ اﺳﺘﺨﺪام ‪Group Functions‬‬
‫داﺧﻠﻬﺎ‪ .‬آﻤﺎ ﻳﻠﻰ‪:‬‬

‫ﻣﺜﺎل أﺧﺮ‪:‬‬

‫ﻻ ﻳﻤﻜــﻦ اﺳــﺘﺨﺪام ‪ WHERE‬ﻟﻤﻨــﻊ ﻣﺠﻤﻮﻋــﺔ ﻣــﻦ اﻟﻤﺠﻤﻮﻋــﺎت اﻟﻨﺎﺗﺠــﺔ ﺣﻴــﺚ أن‬

‫ﻓﻘﺮة ‪ WHERE‬ﺗﺴﺘﺨﺪم ﻟﻤﻨﻊ اﻟﺼﻔﻮف اﻟﻔﺮدﻳﺔ وﻟﻴﺲ ﺻﻔﻮف اﻟﻤﺠﻤﻮﻋﺔ‪.‬وﻳﺘﻢ اﺳﺘﺨﺪام‬
‫ﻋﺒﺎرة ‪ HAVING‬ﺑﺪﻻ ﻣﻦ ﻋﺒـﺎرة ‪ WHERE‬وذﻟـﻚ ﻹﻇﻬـﺎر ﻣﺠﻤﻮﻋـﺎت ﻣـﻦ اﻟﺒﻴﺎﻧـﺎت دون‬
‫اﻷﺧﺮى آﻤﺎ ﻓﻲ اﻟﻤﺜﺎل ﺣﻴﺚ ﻟﻢ ﺗﻈﻬﺮ اﻟﻤﺠﻤﻮﻋﺔ اﻟﻤﺴﺘﺜﻨﺎة وهﻲ اﻹدارة ‪ 30‬ﺣﻴﺚ اﻧﻬـﺎ‬
‫ﻟﻢ ﺗﺤﻘﻖ اﻟﺸﺮط و هﻮ أن ﻳﻜﻮن ﻣﺘﻮﺳﻂ ﻣﺮﺗﺒﻬﺎ أآﺒﺮ ﻣﻦ ‪.10000‬‬

‫ﻣﻠﺤﻮﻇﺔ‪:‬‬
‫ﻻﻳﻤﻜﻦ اﺳﺘﺨﺪام اﻻﺳﻢ اﻟﻤﺴﺘﻌﺎر )‪ (Alias‬ﻣﻊ ‪ . HAVING‬آﻤﺎ ﻓﻰ اﻟﻤﺜﺎل اﻟﺘﺎﻟﻰ‪:‬‬
‫"‪Select job, max (sal) "MAX_SAL‬‬
‫‪From EMP‬‬
‫‪Group by job‬‬
‫;‪Having MAX_SAL>100‬‬

‫وﻟﻤﻌﺎﻟﺠﺔ اﻟﻤﺜﺎل اﻟﺴﺎﺑﻖ ﻳﺠﺐ ﻋﺪم اﺳﺘﺨﺪام اﻻﺳﻢ اﻟﻤﺴﺘﻌﺎر‬

‫ﻓﻰ ﻓﻘﺮة ‪ HAVING‬آﻤﺎ ﻳﻠﻰ‪:‬‬
‫"‪Select job , MAX(SAL) "MAX_SAL‬‬
‫‪From EMP‬‬
‫‪Group by job‬‬
‫;‪Having MAX(SAL) >100‬‬
 ‫اﻣﻜﺎﻧﻴﺔ اﺳﺘﺨﺪام اآﺜﺮ ﻣﻦ ‪ FUNCTIONS‬آﻤﺎ ﻳﻠﻰ‬
‫ﻓﺎﻟﻤﺜﺎل اﻟﺘﺎﻟﻰ ﻳﺮﻳﺪ ﻋﺮض أآﺒﺮ ﻣﺘﻮﺳﻂ ﻟﻠﻤﺮﺗﺒﺎت ﺑﺎﻟﻨﺴﺒﺔ ﻟﻼﻗﺴﺎم ‪:‬‬

‫ﻓﻬﻨﺎ ﺗﻢ ﺣﺴﺎب اﻟﻤﺘﻮﺳﻂ ﻟﻜﻞ إدارة ﺛﻢ ﺑﻌﺪ ذﻟﻚ ﺗﻢ ﻋﺮض اﻟﻤﺘﻮﺳﻂ اﻷآﺒﺮ‪.‬‬
 ‫ﻋﺮض اﻟﺒﻴﺎﻧﺎت ﻣﻦ اآﺜﺮ ﻣﻦ ﺟﺪول‬

‫اﻷهﺪاف‪:‬‬
‫‪ .1‬اﺳﺘﺨﺪام ﺟﻤﻠﺔ ‪ SELECT‬ﻻﺳﺘﺨﻼص ﺑﻴﺎﻧﺎت ﻣﻦ أآﺜﺮ ﻣﻦ ﺟـﺪول وذﻟـﻚ ﺑﺎﺳـﺘﺨﺪام ﻃـﺮق‬
‫اﻟﺮﺑﻂ اﻟﻤﺨﺘﻠﻔﺔ ‪.‬‬
‫‪ .2‬إﺳﺘﺨﻼص اﻟﺒﻴﺎﻧﺎت اﻟﺘﻲ ﻻ ﺗﻘﺎﺑﻞ ﺷﺮط اﻟﺮﺑﻂ ﺑﺎﺳﺘﺨﺪام ‪.Outer Join‬‬
‫‪ .3‬رﺑﻂ ﻋﻤﻮدﻳﻦ ﺑﻨﻔﺲ اﻟﺠﺪول وﻳﺴﻤﻲ ‪.Self Join‬‬

‫اﻟﺤﺼﻮل ﻋﻠﻲ اﻟﺒﻴﺎﻧﺎت ﻣﻦ أآﺜﺮ ﻣﻦ ﺟﺪول‬

‫ﻓﻘﺪ ﺗﻢ اﺧﺘﻴﺎر اﻟﻌﻤﻮد ‪ DEPARTMENT_NAME‬ﻣﻦ ﺟﺪول ‪DEPARTMENTS‬‬

‫واﺧﺘﻴﺎر اﻟﻌﻤﻮد ‪ EMPLOYE_ID‬واﻟﻌﻤـﻮد ‪ DEPARTMENT_ID‬ﻣـﻦ ﺟـﺪول ‪ EMPLOYEES‬ﻓـﺘﻢ‬
‫ﻋﺮض هﺬﻩ اﻟﺒﻴﺎﻧﺎت ﻣﻌﺎ ﻓﻲ ﺟﺪول ﺟﺪﻳﺪ وهﺬا ﻣﺎ ﻳﺴﻤﻲ ﺑـﺎﻟﺮﺑﻂ‪ Cartesian Products .‬ﻋﻨـﺪﻣﺎ‬
‫ﻻﻧﻀﻊ ﺷﺮط اﻟﺮﺑﻂ او ﻧﻀﻊ ﺷﺮط رﺑﻂ ﺧﺎﻃﺄ وﺗﻜﻮن اﻟﻨﺘﻴﺠﺔ ﻋـﺮض ﻋـﺪد آﺒﻴـﺮ ﻣـﻦ اﻟـﺼﻔﻮف وﺗﻜـﻮن‬
‫اﻟﻨﺘﻴﺠﺔ ﻏﻴﺮ ذات ﻣﻌﻨﻲ‪ .‬آﻤﺎ ﻓﻲ اﻟﻤﺜﺎل اﻟﺘﺎﻟﻲ‪:‬‬

‫‪Cartesian Products‬‬
 ‫وآﻤﺎ ذآﺮﻧﺎ ﻓﻔﻲ هﺬا اﻟﻤﺜﺎل ﺑﺴﺒﺐ ﺣﺬف اﻟﺸﺮط ‪ WHERE‬ﺗﻢ رﺑﻂ آﻞ اﻟﺼﻔﻮف ﻓﻰ ﺟﺪول‬
‫اﻟﻤﻮﻇﻔﻴﻦ ﻣﻊ آﻞ اﻟﺼﻔﻮف ﻓﻰ ﺟﺪول اﻻﻗﺴﺎم و ﺑﺬﻟﻚ ﻳﻜﻮن اﻟﻨﺎﺗﺞ ‪ 160‬ﺻﻔﻮف‪.‬‬

‫أﻧﻮاع اﻟﺮواﺑﻂ‬

‫ﻳﺴﺘﺨﺪم اﻟﺮﺑﻂ ﻟﻌﺮض اﻟﺒﻴﺎﻧﺎت ﻣﻦ أآﺜﺮ ﻣﻦ ﺟﺪول‬

‫ﻳﺴﺘﺨﺪم اﻷﻣﺮ ‪ SELECT‬ﻋﻦ ﻃﺮﻳﻖ آﺘﺎﺑﺔ اﺳﻢ اﻟﺠـﺪول اﻟﻤـﺮاد اﻻﺧﺘﻴـﺎر ﻣﻨـﺔ ‪ table1‬واﺳـﻢ‬
‫اﻟﻌﻤﻮد اﻟﻤﺮاد ﻋﺮﺿﺔ ‪ column1‬وﻳﻔﺼﻞ ﺑﻴﻨﻬﻢ ﺑﻨﻘﻄﺔ ‪.‬‬
‫ﺛﻢ اﻟﺠﺪول اﻟﺜـﺎﻧﻲ اﻟﻤـﺮاد رﺑﻄـﺔ و أﺳـﻢ اﻟﻌﻤـﻮد اﻟـﺬي ﻳـﺮاد ﻋﺮﺿـﻪ ‪ column2‬وﻳﻔـﺼﻞ ﺑﻴـﻨﻬﻢ‬
‫ﺑﻨﻘﻄﺔ ‪.‬‬
‫ﺛﻢ اﻟﺸﺮط ‪ WHERE‬ﻟﻴﺘﻢ رﺑﻂ اﻟﺠﺪوﻟﻴﻦ ﻣﻌﺎ ﺣﻴﺚ ﻳﺘﻢ ﻣﺴﺎواة ﻗﻴﻢ اﻟﻌﻤﻮدﻳﻦ ﻓﻲ اﻟﺠﺪوﻟﻴﻦ‪.‬‬
‫وهﻨﺎ ﻧﺠﺪ ان ﻋﻤﻮد رﻗﻢ اﻹدارة ﻓﻲ اﻟﺠﺪول اﻷول ﻟﻠﻤﻮﻇﻔﻴﻦ ﻳﺘﺴﺎوى ﻣﻊ ﻋﻤﻮد رﻗﻢ اﻹدارة ﻓـﻲ‬
‫اﻟﺠﺪول اﻟﺜﺎﻧﻲ اﻹدارات‪.‬‬

‫ﻣﺠﻤﻮﻋﺔ ﻣﻦ اﻟﺠﺪاول ﻣﻌﺎ ‪ ،‬آﻤﺜﺎل ﻟَﺮْﺑﻂَ أرﺑﻌﺔ ﺟﺪاول‪ ،‬ﻳﺘﻄﻠﺐ ذﻟﻚ ﺛﻼﺛﺔ رواﺑـﻂ‬ ‫*ﻟﻜﻲ ﺗَﺮْﺑﻂَ‬
‫آﺤﺪ أدﻧﻲ‪.‬‬

‫ﻣﺎ هﻮ اﻟﺮﺑﻂ اﻟﻤﺘﺴﺎوي ‪Equijoin‬؟‬

 ‫اﻟﺮﺑﻂ اﻟﻤﺘﺴﺎوي‬
‫وﻓﻴﺔ ﻳﺘﻢ ﺗﺴﺎوي ﺑﻴﻦ ﻗﻴﻢ ﻋﻤﻮد ﺑﺎﻟﺠﺪول اﻷول ﻣﻊ ﻗﻴﻢ ﻋﻤﻮد ﺑﺎﻟﺠﺪول اﻟﺜﺎﻧﻲ ‪.‬‬
‫وﻳﺘﻀﻤﻦ هﺬا اﻟﻨﻮع اﺳﺘﺨﺪام اﻟﻤﻔﺘﺎح اﻟﺮﺋﻴﺴﻲ واﻟﻤﻔﺘﺎح اﻷﺟﻨﺒﻲ‬
‫) ‪ Primary Key‬و ‪ ( Foreign Key‬وﻳﺴﻤﻲ هﺬا اﻟﻨﻮع ﻣﻦ ﺑﺎﻟﺮﺑﻂ اﻟﺒﺴﻴﻂ أو اﻟﺮﺑﻂ اﻟﺪاﺧﻠﻲ‬
‫‪.( Inner Join‬‬ ‫‪ Simple Join‬و‬ ‫)‬

‫ﻣﺜﺎل ﻳﻮﺿﺢ اﻟﺮﺑﻂ ﺑﻄﺮﻳﻘﺔ ‪EquiJoin‬‬

‫‪ WHERE‬ﻳﺤﺪد ﺷﺮط اﻟﺮﺑﻂ اﻟﻤﺴﺘﺨﺪم هﻮ إﺷﺎرة‬ ‫وآﻤﺎ ﻧﺮي ﻓﻰ اﻟﻤﺜﺎل اﻟﺴﺎﺑﻖ ﻓﻰ ﻓﻘﺮة‬
‫اﻟﺘﺴﺎوي ) = ( وهﻮ‪:‬‬
‫‪EMPLOYEES.DEPARTMENT_ID = DEPARTMENTS.DEPARTMENT_ID‬‬
‫ﻣﺴﺒﻖ ﺑﺄﺳﻢ‬ ‫ﻷن ﻋﻤﻮد ‪ DEPARTMENT_ID‬ﻣﻮﺟﻮد ﻓﻰ آﻠﺘﺎ اﻟﺠﺪوﻟﻴﻦ‪ ،‬وﻳﺠِﺐ أَن ﻳﻜﻮن ُ‬
‫اﻟﺠﺪول اﻟﺨﺎص ﺑﺔ آﻲ ﻧﺘﺠﻨﺐ اﻟﻐﻤﻮض ‪.‬‬
‫إﺿﺎﻓﺔ ﺷﺮط ﺁﺧﺮ ﻣﻦ ﺷﺮوط اﻟﺮﺑﻂ ﻋﻦ ﻃﺮﻳﻖ اﺳﺘﺨﺪام اﻟﻤﻌﺎﻣﻞ ‪and‬‬

‫ﻣﻦ اﻟﻤﻤﻜﻦ إﺿﺎﻓﺔ ﺷﺮط ﺁﺧﺮ ﻋﻦ ﻃﺮﻳﻖ اﺳﺘﺨﺪام ﻣﻌﺎﻣﻞ ‪ and‬ﻓﻤﺜﻼ‪:‬‬

‫’‪AND last_name = ’Matos‬‬
‫ﺣﻴﺚ ﻳﺘﻢ إﺿﺎﻓﺔ ‪ AND‬ﺑﻌﺪ اﻟﺸﺮط ﻓﻰ ‪WHERE‬‬
‫ﺛﻢ ﻳﻠﻲ ‪ AND‬اﻟﺸﺮط اﻟﺠﺪﻳﺪ‪.‬‬

‫‪SELECT last_name, employees.department_id,‬‬

‫‪department_name‬‬
‫‪FROM employees, departments‬‬
‫‪WHERE employees.department_id = departments.department_id‬‬
‫;’‪AND last_name = ’Matos‬‬

‫ﻓﻔﻰ اﻟﻤﺜﺎل اﻟﺴﺎﺑﻖ ﺗﻢ ﻋﺮض اﻻﺳﻢ و رﻗﻢ اﻟﻘﺴﻢ واﺳﻢ اﻟﻘﺴﻢ ﻟﻠﻤﻮﻇﻒ ‪.Matos‬‬

‫اﺳﺘﺨﺪام اﻷﺳﻤﺎء اﻟﻤﺴﺘﻌﺎرة ﻟﻠﺠﺪاول‬

‫* اﺳﺘﺨﺪام اﻷﺳﻤﺎء اﻟﻤﺴﺘﻌﺎرة ﻟﻠﺠﺪاول ﻳﺒﺴﻂ ﻋﻤﻠﻴﺔ اﻻﺳﺘﻌﻼم ‪.‬‬
‫* ﻳﺤﺴﻦ اﻷداء ﺑﺎﺳﺘﺨﺪام اول اﻟﺤﺮوف ﻣﻦ اﺳﻤﺎء اﻟﺠﺪاول ‪.‬‬

‫ﻣﻦ اﻟﻤﻤﻜﻦ اﺳﺘﺨﺪام اﻷﺳﻤﺎء اﻟﻤﺴﺘﻌﺎرة ﻟﻠﺠﺪاول اﻟﻤﺮاد رﺑﻄﻬﺎ وهﻲ أﺳﻤﺎء ﺳﻬﻠﺔ ﻣﺆﻗﺘﺔ‬
‫ﺑﺎﻟﺠﺪاول‪ .‬ﺗﺴﺘﺨﺪم ﻓﻘﻂ أﺛﻨﺎء ﺗﻨﻔﻴﺬ أﻣﺮ ‪ SELECT‬ﺣﻴﺚ ﺗﻔﻴﺪ ﻓﻲ اﺧﺘﺼﺎر اﻟﻮﻗﺖ وآﺘﺎﺑﺔ اﻷﻣﺮ‪.‬‬
‫وﻳﺘﻢ ﺗﻌﺮﻳﻒ ‪ Alias‬ﻓﻲ أﻣﺮ ‪ FROM‬ﻟﻜﻞ ﺟﺪول‪.‬‬
‫آﻤﺎ هﻮ ﻣﻮﺿﺢ ﺑﺎﻟﻤﺜﺎل‬

‫‪FROM employees e , departments d‬‬

‫ﺑﺤﻴﺚ ﻳﻜﺘﺐ أﺳﻢ اﻟﺠﺪول آﺎﻣﻼ ﺑﺘﺒﻌﺔ اﻻﺳﻢ اﻟﻤﺴﺘﻌﺎر ﻟﺔ ﻓﻔﻲ اﻟﻤﺜﺎل اﻟﺴﺎﺑﻖ آﺎن أﺳﻢ‬
‫اﻟﺠﺪول ‪ employees‬و اﻻﺳﻢ اﻟﻤﺴﺘﻌﺎر ﻟﺔ ‪e‬‬
‫وأﺳﻢ اﻟﺠﺪول اﻟﺜﺎﻧﻰ ‪ department‬واﻻﺳﻢ اﻟﻤﺴﺘﻌﺎر ﻟﺔ ‪. d‬‬

‫‪ .1‬اﻷﺳﻤﺎء اﻟﻤﺴﺘﻌﺎرة ﻟﻠﺠﺪاول ﻳﺠﺐ أَن ﺗﻜﻮن ﻓﻰ ﺣﺪود ‪ 30‬ﺣﺮف ﻓﻲ اﻟﻄﻮلِ ﻟﻜﻦ إذا‬
‫آﺎﻧﺖ أﻗﺼﺮ ﻓﻲ اﻟﻄﻮل آﺎن ذﻟﻚ أﻓﻀﻞ ‪.‬‬
‫‪ .2‬اﻻﺳﻢ اﻟﻤﺴﺘﻌﺎر ﻟﻠﺠﺪول ﻳﻜﻮن ﻓﻲ ﻓﻘﺮة ‪ ، FROM‬إذن ذﻟﻚ اﻻﺳﻢ اﻟﻤﺴﺘﻌﺎرِ ﻟﻠﺠﺪول‬
‫ﺐ أَن ﻳﺴﺒﻖ اﺳﻢ اﻟﻌﻤﻮد اﻟﻤﺮاد ﻋﺮﺿﺔ‪.‬‬ ‫ﻳﺠِ ُ‬
‫‪ .3‬اﻷﺳﻤﺎء اﻟﻤﺴﺘﻌﺎرة ﻟﻠﺠﺪاول ﻳﺠِﺐ أَن ﺗﻜُﻮن ذات ﻣﻐﺰى ‪.‬‬
‫ﻣﻦ اﻟﻤﻤﻜﻦ اﻟﺮﺑﻂ ﺑﻴﻦ أآﺜﺮ ﻣﻦ ﺟﺪول‬

‫وﻟﻜﻲ ﺗﻜﻮن هﺬﻩ اﻟﻌﻤﻠﻴﺔ ﺻﺤﻴﺤﺔ ﻓﺈن ﻋﺪد ﻋﻤﻠﻴﺎت اﻟﺮﺑﻂ داﺋﻤﺎ ﺗﻜﻮن أﻗﻞ ﻣﻦ ﻋﺪد اﻟﺠﺪاول‬
‫اﻟﻤﺴﺘﺨﺪﻣﺔ ﺑﻮاﺣﺪ‪.‬‬

‫ﺣﻴﺚ أن هﻨﺎك ﺛﻼث ﺟﺪاول ﺗﻢ اﻟﺮﺑﻂ ﺑﻴﻨﻬﻢ ﺑﻌﻤﻠﻴﺘﻲ رﺑﻂ ﻓﻘﻂ وهﻤﺎ‪:‬‬
‫‪e.department_id = d.department_id‬‬
‫‪d.location_id = l.location_id‬‬
 ‫‪Employees ,Department Location‬‬ ‫ﻓﻔﻰ اﻟﻤﺜﺎل اﻟﺴﺎﺑﻖ ﺗﻢ اﻟﺮﺑﻂ ﺑﻴﻦ ﺛﻼث ﺟﺪاول‬
‫وذﻟﻚ ﻟﻌﺮض اﻻﺳﻢ و اﺳﻢ اﻻدارة واﻟﻤﺪﻳﻨﺔ اﻟﺘﻰ ﺑﻬﺎ ﺗﻠﻚ اﻟﻘﺴﻢ‪.‬‬

‫‪More examples‬‬

‫ﻧﺴﺘﻄﻴﻊ اﺳ ﺘﺮﺟﺎع ﺑﻴﺎﻧ ﺎت ﻣ ﻦ أآﺜ ﺮ ﻣ ﻦ ﺟ ﺪول اذا آ ﺎن ﺑﻴ ﻨﻬﻢ ﻋﻼﻗ ﺔ ‪ Relation‬ﺣﻴ ﺚ آ ﻞ ﺻ ﻒ ﻣ ﻦ‬

‫اﺣﺪهﻤﺎ ﻳﺮﺗﺒﻂ ﻣﻊ ﺻﻒ ﻣﻦ اﻻﺧﺮ ﻋﻦ ﻃﺮﻳﻖ ﺣﻘﻞ ﻣﺸﺘﺮك‬
NAME, S_DEPT.NAME _SELECT S_EMP.DEPT_ID, S_EMP.LAST
FROM S_EMP, S_DEPT
WHERE S_EMP.DEPT_ID = S_DEPT.ID;

DEPT_ID LAST _ NAME NAME

------------------------------------------------
50 VELASQUEA ADMINISTRATION
41 NGAO OPERATOPN
31 NAGAYAMA SALES
50 OPEBURN ADMINISTRATION
41 RGIHART OPERATOPNS
42 MENCHU OPERATOPNS
43 BIRI OPERATOPNS
45 HAVEL OPERATOPNS

‫ ﻓﻨﻜﺘﺐ‬AND ‫ وذﻟﻚ ﺑﺎﺳﺘﺨﺪام‬WHERE ‫وﻳﻤﻜﻦ اﺿﺎﻓﺔ ﺷﺮط اﺧﺮ ﺑﻌﺪ‬

SELECT S_EMP.DEPT_ID, S_EMP.LAST _NAME, S_DEPT.NAME

FROM S_EMP, S_DEPT
WHERE S_EMP.DEPT_ID = S_DEPT.ID AND S_DEPT = 41;

: ‫ﻋﻨﺪ اﻟﺘﻔﻴﺬ ﻳﻨﺘﺞ‬

DEPT_ID LAST _ NAME NAME

------------------------------------------------
41 NGAO OPERATOPNS
41 URGIHART OPERATOPNS
 ‫اﻟﺮﺑﻂ اﻟﻐﻴﺮ ﻣﺘﺴﺎوي‬
‫‪NonEquiJoin‬‬

‫اﻟﻤﺮﺗﺒﺎت ﻓﻲ ﺟﺪول اﻟﻤﻮﻇﻔﻴﻦ ﻳﺠﺐ أن ﺗﻜﻮن ﺑﻴﻦ أﻗﻞ ﻣﺮﺗﺐ وأﻋﻠﻲ ﻣﺮﺗﺐ ﻓﻲ ﺟﺪول‬
‫‪. JOB_GRADES‬‬
‫اﻟﺮﺑﻂ اﻟﻐﻴﺮ ﻣﺘﺴﺎوي ) ‪ (NonEquiJoin‬ﺗﻮﺟﺪ ﺑﻪ ﻋﻼﻗﺔ ﻏﻴﺮ ﻣﺒﺎﺷﺮة ﻟﺮﺑﻂ ﺟﺪوﻟﻴﻦ وﻻ ﺗﺴﺘﺨﺪم‬
‫ﻓﻴﻪ إﺷﺎرة اﻟﺘﺴﺎوي)=(‪.‬‬
‫واﻟﻌﻼﻗﺔ ﺑﻴﻦ ﻋﻤﻮد اﻟﻤﺮﺗﺒﺎت ﻓﻲ ﺟﺪول اﻟﻤﻮﻇﻔﻴﻦ ﻳﺠﺐ أن ﺗﻜﻮن ﺑﻴﻦ أﻗﻞ ﻣﺮﺗﺐ وأﻋﻠﻲ ﻣﺮﺗﺐ‬
‫ﻓﻲ ﺟﺪول ‪.JOB_GRADES‬‬
‫ﻓﻔﻰ اﻟﻤﺜﺎل اﻟﺘﺎﻟﻰ ﻳﻘﻮم ﺑﻤﻌﺮﻓﺔ ﻣﺮآﺰ او ﻣﻮﻗﻊ ﻣﺮﺗﺐ آﻞ ﻣﻮﻇﻒ وذﻟﻚ ﺑﻤﻌﺮﻓﺔ ﻧﻄﺎق آﻞ ﺷﺮﻳﺤﺔ‬
‫ﻣﻦ اﻟﻤﺮﺗﺒﺎت )ﺑﺪاﻳﺘﻬﺎ وﻧﻬﺎﻳﺘﻬﺎ( وﻣﻘﺎرﻧﺘﻬﺎ ﺑﻤﺮﺗﺐ آﻞ ﻣﻮﻇﻒ ﻓﻰ ﺟﺪول اﻟﻤﻮﻇﻔﻴﻦ‪ .‬إذا آﺎن ﺿﻤﻦ‬
‫اﻟﺸﺮﻳﺤﺔ ﻓﺄﻧﻪ ﻳﻌﺮض اﺳﻢ اﻟﺸﺮﻳﺤﺔ‪.‬آﻤﺎ ﻓﻰ اﻟﻤﺜﺎل اﻟﺘﺎﻟﻰ‪...‬‬

‫ﻣﺜﺎل ﻳﻮﺿﺢ اﻟﺮﺑﻂ اﻟﻐﻴﺮ اﻟﻤﺘﺴﺎوي ‪NonEquiJoin‬‬

‫ﺣﻴﺚ ﻻ ﺗﻮﺟﺪ ﻋﻼﻗﺔ ﻣﺒﺎﺷﺮة ﺑﻴﻦ اﻟﺠﺪوﻟﻴﻦ ‪ employees e, job_grades‬اﻟﻤـﺮاد اﻟـﺮﺑﻂ ﺑﻴـﻨﻬﻢ‬
‫وﻟﺬك ﺗـﻢ اﺳـﺘﺨﺪام ‪ BETWEEN‬ﺑـﺪﻻ ﻣـﻦ ﻳـﺴﺎوي ﻓـﻲ ﺷـﺮط اﻟـﺮﺑﻂ‪ .‬ﻻﺣـﻆ ان ﻗﻴﻤـﺔ اﻟﻤﺮﺗـﺐ‬
‫ﻟﻠﻤﻮﻇﻒ ﺗﻤﺘﺪ ﺑﻴﻦ أﻗﻞ ﻗﻴﻤﺔ وأﻋﻠﻲ ﻗﻴﻤﺔ ﻣﺮﺗﺐ ﻓﻲ ﺟﺪول درﺟﺎت اﻟﻤﺮﺗﺐ‪.‬‬
‫آﻞ ﻣﺮﺗﺒـﺎت اﻟﻤـﻮﻇﻔﻴﻦ ﻣﻤﺘـﺪة ﺑﻮاﺳـﻄﺔ ﺟـﺪول درﺟـﺎت‪ .‬اﻟﻮﻇﻴﻔـﺔ ‪ JOB_GRADE‬ﻓـﻼ‬
‫ﻳﻮﺟﺪ ﻣﻮﻇﻒ ﻳﻜﺴﺐ أﻗﻞ ﻣﻦ أﺻﻐﺮ ﻗﻴﻤﺔ ﻓﻲ ﻋﻤـﻮد ‪ LOWEST_SAL‬وﻻ ﻳﻮﺟـﺪ ﻣﻮﻇـﻒ‬
‫ﻳﻜﺴﺐ أآﺜﺮ ﻣﻦ اﻟﻌﻤﻮد ‪. HIGHEST_SAL‬‬
‫ﻣﻼﺣﻈﺔ‪:‬‬
‫) =<(و ) =>( ﻳﻤﻜﻦ أَن ﺗﺴﺘﺨﺪم و ﻟﻜﻦ ‪ BETWEEN‬ﻟﻠﺘﺒﺴﻴﻂ ‪ .‬ﺗﺬآﺮ ﻋﻨﺪ ﺗﺤﺪﻳﺪ اﻟﻘﻴﻢ‬
‫ﻳﺠﺐ ان ﺗﻜﻮن أول ﻗﻴﻤﺔ ﻣﻨﺨﻔﻀﺔ وﺛﺎﻧﻲ ﻗﻴﻤﺔ ﻣﺮﺗﻔﻌﺔ وذﻟﻚ ﻋﻨﺪ اﺳﺘﺨﺪام ‪.BETWEEN‬‬
 ‫اﻟﺮﺑﻂ اﻟﺨﺎرﺟﻲ) ‪(outer join‬‬
‫ﻳﺴﺘﺨﺪم ﻟﻌﺮض ﺻﻔﻮف ﻣﻮﺟﻮدة ﺑﺎﻟﺠﺪول وﻟﻜﻦ ﻻ ﻳﻨﻄﺒﻖ ﻋﻠﻴﻬﺎ ﺷﺮط اﻟﺮﺑﻂ‬
‫وﻳﺘﻢ ذﻟﻚ ﺑﺎﺳﺘﺨﺪام إﺷﺎرة اﻟﺠﻤﻊ )‪ (+‬ﻣﻊ ﺷﺮط اﻟﺮﺑﻂ وﺗﻮﺿﻊ ﻓﻲ ﺟﻬﺔ اﻟﻌﻤﻮد اﻟﻤﺮاد ﻋﺮض‬
‫ﺑﻴﺎﻧﺎﺗﻪ ‪.‬‬

‫ﻻﺣﻆ ﻋﺪم وﺟﻮد ﻣﻮﻇﻔﻴﻦ ﻓﻲ اﻟﻘﺴﻢ ‪190‬‬

‫ﺑﺎﻟﻨﻈﺮ اﻟﻰ اﻟﺠﺪوﻟﻴﻦ ﻧﺠﺪ ان هﻨﺎك ادارة ﻣﻮﺟﻮدة ﻓﻰ ﺟﺪول اﻻﻗﺴﺎم وﻏﻴﺮ ﻣﻮﺟﻮدة ﻓﻰ ﺟﺪول‬
‫اﻟﻤﻮﻇﻔﻴﻦ ‪.‬ﻓﻠﻨﻔﺘﺮض ان هﺬة اﻻدارة ﺟﺪﻳﺪة وﻟﻢ ﻳﻌﻴﻦ ﺑﻬﺎ ﻣﻮﻇﻔﻴﻦ ﺣﺘﻰ اﻻن‪ .‬واردﻧﺎ ان ﻧﺮى ﺗﻠﻚ‬
‫اﻻدارة ﺑﻄﺮﻳﻘﺔ اﻟﺮﺑﻂ ‪ Equijoin‬آﻤﺎ ﻓﻰ اﻟﻤﺜﺎل اﻟﺘﺎﻟﻰ ﻓﻨﺠﺪ اﻧﻨﺎ ﻻ ﻳﻤﻜﻦ رؤﻳﺘﻬﺎ ﺑﺘﻠﻚ اﻟﻄﺮﻳﻘﺔ‬
‫وﻟﺬﻟﻚ ﻳﺘﻢ اﺳﺘﺨﺪام ﻃﺮﻳﻘﺔ اﻟﺮﺑﻂ ‪ Outer join‬آﻤﺎ ﺳﻮف ﻧﺮى‪.‬‬

‫ﻻﺣﻆ ان ﺗﻠﻚ اﻟﺼﻔﻮف ﻟﻴﺴﺖ آﺎﻣﻠﺔ ﺣﻴﺚ اﻧﺔ ﻟﻢ ﻳﻌﺮض اﻻدارات اﻟﺘﻰ ﻟﻴﺲ ﺑﻬﺎ‬
‫ﻣﻮﻇﻔﻴﻦ‪.‬وﻟﻤﻌﺎﻟﺠﺔ ذﻟﻚ ﻳﺘﻢ اﺳﺘﺨﺪام ‪. Outer Join‬‬

‫اﻟﺮﺑﻂ اﻟﺨﺎرﺟﻲ ‪Outer Join‬‬

‫* ﻳﺴﺘﺨﺪم ﻟﻜﻲ ﻳﻤﻜﻦ رؤﻳﺔ اﻟﺼﻔﻮف اﻟﺘﻲ ﻻ ﺗﻘﺎﺑﻞ ﺷﺮطَ اﻟﺮﺑﻂ ‪.‬‬
‫* ﻣﻌﺎﻣﻞ اﻟﺮﺑﻂ اﻟﺨﺎرﺟﻲِ هﻮ إﺷﺎر ُة اﻟﺰّاﺋﺪ )‪.(+‬‬

‫ﻳﺘﻢ اﺳﺘﺨﺪام إﺷﺎرة اﻟﺠﻤﻊ ﺟﻬﺔ اﻟﻌﻤﻮد اﻟﻤﺮاد ﻋﺮض ﺟﻤﻴﻊ ﺑﻴﺎﻧﺎﺗﻪ أﺛﻨﺎء ﻋﻤﻠﻴﺔ اﻟﺮﺑﻂ ﺑﻴﻦ‬
‫اﻟﻌﻤﻮدﻳﻦ وﺗﻮﺿﻊ ﻋﻼﻣﺔ )‪ (+‬ﺟﻬﺔ اﻟﻌﻤﻮد اﻟﺬي ﻳﻮﺟﺪ ﻓﻴﻪ اﻟﻨﻘﺺ ‪.‬وﻳﺠﺐ وﺿﻊ ﻋﻼﻣﺔ)‪ (+‬ﺑﻴﻦ‬
‫ﻗﻮﺳﻴﻦ ‪.‬‬
‫)‪ table2.column (+‬رﻣﺰ اﻟﺮﺑﻂ اﻟﺨﺎرﺟﻲ )‪ (+‬ﻳﻤﻜﻦ أَن ﻳﻮﺿﻊ ﻋﻠﻲ ﺟﺎﻧﺐ واﺣﺪ ﻓﻰ ﺷﺮط ﻓﻘﺮة‬
‫‪ WHERE‬ﻟﻜﻦ ﻻﻳﻤﻜﻦ ان ﻳﻮﺟﺪ ﻋﻠﻰ آﻼ ﻣﻦ اﻟﺠﺎﻧﺒﻴﻦ‪.‬‬
 ‫اﺳﺘﺨﺪام اﻟﺮﺑﻂ اﻟﺨﺎرﺟﻲ ‪Outer Join‬‬

‫ﻻ ﻳﻮﺟﺪ ﻣﻮﻇﻒ ﻓﻲ هﺬﻩ اﻟﺨﺎﻧﺔ‬

‫ﻓﻲ هﺬا اﻟﻤﺜﺎل ﺣﻴﺚ أﻧﺔ ﺗﻢ اﺳﺘﺨﺪام إﺷﺎرة اﻟﺠﻤﻊ ﺟﻬﺔ اﻟﻌﻤﻮد اﻟﻤﺮاد ﻋﺮض ﺟﻤﻴﻊ ﺑﻴﺎﻧﺎﺗﻪ‬
‫أﺛﻨﺎء ﻋﻤﻠﻴﺔ اﻟﺮﺑﻂ ﺑﻴﻦ اﻟﻌﻤﻮدﻳﻦ وﺗﻮﺿﻊ ﻋﻼﻣﺔ )‪ (+‬ﺟﻬﺔ اﻟﻌﻤﻮد اﻟﺬي ﻳﻮﺟﺪ ﻓﻴﻪ اﻟﻨﻘﺺ‪.‬واﻟﻤﺜﺎل‬
‫ﻳﻌﺮض ‪.department_name department_id ,last_name‬‬

‫ﻻﺣﻆ ان اﻟﻘﺴﻢ ‪ Contracting‬ﻻ ﻳﺸﺘﻤﻞ ﻋﻠﻲ أي ﻣﻮﻇﻔﻴﻦ‪.‬و إن اﻟﻘﻴﻤﺔ اﻟﻤﻌﺮوﺿﺔ ﻓﺎرﻏﺔ‬

‫وﻇﺎهﺮة ﻓﻲ اﻟﻨﺎﺗﺞ ‪.‬‬

‫‪More examples‬‬

‫اذا اردﻧﺎ اﻻﺳﺘﻌﻼم ﻋﻦ اﻟﺠﺰء اﻟﺬي ﻻ ﻳﺘﻮاﺟﺪ ﺑﻪ ﻣﻮﻇﻒ ﻧﻜﺘﺐ‬

‫‪SELECT‬‬ ‫‪s_emp.last_name, s_emp.id, , s_customer.name‬‬

‫‪FROM s_emp, s_customer‬‬
‫‪WHERE‬‬ ‫‪s_emp.id (+) = s_customer.sales_rep_id‬‬
‫;‪ORDER BY s_emp.id‬‬
 ‫اﻟﺮﺑﻂ اﻟﺪاﺧﻠﻲ ‪Self Join‬‬

‫رﻗﻢ اﻟﻤﻮﻇﻒ ﻓﻲ ﺟﺪول اﻟﻤﻮﻇﻔﻴﻦ‬

‫ﻳﺴﺎوي رﻗﻢ اﻟﻤﻮﻇﻒ ﻓﻲ ﺟﺪول اﻟﻤﺪﻳﺮ‬

‫اﻟﺮﺑﻂ اﻟﺪاﺧﻠﻲ ‪ Self Join‬ﻳﺴﺘﺨﺪم ﻟﺮﺑﻂ ﻋﻤﻮد ﺑﻌﻤﻮد ﺁﺧﺮ ﻓﻰ ﻧﻔﺲ اﻟﺠﺪول‪.‬‬
‫وهﻨــﺎ ﻓــﻰ هــﺬة اﻟﺤﺎﻟــﺔ ﻳﺠــﺐ ان ﺗﺘﺨﻴــﻞ اﻟﺠــﺪول اﻟﻮاﺣــﺪ)اﻟﻤــﻮﻇﻔﻴﻦ( ﺟــﺪوﻟﻴﻦ‪ .‬اﻟﺠــﺪول اﻻول‬
‫ﻟﻠﻤﻮﻇﻔﻴﻦ واﻟﺜﺎﻧﻰ ﻟﻠﻤـﺪﻳﺮﻳﻦ ﺣﻴـﺚ ان اﻟﻌﻤـﻮد ‪ Employee_ID‬ﻳﻌﺘﺒـﺮ ‪ Primary Key‬و اﻟﻌﻤـﻮد‬
‫‪ Manager_ID‬ﻳﻌﺘﺒﺮ ‪ Foreign Key‬ﻟﺔ‪.‬‬
‫وﺑﻬﺬا ﻳﻤﻜﻨﻚ اﻟﺘﻌﺎﻣﻞ ﻣﻊ ﺗﻠﻚ اﻟﺠﺪوﻟﻴﻦ ﺑﺎﻟﻄﺮق ‪ Equijoin‬او ‪.Outer join‬‬

‫ﻓﻰ اﻟﻤﺜﺎل اﻟﺴﺎﺑﻖ ﻳﺘﻢ إﻇﻬﺎر آﻞ ﻣﻮﻇﻒ ﺑﺠﺎﻧﺐ ﻣﺪﻳﺮة وﺑﻤﺎ أن اﻟﺮﺑﻂ ﺑﻴﻦ ﻋﻤﻮدﻳﻦ ﻓﻲ ﻧﻔﺲ‬
‫اﻟﺠﺪول ﻓﻘﺪ ﺗﻢ اﺳﺘﺨﺪام اﻻﺳﻢ اﻟﻤﺴﺘﻌﺎر ‪Employees worker, employees manager‬‬
‫وﺗﻢ اﺳﺘﺨﺪاﻣﻬﺎ آﻲ ﻳﺘﻢ اﻋﺘﺒﺎر اﻟﺠﺪول ﻋﺒﺎرة ﻋﻦ ﺟﺪوﻟﻴﻦ ﻣﻨﻔﺼﻠﻴﻦ وﻳﻤﻜﻦ رﺑﻄﻬﻤﺎ ﺑﻴﻦ‬
‫ﻋﻤﻮدﻳﻦ داﺧﻞ ﻧﻔﺲ اﻟﺠﺪول وﻗﺪ ﺳﻤﻲ ﺟﺪول اﻟﻤﻮﻇﻔﻴﻦ ﺑﺎﺳﻤﻴﻦ اﻷول وهﻮ ‪ Worker‬وﻳﻤﺜﻞ‬
‫اﻟﻤﻮﻇﻔﻴﻦ واﻟﺜﺎﻧﻲ ‪ Manager‬وهﻮ اﻟﻤﺪﻳﺮ ‪.‬‬

‫ﺣﻴﺚ أن رﻗﻢ اﻟﻤﺪﻳﺮ هﻮ أﺻﻼ رﻗﻢ ﻣﻮﻇﻒ ﻟﺬا ﻓﻘﺪ ﺗﻢ ﻣﺴﺎواة رﻗﻢ اﻟﻤﻮﻇﻒ ﺑﻌﻤﻮد أرﻗﺎم‬
‫اﻟﻤﻮﻇﻔﻴﻦ ﻓﻲ ﺟﺪول اﻟﻤﺪﻳﺮﻳﻦ ‪ Manager‬ﺑﺄرﻗﺎم اﻟﻤﺪﻳﺮﻳﻦ ﺑﻌﻤﻮد اﻟﻤﺪﻳﺮﻳﻦ ﻓﻲ ﺟﺪول‬
‫اﻟﻤﻮﻇﻔﻴﻦ ‪Worker‬‬
‫ﺣﻴﺚ أن اﻟﻤﻮﻇﻒ ﻓﻲ ﺟﺪول اﻟﻤﺪﻳﺮﻳﻦ هﻮ ﻣﺪﻳﺮ ﻓﻲ ﺟﺪول اﻟﻤﻮﻇﻔﻴﻦ‪.‬‬

‫* ﺗﻢ اﻇﻬﺎر ‪ 19‬ﻣﻮﻇﻒ ﻓﻘﻂ ‪،‬ﻣﻊ ان هﻨﺎك ‪ 20‬ﻣﻮﻇﻒ و هﺬاﺣﺪث ﻷن اﻟﻤﻮﻇﻒ ‪ King‬هﻮ‬

‫اﻟﺮّﺋﻴﺲ وﻻ ﻳﺮﺋﺴﺔ اﺣﺪ وﺑﺎﻟﺘﺎﻟﻰ ﻻ ﻳﻮﺟﺪ ﻟﺔ رﻗﻢ ﻣﺪﻳﺮ ﻓﻰ اﻟﻌﻤﻮد ‪ Manager_ID‬وﻟﻌﺮض‬
‫‪ KING‬ﻻﺑﺪ ﻣﻦ اﺳﺘﺨﺪام ‪. Outer Join‬‬
More examples

: ‫ﻣﺜﺎل‬
SELECT worker.last_name||' works for '||
manager.last_name
FROM s_emp worker, s_emp manager
WHERE worker.manager_id = manager.id;

‫ﻋﻨﺪ اﻟﺘﻨﻔﻴﺬ ﺳﻴﺘﻢ ﻃﺒﺎﻋﺔ‬

worker.last_name||' works for '||

manager.last_name
------------------------------------------------
Nago works for Velasquez
Nagayama works for Velasquez
Ropeburn works for Velasquez
Urguhart works for Nago
Biri works for Nago
Magee works for Nagayama
Giljum Nagayama
 ‫رﺑﻂَ اﻟﺠﺪاول ﺑﻄﺮق اﻟﺮﺑﻂ ﺑﻌﺪ ﺳﻨﺔ ‪1999‬‬

‫اﻟﺸﻜﻞ اﻻﺳﺎﺳﻰ ﻟﺘﻠﻚ اﻟﻄﺮق‪:‬‬

‫* ‪ CROSS JOIN‬ﻳﺴﺎوى ‪.Cartesian product‬‬

‫ﻂ ﺟﺪوﻟﻴﻦ ﻣﻌﺘﻤﺪ ﻋﻠﻰ ﻧﻔﺲ أﺳﻢ اﻟﻌﻤﻮدِ ﺑﺎﻟﺠﺪوﻟﻴﻦ‪.‬‬
‫* ‪ NATURAL JOIN‬ﻳﺮﺑ ُ‬
‫* ‪ JOIN table USING column_name‬ﻳﺴﺎوى اﻟﺮﺑﻂ اﻟﺒﺴﻴﻂ ) ‪( Equijoin‬‬
‫ﻣﻌﺘﻤﺪ ﻋﻠﻲ أﺳﻢ ﻋﻤﻮدِ‪.‬‬
‫* ‪ JOIN table ON‬ﻳﺴﺎوى اﻟﺮﺑﻂ اﻟﺒﺴﻴﻂ اﻳﻀﺎ ﻣﻌﺘﻤﺪ ﻋﻠﻲ اﻟﺸّﺮطِ ﺑﻌﺪ ‪. ON‬‬
‫* ‪ LEFT/RIGHT/FULL OUTER Join‬وهﻮ ﻧﻔﺲ ﻓﻜﺮة ‪.Outer Join‬‬

‫) ‪(cross join‬‬

‫وهﻲ ﻧﻔﺲ ‪. Cartesian Product‬‬

‫اﻟﻤﺜﺎل ﻳﻌﻄﻲ ﻧﻔﺲ اﻟﻨﺘﺎﺋﺞ ﺑﺎﺳﺘﺨﺪام اﻟﻄﺮﻳﻘﺔ اﻻوﻟﻰ ‪Cartesian Product‬‬

‫‪Natural Join‬‬
‫*ﻳﻌﺘﻤﺪ هﻨﺎ ﻋﻠﻰ أﻋﻤﺪة اﻟﺮﺑﻂ ﻓﻲ اﻟﺠﺪوﻟﻴﻦ اﻟﺬﻳﻦ ﻟﻬﺎ ﻧﻔﺲ اﻻﺳﻢ ‪.‬‬
‫* ﻳﺨﺘﺎر اﻟﺼﻔﻮف ﻣﻦ اﻟﺠﺪوﻟﻴﻦ اﻟﺘﻲ ﺗﻜﻮن ﻗﻴﻤﺘﻬﺎ ﻣﺘﺴﺎوﻳﺔ ﻓﻲ آﻞ اﻷﻋﻤﺪة اﻟﻤﺘﻨﺎﻇﺮة‪.‬‬
‫* إذا آﺎﻧﺖ اﻷﻋﻤﺪةَ ﻟﻬﺎ ﻧﻔﺲ اﻷﺳﻤﺎء وﻟﻜﻦ ﻧﻮع اﻟﺒﻴﺎﻧﺎت ﻣﺨﺘﻠﻒ ﻳﺤﺪث ﺧﻄﺄ ﻋﻨﺪ‬
‫اﻻﺳﺘﺨﻼص‪.‬‬
 Equijoin ‫وﺳﻮف ﻧﻌﺮض ﻧﻔﺲ اﻟﻨﺘﻴﺠﺔ ﺑﺎﺳﺘﺨﺪام‬

SELECT department_id, department_name,

departments.location_id, city
FROM departments, locations
WHERE departments.location_id = locations.location_id;

.WHERE ‫ ﻓﻰ ﻓﻘﺮة‬Natural Join ‫ﺷﺮط إﺿﺎﻓﻲ ﻋﻠﻲ‬

. 50 ‫ أو‬20 ِ‫ﻓﻴﺘﻢ ﺗﺤﺪﻳﺪ ﺻﻔﻮف اﻟﻨّﺎﺗﺞِ ﻟﻼﻗﺴﺎم‬

SELECT department_id, department_name,

location_id, city
FROM departments
NATURAL JOIN locations
WHERE department_id IN (20, 50);

USING ‫إﻧﺸﺎء اﻟﺮﺑﻂ ﺑﺎﺳﺘﺨﺪام‬

‫ن ﺗﺴﺘﺨﺪم‬ْ َ‫* إذا آﺎﻧﺖ اﻷﻋﻤﺪة ﻟﻬﺎ ﻧﻔﺲ اﻷﺳﻤﺎء ﻟﻜﻦ أﻧﻮاع اﻟﺒﻴﺎﻧﺎت ﻏﻴﺮ ﻣﻄﺎﺑﻘﺔ ﻓﻴﻤﻜﻨﻚ أ‬
. ‫ﺐ ان ﻳﺘﻢ اﻟﺮﺑﻂ ﺑﻬﺎ‬
ُ ِ‫ ﻓﻲ ﺗﺤﺪﻳﺪ اﻷﻋﻤﺪة اﻟﺘﻲ ﻳﺠ‬USING
.‫ آﻲ ﺗﻄﺎﺑﻖ ﻋﻤﻮد واﺣﺪﻓﻘﻂ ﻋﻨﺪﻣﺎ ﻳﻜﻮن أآﺜﺮ ﻣﻦ ﻋﻤﻮد ﻣﺘﻤﺎﺛﻞ‬USING ‫* ﺗﺴﺘﺨﺪم ﻓﻘﺮة‬
. ‫* ﻻ ﻳﺴﺘﺨﺪم أﺳﻢ اﻟﺠﺪول أو اﻷﺳﻢ اﻟﻤﺴﺘﻌﺎر ﻓﻲ اﻷﻋﻤﺪة اﻟﺘﻲ إﺳﺘﺮﺟﻌﺖ‬

.‫ ﺗﺴﺘﺨﺪم اﻷﻋﻤﺪةِ ﺑﻤﻄﺎﺑﻘﺔ اﻷﺳﻤﺎء وأﻧﻮاعِ اﻟﺒﻴﺎﻧﺎتِ ﻟﺮﺑﻂ اﻟﺠﺪاول‬Natural Join

.‫ ﻳﻤﻜﻦ أن ﺗﺴﺘﺨﺪم آﻲ ﺗﺤﺪد ﻓﻘﻂ ﺗﻠﻚ اﻷﻋﻤﺪةِ اﻟﺘﻲ ﻳﺠِﺐ اﻟﺮﺑﻂ ﺑﻬﺎ‬USING
‫آﻤﺜﺎل‬
SELECT l.citya, d.department_name
FROM locations l JOIN departments d USING (location_id)
WHERE location_id = 1400;
WHERE ‫ ﻓﻲ اﻟﻔﻘﺮة‬Alias ‫ﻟﻜﻦ هﺬا اﻟﻤﺜﺎل ﺧﻄﺄ ﻷﻧﺔ ﻻ ﻳﻤﻜﻦ اﺳﺘﺨﺪام‬
SELECT l.city, d.department_name
FROM locations l JOIN departments d USING (location_id)
WHERE d.location_id = 1400;

‫ﻻ ﻳﻤﻜﻦ أن ﺗﺸﺘﻤﻞ‬
Alias ‫ﻋﻠﻲ‬
ORA-25154: column part of USING clause cannot have qualifier
 ‫‪USING‬‬ ‫ﻣﺜﺎل ﻋﻠﻰ‬

‫اﻟﻤﺜﺎل ﻳﻈﻬﺮ رﺑﻂ ﻋﻤﻮد رﻗﻢ اﻟﻘﺴﻢ ﺑﺠﺪول اﻟﻤﻮﻇﻔﻴﻦ ﺑﺠﺪول اﻷﻗﺴﺎم وﺗﻌﺮض ﻟﻨﺎ ﻣﻮﻗﻊ ﻣﻜﺎن‬
‫ﻋﻤﻞ اﻟﻤﻮﻇﻒ‪.‬‬
‫وهﺬا اﻟﻤﺜﺎل ﻳﻤﻜﻦ ﺗﻨﻔﻴﺪة ﺑـ ‪ Equijoin‬آﻤﺎ ﻳﻠﻰ‪:‬‬
‫‪SELECT employee_id, last_name,‬‬
‫‪employees.department_id, location_id‬‬
‫‪FROM employees, departments‬‬
‫;‪WHERE employees.department_id = departments.department_id‬‬

‫ﻣﺜﺎل ﻋﻠﻰ ‪ON‬‬

‫ﺗﺴﺘﺨﺪم ﻓﻘﺮة ‪ ON‬آﻲ ﺗﺤﺪد ﺷﺮط اﻟﺮﺑﻂ ﺑﻴﻦ اﻟﺠﺪوﻟﻴﻦ‪.‬‬

‫ﻓﻘﺮة ‪ ON‬ﻳﻤﻜﻦ أن ﺗﺮﺑﻂ أﻋﻤﺪﻩ ﺑﻬﺎ أﺳﻤﺎء ﻣﺨﺘﻠﻔﺔ‪:‬‬

‫إن اﻟﻤﺜﺎل اﻟﺴﺎﺑﻖ ﻳﻌﺪ ‪ Self Join‬اى )رﺑﻂ داﺧﻠﻲ( ﻟﺠﺪول اﻟﻤﻮﻇﻔﻴﻦ‬
‫ﺑﻨﻔﺴﻪ ﻣﻌﺘﻤﺪ ﻋﻠﻲ أﻋﻤﺪة رﻗﻢ اﻟﻤﻮﻇﻒ ورﻗﻢ اﻟﻤﺪﻳﺮ ﺑﻨﻔﺲ اﻟﺠﺪول ‪.‬‬
 ‫اﻣﻜﺎﻧﻴﺔ اﺳﺘﺨﺪام اآﺜﺮ ﻣﻦ ﻃﺮﻳﻘﺔ رﺑﻂ‬

: Equijoin ‫وﻳﻤﻜﻦ ﺗﻨﻔﻴﺬ ﻧﻔﺲ اﻟﻤﺜﺎل اﻟﺴﺎﺑﻖ ﺑﻄﺮﻳﻘﺔ‬

SELECT employee_id, city, department_name
FROM employees, departments, locations
WHERE employees.department_id = departments.department_id
AND departments.location_id = locations.location_id;

: USING ‫وﻳﻤﻜﻦ ﺗﻨﻔﻴﺬ ﻧﻔﺲ اﻟﻤﺜﺎل ﺑﻄﺮﻳﻘﺔ اﻟﺮﺑﻂ‬

SELECT e.employee_id, l.city, d.department_name
FROM employees e
JOIN departments d
USING (department_id)
JOIN locations l
USING (location_id);

1999 ‫ﻗﺒﻞ ﺳﻨﺔ‬ 1999 ‫ﺑﻌﺪ ﺳﻨﺔ‬

 Left Outer Join

‫( ﻋﻨﺪ ﺗﻠﻚ اﻟﻌﻤﻮد آﻤﺎ ﻓﻰ‬+) ‫ وﺑﺪﻻ ﻣﻦ وﺿﻊ‬d.department_id ‫وهﺬا ﻳﻌﻨﻰ ان اﻟﻨﻘﺺ ﻓﻰ‬
.LEFT OUTER JOIN ‫ ﻳﺘﻢ اﺳﺘﺨﺪام‬Outer Join ‫اﻟﻄﺮﻳﻘﺔ‬

.‫( ﻳﺴﺎر اﻟﺸﺎﺷﺔ وﻟﻴﺲ ﻳﺴﺎر رؤﻳﺘﻚ‬+)‫ هﻨﺎ ﺗﻮﺿﻊ ﻋﻼﻣﺔ‬:‫ﻣﻠﺤﻮﻇﺔ‬

:‫واﻟﻤﺜﺎل اﻟﺘﺎﻟﻰ ﻳﻮﺿﺢ ذﻟﻚ‬
SELECT e.last_name, e.department_id, d.department_name
FROM employees e, departments d
WHERE d.department_id (+) = e.department_id;

Right Outer Join

‫( ﻋﻨﺪ ﺗﻠﻚ اﻟﻌﻤﻮد آﻤﺎ ﻓﻰ‬+) ‫ وﺑﺪﻻ ﻣﻦ وﺿﻊ‬e.department_id ‫وهﺬا ﻳﻌﻨﻰ ان اﻟﻨﻘﺺ ﻓﻰ‬
.Right OUTER JOIN ‫ ﻳﺘﻢ اﺳﺘﺨﺪام‬Outer Join ‫اﻟﻄﺮﻳﻘﺔ‬
:‫ﻣﻠﺤﻮﻇﺔ‬
.‫( ﻳﻤﻴﻦ اﻟﺸﺎﺷﺔ وﻟﻴﺲ ﻳﻤﻴﻦ رؤﻳﺘﻚ‬+)‫هﻨﺎ ﺗﻮﺿﻊ ﻋﻼﻣﺔ‬
:‫واﻟﻤﺜﺎل اﻟﺘﺎﻟﻰ ﻳﻮﺿﺢ ذﻟﻚ‬
SELECT e.last_name, e.department_id, d.department_name
FROM employees e, departments d
WHERE d.department_id = e.department_id (+);
 ‫‪Full outer join‬‬

‫هﺬا اﻻﺳﺘﻌﻼم ﻳﺴﺘﺮﺟﻊ آﻞ اﻟﺼﻔﻮف ﻓﻰ اﻟﺠﺪوﻟﻴﻦ ﺣﺘﻰ إذا آﺎﻧﺖ ﻏﻴﺮ ﻣﺘﻤﺎﺛﻠﺔ‬
‫ﺷﺮوط إﺿﺎﻓﻴﺔ‬

‫ﻳﻤﻜﻨﻚ ان ﺗﺴﺘﺨﺪم ﺑﻌﺾ اﻟﺸﺮوط اﻻﺿﺎﻓﻴﺔ ﺑﻌﺪ اﻟﺮﺑﻂ ﺑﻴﻦ اﻟﺠﺪوﻟﻴﻦ ﻟﺘﺤﺪﻳﺪ ﻋﺪد ﻣﻌﻴﻦ ﻣﻦ‬
‫اﻟﺼﻔﻮف‪.‬‬

‫أﻧﻮاع اﻟﺮواﺑﻂ‬
‫‪Equijoins‬‬ ‫اﻟﻤﺘﺴﺎوﻳﺔ )اﻟﺒﺴﻴﻄﺔ(‬ ‫اﻟﺮواﺑﻂ‬
‫‪Non-equijoins‬‬ ‫اﻟﻐﻴﺮ ﻣﺘﺴﺎوﻳﺔ‬ ‫اﻟﺮواﺑﻂ‬
‫‪Outer joins‬‬ ‫اﻟﺨﺎرﺟﻴﺔ‬ ‫اﻟﺮواﺑﻂ‬
‫‪Self joins‬‬ ‫اﻟﺪاﺧﻠﻴﺔ‬ ‫اﻟﺮواﺑﻂ‬
‫‪Cross joins‬‬ ‫اﻟﺘﻘﺎﻃﻌﻴﺔ‬ ‫اﻟﺮواﺑﻂ‬
‫‪Natural joins‬‬ ‫اﻟﻄﺒﻴﻌﻴﺔ‬ ‫اﻟﺮواﺑﻂ‬
‫‪Full or outer joins‬‬ ‫اﻟﻤﺘﻜﺎﻣﻠﺔ أو اﻟﺮواﺑﻂ اﻟﺨﺎرﺟﻴﺔ‬ ‫اﻟﺮواﺑﻂ‬

‫ﻣﻠﺨﺺ اﻟﻔﺼﻞ‪.‬‬

‫ﺗﻨﺎوﻟﻨﺎ ﻓﻲ هﺬا اﻟﻔﺼﻞ ﺟﻤﻞ ‪ SQL‬اﻟﺨﺎﺻﺔ ﺑﺎﺳﺘﺮﺟﺎع ﺑﻴﺎﻧﺎت ﻣﻦ اآﺜﺮ ﻣﻦ ﺟﺪول‬

‫آﻐﺮض رﻗﻢ اﻗـﺴﻢ اﻟﻤـﻮﻇﻔﻴﻦ ﻣـﻦ ﺟـﺪول اﻟﻤـﻮﻃﻔﻴﻦ وﺗﻄﺮﻗﻨـﺎ آـﺬﻟﻚ إﻟـﻰ ﻋﻤﻠﻴـﺔ‬
‫اﺳﺘﺮﺟﺎع اﻟﺒﻴﺎﻧﺎت ﻣﻦ ﺧﻼل اﺳﻢ ﻣﺴﺘﻌﺎر‬
 ‫‪Subqueries‬‬
‫هﺪف اﻟﺪرس‪:‬‬
‫ﻣﻌﺮﻓﺔ اﻧﻮاع و ﻣﻤﻴﺰات اﺳﺘﺨﺪام ‪ Subqueries‬ﺣﻴﺚ اﻧﻬﺎ ﺗﻌﺎﻟﺞ اﻟﻜﺜﻴﺮ ﻣﻦ اﻟﻤﺸﺎآﻞ‪.‬‬
‫ﻓﻲ ﻓﻘﺮة ‪. WHERE‬‬ ‫أﻧﺖ ﻳﻤﻜﻦ أَن ﺗﻜﺘﺐ اﺳﺘﻌﻼم ﻓﺮﻋﻲ‬
‫‪ . SMITH‬ﻟﻜﻰ ﺗﺤﻞ‬ ‫ﻟﻨﻔﺘﺮض أﻧﻚ ﺗﺮﻳﺪ ﻣﻌﺮﻓﺔ اﻟﻤﻮﻇﻔﻴﻦ اﻟﺬﻳﻦ ﺗﺰﻳﺪ رواﺗﺒﻬﻢ ﻋﻦ اﻟﻤﻮﻇﻒ‬
‫هﺬﻩ اﻟﻤﺸﻜﻠﺔ ﺗﺤﺘﺎج اﻟﻰ أﺳﺘﻌﻼﻣﻴﻦ‪:‬‬
‫اﺳﺘﻌﻼم ﻹﻳﺠﺎد راﺗﺐ اﻟﻤﻮﻇﻒ ‪. SMITH‬‬
‫اﺳﺘﻌﻼم ﻹﻳﺠﺎد اﻟﻤﻮﻇﻔﻴﻦ اﻟﺬﻳﻦ ﺗﺰﻳﺪ رواﺗﺒﻬﻢ ﻋﻦ اﻟﻤﺒﻠﻎ اﻟﻤﺤﺴﻮب ﻓﻲ اﻻﺳﺘﻌﻼم اﻷول‪.‬‬

‫اﻻﺳﺘﻌﻼم اﻟﻔﺮﻋﻲ‬
‫ﻣﻘﺪﻣﺔ‬

‫ﻟﻨﻔﺘﺮض أﻧﻚ ﺗﺮﻏﺐ ﻓﻲ آﺘﺎﺑ ﺔ اﺳ ﺘﻌﻼم ﻹﻳﺠ ﺎد ﺑﻴﺎﻧ ﺎت اﻟﻤ ﻮﻇﻔﻴﻦ اﻟ ﺬﻳﻦ ﺗﺰﻳ ﺪ رواﺗ ﺒﻬﻢ ﻋ ﻦ راﺗ ﺐ أﺣ ﺪ‬
‫اﻟﻤﻮﻇﻔﻴﻦ‬
‫ﻓﻲ هﺬﻩ اﻟﺤﺎﻟﺔ ﺗﺤﺘﺎج اﻟﻰ اﺳﺘﻌﻼﻣﻴﻦ‬
‫اﺳﺘﻌﻼم ﻻﻳﺠﺎد راﺗﺐ اﻟﻤﻮﻇﻒ اﻟﻤﻌﻨﻲ‬ ‫‪-1‬‬
‫اﺳﺘﻌﻼم ﻻﻳﺠﺎد اﻟﻤﻮﻇﻔﻴﻦ اﻟﺬﻳﻦ ﺗﺰﻳﺪ رواﺗﺒﻬﻢ ﻋﻦ اﻟﻤﺒﻠﻎ اﻟﻤﺤﺴﻮب ﻓﻲ اﻻﺳﺘﻌﻼم اﻷول‬ ‫‪-2‬‬

‫وﻳﻤﻜﻨﻚ دﻣﺞ اﻻﺳﺘﻌﻼﻣﻴﻦ وذﻟﻚ ﺑﺮﺗﻜﻴﺐ اﺣﺪ اﻻﺳﺘﻌﻼﻣﻴﻦ ﻓﻲ اﻻﺧﺮ ‪ ،‬اﻻﺳﺘﻌﻼم اﻟﺪاﺧﻠﻲ ﺳ ﻮف ﻳﻌ ﻮد‬
‫ﺑﻘﻴﻤﺔ )ﻗﻴﻢ( واﻟﺘﻲ ﻳﺴﺘﺨﺪﻣﻬﺎ اﻻﺳﺘﻌﻼم اﻟﺨﺎرﺟﻲ )اﻟﺮﺋﻴﺴﻲ(‬
‫إن اﺳ ﺘﺨﺪام اﻻﺳ ﺘﻌﻼﻣﺎت اﻟﻔﺮﻋﻴ ﺔ ﻳ ﺸﺒﻪ ﺗﻤﺎﻣ ﺎ ﺗﻨﻔﻴ ﺬ اﻻﺳ ﺘﻌﻼﻣﻴﻦ ﺑ ﺸﻜﻞ ﻣﺘﺘ ﺎل واﺳ ﺘﻼﻋﻢ ﻧﺘﻴﺠ ﺔ‬
‫اﻻﺳﺘﻌﻼم اﻻول آﻨﺘﻴﺠﺔ ﺑﺤﺚ ﻓﻲ اﻻﺳﺘﻌﻼم اﻟﺜﺎﻧﻲ‬

‫ﻧﻌﺮﻳﻒ اﻻﺳﺘﻌﻼم اﻟﻔﺮﻋﻲ‬

‫هﻮ ﺟﻤﻠﺔ اﺳﺘﻔﺴﺎر ‪ SELECT‬ﻣﻀﻤﻨﺔ داﺧﻞ ﺟﻤﻠﺔ اﺳﺘﻔ ﺴﺎر رﺋﻴ ﺴﻴﺔ ﻻﺳ ﺘﺮﺟﺎع ﻗﻴﻤ ﺔ أو ﻣﺠﻤﻮﻋ ﺔ‬
‫ﻣﻦ اﻟﻘﻴﻢ ﻟﻴﺘﻢ اﺳﺘﺨﺪاﻣﻬﺎ ﻓﻲ اﻻﺳﺘﻌﻼم اﻟﺮﺋﻴﺴﻲ اﻧﻈﺮ اﻟﺸﻜﻞ اﻟﺘﺎﻟﻲ‬
 ‫اﻟﺸﻜﻞ اﻟﻌﺎم‬

‫‪SELECT‬‬ ‫‪select_listFROM tableWHERE‬‬ ‫‪expr operator‬‬

‫‪(SELECT select_list‬‬
‫‪FROM‬‬ ‫;)‪table‬‬

‫ﻣﻼﺣﻈﺔ‬
‫اﻻﺳﺘﻌﻼم اﻟﺪاﺧﻠﻲ)اﻟﻔﺮﻋﻲ( ﻳﻨﻔﺬ اوﻻ‬ ‫‪-1‬‬
‫ﻧﺎﺗﺞ اﻻﺳﺘﻌﻼم اﻟﺪاﺧﻠﻲ)اﻟﻔﺮﻋﻲ( ﻳﺴﺘﺨﺪم ﻓﻲ اﻻﺳﺘﻌﻼم اﻟﺮﺋﻴﺴﻲ‬ ‫‪-2‬‬

‫ﻣﺘﻄﻠﺒﺎت اﻻﺳﺘﻌﻼم اﻟﻔﺮﻋﻲ‬

‫وﺿﻊ اﻻﺳﺘﻌﻼم اﻟﻔﺮﻋﻲ ﺑﻴﻦ ﻗﻮﺳﻴﻦ )‪(.......‬‬ ‫‪-1‬‬

‫‪.‬وﺿﻊ اﻻﺳﺘﻌﻼم اﻟﻔﺮﻋﻲ ﻳﻤﻴﻦ ﻋﻤﻠﻴﺔ اﻟﻤﻘﺎرﻧﺔ‬ ‫‪-2‬‬
‫ﻻ ﻳﻤﻜﻦ اﺳﺘﺨﺪام ‪ ORDER BY‬داﺧﻞ اﻻﺳﺘﻌﻼم اﻟﻔﺮﻋﻲ‬ ‫‪-3‬‬
‫اﺳﺘﺨﺪام اﻟﻤﻌﺎﻣﻼت أﺣﺎدﻳﺔ اﻟﺼﻒ ﻣﻊ اﻻﺳﺘﻌﻼﻣﺎت اﻟﻔﺮﻋﻴﺔ اﻷﺣﺎدﻳﺔ اﻟﺼﻒ‬ ‫‪-4‬‬
‫اﺳﺘﺨﺪام اﻟﻤﻌﺎﻣﻼت ﻣﺘﻌﺪدة اﻟﺼﻒ ﻣﻊ اﻻﺳﺘﻌﻼﻣﺎت اﻟﻔﺮﻋﻴﺔ اﻟﻤﺘﻌﺪدة اﻟﺼﻒ‬ ‫‪-5‬‬

‫أﻧﻮاع اﻻﺳﺘﻌﻼﻣﺎت اﻟﻔﺮﻋﻴﺔ‬

‫ﻳﻤﻜﻦ ﺗﺼﻨﻴﻒ اﻻﺳﺘﻌﻼم اﻟﻔﺮﻋﻲ ﺣﺴﺐ‬

‫اﺳﺘﻌﻼم ﻓﺮﻋﻲ أﺣﺎدي اﻟﺼﻒ ﻳﺴﺘﺮﺟﻊ ﺻﻔﺎ واﺣﺪا‬ ‫‪-1‬‬

‫اﺳﺘﻌﻼم ﻓﺮﻋﻲ ﻣﺘﻌﺪد اﻟﺼﻔﻮف ﻳﺴﺘﺮﺟﻊ أآﺜﺮ ﻣﻦ ﺻﻒ واﺣﺪ‬ ‫‪-2‬‬
 ‫‪SINGLE ROW SUBQUERY‬‬
‫‪.‬‬ ‫‪ ,‬اﺳﺘﺨﺪام ﻋﻮاﻣﻞ اﻟﻤﻘﺎرﻧﺔ ﻣﻊ اﻟﺼﻔﻮف اﻷﺣﺎدﻳﺔ‬ ‫* اﺳﺘﺮﺟﺎع ﺻﻒ واﺣﺪ ﻓﻘﻂ‬
‫اﻟﻤﻌﺎﻣﻼت‬

‫=‬

‫>‬

‫=>‬

‫<‬

‫=<‬

‫><‬

‫ﻣـﺜـﺎﻟـ ‪ :‬ﻋﺮض اﻟﻤﻮﻇﻔﻴﻦ اﻟﺬﻳﻦ وﻇﻴﻔﺘﻬﻢ ﻧﻔﺲ وﻇﻴﻔﺔ اﻟﻤﻮﻇﻒ ‪. 141‬‬

 ‫اﺳﺘﺨﺪام اﻻﺳﺘﻌﻼم اﻟﻔﺮﻋﻲ أﺣﺎدﻳﺔ اﻟﺼﻒ‬

‫وﻳﻤﻜﻦ اﺳﺘﺨﺪام ‪ Sub Query‬اآﺜﺮ ﻣﻦ ﻣﺮة آﻤﺎ ﻓﻰ اﻟﻤﺜﺎل اﻟﺘﺎﻟﻰ‪:‬‬

‫ﻳﺘﻀﻤﻦ اﻟﻤﺜﺎل ﻋﻠﻲ ﺛﻼث اﺳﺘﻌﻼﻣﺎت‪ :‬اﻻﺳﺘﻌﻼم اﻟﺨﺎرﺟﻲ واﺳﺘﻌﻼﻣﻴﻦ داﺧﻠﻴﻦ‪.‬‬

‫اﻻﺳﺘﻌﻼم اﻟﺪاﺧﻠﻰ‪ :‬اﻻول ﻳﻨﻔﺬ اوﻻ وﻳﺨﺮج ﻟﻨﺎ اﻟﻮﻇﻴﻔﺔ ‪ST_CLERK‬‬
‫واﻻﺳﺘﻌﻼم اﻟﺪاﺧﻠﻰ‪ :‬اﻟﺜﺎﻧﻰ ﻳﻨﻔﺬ ﺑﻌﺪة و ﻳﺨﺮج ﻟﻨﺎ اﻟﻤﺮﺗﺐ ‪ 2600‬ﺛﻢ ﺑﻌﺪ ذﻟﻚ ﻳﺘﻢ‬
‫اﻻﺳﺘﻌﻼم اﻟﺨﺎرﺟﻰ) ‪ :(OUTER QUERY‬ﺑﻨﺎء ﻋﻠﻰ ﻧﺘﻴﺠﺔ اﻻﺳﺘﻌﻼﻣﻴﻦ اﻟﺴﺎﺑﻘﻴﻦ‬
‫آﻠﺘﺎ اﻻﺳﺘﻌﻼﻣﺎت اﻟﺪاﺧﻠﻴﺔ ﺗﺴﺘﺮﺟﻊ ﻗﻴﻢ واﺣﺪة ) ‪ ST_CLEARK‬و ‪ (2600‬ﻋﻠﻲ اﻟﺘﻮاﻟﻲ وهﺬا‬
‫ﻳﺴﻤﻲ اﺳﺘﻌﻼﻣﺎت ﻓﺮﻋﻴﺔ أﺣﺎدﻳﺔ اﻟﺼﻒ‪.‬وﻟﺬﻟﻚ ﺗﻢ اﺳﺘﺨﺪام )= و >(‪.‬‬
‫‪ INEER QUERY‬ﻳﻤﻜﻦ أن‬ ‫ﻣﻼﺣﻈﺔ‪ :‬اﻻﺳﺘﻌﻼﻣﺎت اﻟﺨﺎرﺟﻴﺔ ‪ OUTER QUERY‬واﻟﺪاﺧﻠﻴﺔ‬
‫ﺗﺤﺼﻞ ﻋﻠﻲ ﺑﻴﺎﻧﺎت ﻣﻦ ﺟﺪاول ﻣﺨﺘﻠﻔﺔ ﻣﺜﻞ ‪:‬‬
‫‪Select ename, job from EMP‬‬
‫;)'‪Where deptno=any(select deptno from dept where dname='ACCOUNTING‬‬

‫‪ SubQuery‬ﻣﻦ ﺟﺪول اﻻﻗﺴﺎم وﺗﻢ ﻣﻘﺎرﻧﺘﻬﺎ ﻣﻊ ﺑﻴﺎﻧﺎت‬ ‫ﻓﻔﻰ اﻟﻤﺜﺎل اﻟﺴﺎﺑﻖ آﺎﻧﺖ ﻧﺘﻴﺠﺔ‬
‫ﻣﻦ ﺟﺪول اﻟﻤﻮﻇﻔﻴﻦ ‪.‬‬
‫‪Subquery‬‬ ‫ﻳﻤﻜﻦ اﺳﺘﺨﺪام ‪ Group Functions‬ﻣﻊ‬

‫اﺳﺘﺨﺪام ‪ HAVING‬ﻣﻊ ‪Sub query‬‬

‫)‪ (SubQuery‬وﻟﻴﺲ ﻓﻘﻂ‬ ‫‪ -‬ﻓﻘﺮة ‪ HAVING‬ﻳﻤﻜﻦ أَن ﺗﺴﺘﺨﺪم ﻣﻊ َاﻻﺳﺘﻌﻼﻣﺎت اﻟﻔﺮﻋﻴﺔ‬
‫‪. WHERE‬‬
‫ِ‬ ‫ﻓﻲ اﻟﻔﻘﺮة‬
‫م ـ ث ـ ال ـ ‪:‬‬
‫أوﺟﺪ رﻗﻢ اﻟﻤﻮﻇﻒ واﺳﻤﺔ ﻟﻠﻤﻮﻇﻔﻴﻦ اﻟﺬﻳﻦ ﻳﺎﺧﺬون اﻗﻞ ﻣﺮﺗﺐ ﻓﻰ آﻞ ﻗﺴﻢ‪.‬‬

‫ﻣﺎ اﻟﺨﻄﺄ ﻓﻲ هﺬا اﻻﺳﺘﻌﻼم؟‬

‫اﻟﺨﻄﺄ هﻨﺎ ان ‪ SubQuery‬ﻳﻨﺘﺞ ﻋﻨﻬﺎ اآﺜﺮ ﻣﻦ ﻧﺘﻴﺠﺔ وﺗﻢ ﻣﻘﺎرﻧﺘﻬﺎ ﺑﺎﻟﻤﻌﺎﻣﻞ ﻳﺴﺎوى )=(‬
‫وﻟﻤﻌﺎﻟﺠﺔ ذﻟﻚ ﻳﺠﺐ اﺳﺘﺨﺪام اﻟﻔﻘﺮة ) ‪ (= ANY‬آﻤﺎ ﻳﻠﻰ‪:‬‬
‫‪Select employee_id, last_name from Employees‬‬
‫;)‪Where salary =any (select min (salary) from Employees group by department‬‬
‫‪-‬هﻞ هﺬا اﻻﺳﺘﻌﻼم ﺳﻮف ﻳﺴﺘﺮﺟﻊ ﺻﻔﻮف؟‬

‫ﻣﻼﺣﻈﺔ‪:‬‬
‫ﺳﺒﺐ اﻟﻨﺘﻴﺠﺔ اﻟﺴﺎﺑﻘﺔ ان ‪ Sub Query‬آﺎﻧﺖ ﻧﺘﻴﺠﺘﻬﺎ ‪. NULL‬‬

‫اﻻﺳﺘﻌﻼم اﻟﻔﺮﻋﻲ ﻟﻠﺼﻔﻮف اﻟﻤﺘﻌﺪد‬

‫* اﺳﺘﺮﺟﺎع أآﺜﺮ ﻣﻦ ﺻﻒ واﺣﺪ‬
‫* اﺳﺘﺨﺪام ﻣﻌﺎﻣﻼت اﻟﻤﻘﺎرﻧﺔ ﻟﻠﺼﻔﻮف اﻟﻤﺘﻌﺪدة‪.‬‬

‫اﻟﻤﻌﺎﻣﻞ‬ ‫اﻟﻤﻌﻨﻲ‬

‫‪IN‬‬ ‫اﻟﺒﺤﺚ ﻋﻦ ﻗﻴﻤﺔ ﻣﻦ ﺑﻴﻦ ﻣﺠﻤﻮﻋﺔ ﻣﻦ اﻟﻘﻴﻢ‬

‫‪ANY‬‬ ‫ﻳﻘﺎرن ﻗﻴﻤﺔ ﺑﺎى ﻗﻴﻤﺔ ﻣﺴﺘﺮﺟﻌﺔ ﺑﻮاﺳﻄﺔ اﻻﺳﺘﻌﻼﻣﺎت اﻟﻔﺮﻋﻴﺔ‬

‫‪ALL‬‬ ‫ﻣﻘﺎرﻧﺔ ﻗﻴﻤﺔ ﻟﻜﻞ اﻟﻘﻴﻢ اﻟﻤﺴﺘﺮﺟﻌﺔ‬

 ‫اﺳﺘﺨﺪام ﻣﻌﺎﻣﻞ ‪ALL‬‬

‫اﻟﻤﺜﺎل اﻟﺴﺎﺑﻖ ﻳﺮﻳﺪ ﻣﻌﺮﻓﺔ اﻟﻤﻮﻇﻔﻴﻦ اﻟﺬﻳﻦ ﻳﻘﻞ ﻣﺮﺗﺒﻬﻢ ﻋﻦ ﻣﺮﺗﺐ اﻟﻤﻮﻇﻔﻴﻦ‬
‫ﺑﻮﻇﻴﻔﺔ ‪. IT_PROG‬‬
‫‪. SubQuery‬‬ ‫‪ ALL‬ﻳﻘﺎرن اﻟﻘﻴﻢ ﺑﻜﻞ اﻟﻘﻴﻢ اﻟﺘﻲ اﺳﺘﺮﺟﻌﺖ ﻣِﻦ‬ ‫ﻣﻌﺎﻣﻞ‬
‫ﻗﻴﻤﺔ ‪ Null‬ﻓﻲ اﻻﺳﺘﻌﻼم اﻟﻔﺮﻋﻲ‬

‫ﻋﻨﺪﻣﺎ ﺗﻜﻮن ﻧﺘﻴﺠﺔ ‪ NULL = SUb Query‬ﻓﻬﺬا ﻳﻌﻨﻰ ان هﺬا اﻻﺳﺘﻌﻼم ﺗﻜﻮن ﻧﺘﻴﺠﺘﺔ‬
‫‪. NO ROWS SELECTED‬‬
‫اﻟﻤﻌﺎﻣﻞ ‪ IN‬ﻳﺴﺎوى )‪(=ANY‬‬
‫‪Select ename, job from EMP where‬‬
‫;)‪Sal in (select max (sal) from EMP group by deptno‬‬

‫اﻟﻤﺜﺎل اﻟﺴﺎﺑﻖ ﻳﺮﻳﺪ اﻻﺳﺘﻌﻼم ﻋﻦ اﻟﻤﻮﻇﻔﻴﻦ اﻟﺬﻳﻦ ﻳﺎﺧﺬون اﻋﻠﻰ ﻣﺮﺗﺐ ﺑﻜﻞ ﻗﺴﻢ‪.‬‬
‫ﻳﻤﻜﻦ اﺳﺘﺨﺪام ) ‪ (=ANY‬ﺑﺪﻻ ﻣﻦ ) ‪ (IN‬ﻓﻰ اﻟﻤﺜﺎل اﻟﺴﺎﺑﻖ وﺗﻜﻮن ﺑﻨﻔﺲ اﻟﻨﺘﻴﺠﺔ ‪:‬‬
‫‪select ename,job from EMP where‬‬
‫;)‪sal =any(select max(sal) from EMP group by deptno‬‬

‫ﻣﻠﺨﺺ اﻟﻔﺼﻞ‬

‫ﻓﻲ هﺬا اﻟﻔﺼﻞ ﺗﻌﺮﻓﻨﺎ ﻋﻠﻰ اﻻﺳﺘﻌﻼﻣﺎت اﻟﻔﺮﻋﻴﺔ واهﻤﻴﺘﻬﺎ‬

‫وﺷﺮوﻃﻬﺎ واﻧﻮاﻋﻬﺎ اﻷﺣﺎدﻳﺔ واﻟﻤﺘﻌﺪدة‬
 ‫‪Using set operators‬‬
‫ﺑﻌﺪ اﻻﻧﺘﻬﺎء ﻣﻦ هﺬا اﻟﻔﺼﻞ ﻳﺠﺐ أن ﺗﻜﻮن ﻋﻠﻰ ﻣﻌﺮﻓﺔ اﻟﺘﺎﻟﻰ ‪-:‬‬
‫‪ -‬أﻧﻮاع اﻟـ ‪set operator‬‬
‫‪ -‬دﻣﺞ أآﺜﺮ ﻣﻦ ‪ query‬داﺧﻞ ‪ query‬واﺣﺪ‬

‫‪ -:Union‬ﺗﻌﺮض ﻟﻚ آﻞ اﻟﺼﻔﻮف اﻟﻐﻴﺮ ﻣﻜﺮرة ﻓﻰ أى ﻣﻦ اﻷﺳﺘﻌﻼﻣﺎت اﻟﻤﻮﺟﻮدة‪.‬‬

‫‪ -:Unionall‬ﺗﻌﺮض آﻞ اﻟﺼﻔﻮف ﺣﺘﻰ اﻟﻤﻜﺮر ﻣﻨﻬﺎ‪.‬‬
‫‪ -:Inteisect‬ﺗﻌﺮض آﻞ اﻟﺼﻔﻮف اﻟﻐﻴﺮ ﻣﻜﺮرة و اﻟﻤﺘﺸﺎﺑﻬﺔ ﻓﻜﻞ ﻣﻦ اﻷﺳﺘﻌﻼﻣﺎت‬
‫اﻟﻤﻮﺟﻮدة‪.‬‬
‫‪ -:Minus‬ﺗﻌﺮض ﻟﻚ آﻞ اﻟﺼﻔﻮف ﻏﻴﺮ اﻟﻤﺘﺸﺎﺑﻬﺔ اﻟﻤﺨﺘﺎرة ﻣﻦ اﻟـ ‪ query‬اﻻوﻟﻰ و ﻟﻢ‬
‫ﺗﺨﺘﺎر ﻣﻦ ﺧﻼل اﻟـ ‪ query‬اﻟﺜﺎﻧﻰ‪.‬‬
‫‪ -:Union‬ﺳﺘﻌﺮض ﺟﻤﻴﻊ اﻟﺼﻔﻮف اﻟﻨﺎﺗﺠﺔ ﻋﻦ اﻟـ ‪ query‬اﻻوﻟﻰ و اﻟﺜﺎﻧﻴﺔ وﻧﻼﺣﻆ أﻧﻬﺎ‬
‫ﻟﻢ ﺗﻌﺮض اﻟﺼﻔﻮف اﻟﻤﺘﻜﺮرة اﻟﻨﺎﺗﺠﺔ ﻣﻦ اﻟـ ‪ query‬اﻻوﻟﻰ و اﻟﺜﺎﻧﻴﺔ‪.‬‬
‫* وﻟﻜﻦ ﺳﻨﺠﺪ رﻗﻢ اﻟﻤﻮﻇﻒ ‪ 200‬ﻣﺘﻜﺮر وهﺬا ﻷن اﻟﻮﻇﻴﻔﺔ ﺗﺘﻐﻴﺮ آﻞ ﻣﺮة ﻟﻠﻤﻮﻇﻒ رﻗﻢ‬
‫‪ 200‬ﻓﻬﻮ ﻣﺴﺠﻞ ﻓىﺠﺪول اﻟـ ‪ employee‬ﺑﻮﻇﻴﻔﺔ ‪ Ad-AssT‬وﻳﻮﺟﺪ أﻳﻀﺎ ﻓﻰ ﺟﺪول‬
‫اﻟـ ‪ Jop history‬ﻣﺮة وﻇﻴﻔﺘﺔ‬
‫‪ Ad-AssT‬و اﻷﺧﺮى ‪ AC-Account‬و ﻷن ‪ Union‬ﺗﻤﻨﻊ اﻟﺘﻜﺮار ﻓﺂن اﻟﻮﻇﻴﻔﺔ‬
‫‪ AD-Asst‬ﻟﻢ ﺗﻈﻬﺮ ﻣﺮﺗﻴﻦ‪.‬‬
‫ﻣﻠﺤﻮﻇﺔ اﻟـ ‪ Null‬ﻻ ﺗﺤﺬف أﺛﻨﺎء ﺗﻜﺮارهﺎ‪.‬‬
‫‪------------------------------------------------------‬‬
‫ﻋﻨﺪﻣﺎ ﻧﺴﺘﺨﺪم ‪ Union‬أﻳﻀﺂ ﻓﻰ ﺣﺎﻟﺔ أﺿﺎﻓﺔ ‪ Column‬اﻟـ ‪ Department‬ﻧﻼﺣﻆ أن‬
‫اﻟﻤﻮﻇﻒ رﻗﻢ ‪ 200‬ﻇﻬﺮ ﺛﻼث ﻣﺮات ﻻﻧﻪ ﻓﻰ اﻟﺼﻒ اﻟﺜﺎﻧﻰ اﻟﻮﻇﻴﻔﺔ ‪ Ac-Asst‬و رﻗﻢ‬
‫اﻟﻘﺴﻢ ‪.10‬‬
‫وﻓﻰ اﻟﺼﻒ اﻟﺜﺎﻟﺚ اﻟﻮﻇﻴﻔﺔ ‪ Ad-Asst‬رﻗﻢ اﻟﻘﺴﻢ ‪.90‬‬
‫وآﻞ ﺻﻒ ﺗﻮﺟﺪ ﺑﻪ ﻗﻴﻤﺔ ﻣﺨﺘﻠﻴﻔﺔ ﻋﻦ اﻟﺼﻒ اﻷﺧﺮ‪.‬‬
‫وهﺬا أﻳﻀﺂ ﻳﺪل ﻋﻠﻰ أن ‪ Union‬ﺗﻤﻨﻊ اﻟﺘﻜﺮار‪.‬‬

‫ﻣﻠﺤﻮﻇﺔ‪-:‬‬
‫* اﻟﻨﺎﺗﺞ ﻳﻜﻮن ﻣﺮﺗﺐ ﺗﺼﺎﻋﺪى ﺑﺎﻟـ ‪ Column‬اﻷول‪.‬‬
 ‫‪Union All‬‬

‫‪Display the current and‬‬

‫‪Previous departments of all employees.‬‬

‫‪ -:Union all‬ﺳﻨﻌﺮض ﺟﻤﻴﻊ اﻟﺼﻔﻮف ﺣﺘﻰ اﻟﻤﻜﺮر أو‬

‫اﻟﻤﺘﺸﺎﺑﺔ ﻣﻨﻬﺎ‪.‬‬
‫*هﻨﺎ ﻳﻈﻬﺮ اﻟﻤﻮﻇﻒ رﻗﻢ ‪ 176‬ﺛﻼث ﻣﺮات و ﻳﻈﻬﺮ ﻓﻰ اﻟﺼﻒ اﻻول اﻟﻮﻇﻴﻔﺔ ‪Sa-‬‬
‫‪ Rep‬و اﻟﻘﺴﻢ ‪.80‬وﻇﻬﺮ اﻳﻀﺎ ﻓﻰ اﻟﺼﻒ اﻟﺜﺎﻟﺚ اﻟﻮﻇﻴﻔﺔ ‪ Sa-Rep‬وﻟﻘﺴﻢ ‪.80‬‬

‫‪The Intersect Operator‬‬

‫‪ -:Intersect‬ﺳﻨﻌﺮض ﻟﻚ اﻟﺼﻔﻮف اﻟﻤﻮﺟﻮد ﻓﻰ اﻟـ ‪ query‬اﻻوﻟﻰ وﺗﻮﺟﺪ أﻳﻀﺎ‬
‫ﻓﻰ ال ‪ query‬اﻟﺜﺎﻧﻴﺔ ﻓﻰ وﺟﻮد ﻓﻰ هﺬا اﻻﺳﺘﻌﻼﻣﺎت ﻳﻌﺮض ﻣﺮة واﺣﺪة وﻏﻴﺮ‬
‫ﻣﻜﺮر‪.‬‬

‫*اﻟﻨﺎﺗﺞ ﺳﻴﻜﻮن هﻮ اﻟﻤﻮﻇﻒ رﻗﻢ ‪ 176‬و وﻇﻴﻔﺘﺔ ‪ Sa-rep‬رﻗﻢ ‪ 200‬و وﻇﻴﻔﺘﺔ ‪AD-‬‬
‫‪Asst‬ﻻﻧﻬﻢ ﻣﻮﺟﻮدﻳﻦ ﻓﻰ اﻟـ ‪ query‬اﻻوﻟﻰ و اﻟﺜﺎﻧﻴﺔ‪.‬‬

‫‪The Minus Operator‬‬

‫‪ -:Minus‬ﺗﻌﺮض اﻟﺼﻔﻮف اﻟﻤﻮﺟﻮدة ﻓﻰ اﻟـ ‪ query‬اﻻوﻟﻰ و ﻏﻴﺮ ﻣﻮﺟﻮدة ﻓﻰ اﻟـ‬

‫‪ query‬اﻟﺜﺎﻧﻴﺔ‪.‬‬
‫ﻧﺮى أن اﻟﻨﺎﺗﺞ هﻰ ﻣﺠﻤﻮﻋﺔ اﻟﺼﻔﻮف اﻟﻤﻮﺟﻮدة ﻓﻰ اﻟـ ‪ Query‬اﻻوﻟﻰ و ﻏﻴﺮ ﻣﻮﺟﻮد‬
‫ﻓﻰ اﻟـ ‪ Query‬اﻟﺜﺎﻧﻰ‪.‬‬
‫ﻳﻤﻜﻦ أﺳﺘﺨﺪام اﻟـ ‪ set operation‬ﻣﻦ ﺧﻼل‬
‫اﻟـ ‪. sub query‬‬

‫‪ query‬ﻣﻦ ﺧﻼل اﻟـ ‪.sub query‬‬ ‫آﻴﻔﻴﺔ ﻋﻤﻞ دﻣﺞ ﻻآﺜﺮ ﻣﻦ‬

‫‪job‬‬ ‫‪ salary‬ﻓﻰ ﺟﺪول اﻟـ‬ ‫وهﻨﺎ ﺗﻢ وﺿﻊ ﺻﻔﺮ ﻓﻰ ال ‪ query‬اﻟﺜﺎﻧﻴﺔ ﻻﻧﺔ ﻻﻳﻮﺟﺪ‬
‫‪ query‬اﻻوﻟﻰ و اﻟﺜﺎﻧﻴﺔ ‪.‬‬ ‫‪ history‬وﻳﺠﺐ اﻋﺎدة ﻧﻔﺲ ﻋﺪد اﻟـ ‪ column‬ﻓﻰ اﻟـ‬
 ‫‪Manipulating Data‬‬

‫اﻷهﺪاف‬
‫ﺑﻌﺪ إآﻤﺎل هﺬا اﻟﺪرس أﻧﺖ ﻳﺠﺐ إن ﺷﺎء اﷲ أن ﺗﻜﻮن ﻗﺎدر ﻋﻠﻲ ﻋﻤﻞ اﻟﺘﺎﻟﻲ‪:‬‬ ‫•‬
‫وﺻﻒ آﻞ ﺗﻌﺒﻴﺮات ‪. (Data Manipulating Language ) DML‬‬ ‫‪-‬‬
‫إدﺧﺎل ﺻﻔﻮف ﺟﺪﻳﺪة ﻟﻠﺠﺪول‪.‬‬ ‫‪-‬‬
‫ﻋﻤﻞ ﺗﺤﺪﻳﺚ وﺗﻐﻴﺮ ﻟﺒﻴﺎﻧﺎت اﻟﺠﺪول‪.‬‬ ‫‪-‬‬
‫ﺣﺬف ﺻﻔﻮف ﻣﻌﻴﻨﺔ ﻣﻦ اﻟﺠﺪول ‪.‬‬ ‫‪-‬‬
‫دﻣﺞ ﺻﻔﻮف ﻣﻦ ﺟﺪوﻟﻴﻦ ﻓﻲ ﺟﺪول واﺣﺪ‪.‬‬ ‫‪-‬‬
‫اﻣﻜﺎﻧﻴﺔ اﻟﺘﻌﺎﻣﻞ ﻣﻊ آﻼ ﻣﻦ )‪.(Rollback, Commit and Savepoint‬‬ ‫‪-‬‬

‫ﺗﻌﺒﻴﺮ ‪ DML‬ﻳﻨﻔﺬ ﻋﻨﺪ ‪:‬‬

‫اﺿﺎﻓﺔ ﺻﻔﻮف ﺟﺪﻳﺪة ﻟﻠﺠﺪول‪.‬‬ ‫‪-‬‬
‫ﺗﻌﺪﻳﻞ ﺻﻔﻮف ﻣﻮﺟﻮدة ﻓﻲ اﻟﺠﺪول‪.‬‬ ‫‪-‬‬
‫ﺣﺬف ﺻﻔﻮف ﻣﻮﺟﻮدة ﻓﻰ اﻟﺠﺪول‪.‬‬ ‫‪-‬‬

‫‪Adding a New Row to a Table‬‬

‫إﺿﺎﻓﺔ ﺻﻒ ﺟﺪﻳﺪ ﻟﻠﺠﺪول‬

‫اﻟﺼﻒ اﻟﺠﺪﻳﺪ اﻟﻤﺮاد أﺿﺎﻓﺘﻪ رﻗﻢ ﻗﺴﻤﺔ ‪ 70‬و أﺳﻢ اﻟﻘﺴﻢ هﻮ ﻋﻼﻗﺎت ﻋﺎﻣﺔ ورﻗـﻢ اﻟﻤـﺪﻳﺮ هـﻮ‬
‫‪ 100‬ورﻗﻢ اﻟﻤﻮﻗﻊ ‪170‬‬
‫و ﻳﻮﺿﺢ ﻟﻨﺎ اﻟﺮﺳﻢ اﻟﻔﺮق ﺑﻴﻦ اﻟﺠﺪول ﻗﺒﻞ إدﺧﺎل اﻟﺼﻒ وﺑﻌﺪ إدﺧﺎل اﻟﺼﻒ‪ .‬ﻳﻤﻜﻨﻚ إﺿـﺎﻓﺔ ﺻـﻒ‬
‫ﺟﺪﻳﺪ ﻟﻠﺠﺪول ﺑﺎﺳﺘﺨﺪام اﻣﺮ) ‪ (INSERT‬واﻟﺼﻴﻐﺔ اﻟﻌﺎﻣﺔ ﻟﺘﻠﻚ اﻻﻣﺮ آﻤﺎ ﻳﻠﻰ‪:‬‬

‫‪INSERT INTO‬‬ ‫])]‪table [(column1 [, column2...‬‬

‫‪VALUES‬‬ ‫;)]‪(value1 [, value2...‬‬

‫ﺣﻴﺚ أن‬
‫اﺳﻢ اﻟﺠﺪول اﻟﻤﺮاد إﻟﺤﺎق اﻟﺴﺠﻞ ﺑﻪ‬ ‫‪Table‬‬
‫اﺳﻤﺎء اﻷﻋﻤﺪة)اﻟﺤﻘﻮل( اﻟﻤﻄﻠﻮب إدﺧﺎل اﻟﺒﻴﺎﻧﺎت إﻟﻴﻬﺎ‬ ‫‪Column1,Column2‬‬
 ‫اﻟﻘ ﻴﻢ اﻟﻤﻄﻠ ﻮب إﺿ ﺎﻓﺘﻬﺎ ﻓ ﻲ ﺣﻘ ﻮل اﻟ ﺴﺠﻞ‬ ‫‪Value1, value2‬‬
‫اﻟﺠﺪﻳ ﺪ وآ ﻞ ﻗﻴﻤ ﺔ ﻳ ﺘﻢ إدراﺟﻬ ﺎ ﻓ ﻲ اﻟﺤﻘ ﻞ‬
‫اﻟﻤﻨﺎﺳ ﺐ ﻓ ﻲ اﻟﻘﺎﺋﻤ ﺔ وﺑﺎﻟﺘ ﺎﻟﻲ ﺳ ﻴﺘﻢ إﺿ ﻠﻔﺔ‬
‫اﻟﻘﻴﻤﺔ‪ 1‬ﻓﻲ اﻟﺤﻘﻞ ‪ 1‬وهﻜﺬا‬
‫اﻟﺸﺮح‬

‫ﺑﻌﺪ ﺗﻨﻔﻴﺬ ﺟﻤﻠﺔ اﻹدﺧﺎل ﺑﻬﺬﻩ اﻟﻄﺮﻳﻘﺔ ﺳﻮف ﻳﺘﻢ إﺿﺎﻓﺔ ﺑﻴﺎﻧﺎت ﺳﺠﻞ واﺣﺪ ﻓﻘﻂ ﻓﻲ اﻟﺠـﺪول‬
‫اﻟﻤﺬآﻮر ﻳﺘﻮي ﻋﻠﻰ ﻗﻴﻢ ﺗﻢ إ دراﺟﻬﺎ ﻓﻲ ﺟﻤﻠﺔ اﻹدﺧﺎل وﻟﻠﺤﻘﻮل اﻟﻤﺬآﻮرة ﻓﻘﻂ‬
‫اﻟﻘﻮاﻋﺪ اﻟﺘﻲ ﻳﺠﺐ اﻟﺘﻘﻴﺪ ﺑﻬﺎ ﻓﻲ هﺬﻩ اﻟﻄﺮﻳﻘﺔ‬

‫ﻳﺠــﺐ أن ﻳﻜــﻮن ﻋــﺪد اﻟﻘــﻴﻢ اﻟﺘــﻲ ﺳــﻴﺘﻢ إدﺧﺎﻟﻬــﺎ هــﻮ ﻧﻔــﺲ ﻋــﺪد اﻟﺤﻘــﻮل اﻟﻤــﺬآﻮر ﻓــﻲ‬ ‫‪(1‬‬
‫ﺟﻤﻠﺔ ‪INSERT‬‬

‫ﻳﺠﺐ أن ﻳﻜﻮن ﻧﻮع ﺑﻴﺎﻧﺎت اﻟﻘﻴﻢ اﻟﺘﻲ ﺳﻴﺘﻢ إدﺧﺎﻟﻬﺎ ﻣﻦ ﻧﻔﺲ ﻧﻮع ﺑﻴﺎﻧﺎت اﻟﺤﻘﻮل وأن ﺗﻜﻮن‬ ‫‪(2‬‬
‫هﺬﻩ اﻟﻘﻴﻢ ﻣﺮﺗﺒﺔ ﺣﺴﺐ ﺗﺮﺗﻴﺐ اﻟﺤﻘﻮل ﻓﻲ ﺟﻤﻠﺔ ‪INSERT‬‬

‫ﻣﺜﺎل‬

‫ﻋﻨﺪ إدﺧﺎل ﺣﻘﻮل اﻟﺘﺎرﻳﺦ واﻟﻨﺼﻮص ﻳﺠﺐ وﺿﻊ اﻟﻘﻴﻢ اﻟﻤﺨﻠﺔ ﺑﻴﻦ ﻋﻼﻣﺘﻲ ﺗﻨﺼﻴﺺ ﻣﻔﺮدﺗﻴﻦ‬ ‫‪(3‬‬

‫ﻳﺠﺐ ﻣﺮاﻋﺎة وﺟﻮب إدﺧﺎل ﻗﻴﻢ ﻓﻲ اﻟﺤﻘﻮل اﻹﺟﺒﺎرﻳﺔ اﻟﺘﻲ ﺗﻢ ﺗﻌﺮﻳﻔﻌﺎ ﻋﻠـﻰ أﻧﻬـﺎ ﻻ ﺗﺤﺘـﻮي‬ ‫‪(4‬‬
‫ﻓﺮاغ ‪ NOT NULL‬وﻳﺘﻢ ادﺧﺎل ‪ NULL‬ﻓﻲ اﻟﺤﻘﻮل اﻟﺘﻲ ﺑﻬﺎ ﻓﺮاغ‬

‫ﻣﺜﺎل‬
‫‪INSERT INTO‬‬ ‫‪dept‬‬
‫‪VALUES‬‬ ‫;)‪(13, 'Administration', NULL‬‬

‫‪ (5‬ﻳﺠﻮز ﻋﺪم ذآﺮ أﺳﻤﺎء اﻟﺤﻘﻮل ﻓﻲ ﺟﻤﻠﺔ ‪ INSERT‬ﻓﻲ ﺣﺎﻟﺔ إدﺧﺎل ﺑﻴﺎﻧﺎت ﺟﻤﻴﻊ اﻟﺤﻘﻮل‬
‫ﻟﻬﺬا اﻟﺴﺠﻞ ﻋﻠﻰ أن ﺗﻜﻮن اﻟﻘـﻴﻢ اﻟﻤﺨﻠـﺔ ﻣﺮﺗﺒـﺔ ﺣـﺴﺐ اﻟﺘﺮﺗﻴـﺐ اﻻﻓﺘﺮاﺿـﻲ ﻟﻠﺤﻔـﻮل ﻓـﻲ‬
‫اﻟﺠﺪول ﻋﻨﺪ ﺑﻨﺎﺋﻪ‬

‫ﻣﻼﺣﻈﺔ‬
‫ﻟﻤﻌﺮﻓــﺔ اﻟﺘﺮﺗﻴــﺐ اﻻﻓﺘﺮاﺿــﻲ ﻟﻠﺤﻘــﻮل ﻓــﻲ اﻟﺠــﺪول و ﻟﻤﻌﺮﻓــﺔ ﻧــﻮع اﻟﺒﻴﺎﻧــﺎت ﻟﻜــﻞ ﻋﻤﻮدﻋﻨــﺪﻣﺎ‬
‫ﺗﺮﻳﺪاﺿﺎﻓﺔ ﺑﻴﺎﻧﺎت ﺟﺪﻳﺪة ذﻟﻚ ﺑﺴﺘﺨﺪم اﻷﻣﺮ ‪DESC‬‬

‫ﻧﺴﺘﺨﺪام اﻻﻣﺮ ‪ DESCRIBE‬او ‪ DESC‬آﻤﺎ ﻓﻰ اﻟﻤﺜﺎل اﻟﺘﺎﻟﻰ‪:‬‬

‫إﺿﺎﻓﺔ ﺻﻔﻮف ﺗﺤﺘﻮي ﻋﻠﻲ ﻗﻴﻢ ﻓﺎرﻏﺔ او ‪. NULL‬‬

 ‫ﻣﻦ اﻟﻤﻤﻜﻦ إﺿﺎﻓﺔ ﺻﻔﻮف ﺗﺤﺘﻮي ﻋﻠﻲ ﻗﻴﻢ ﻓﺎرﻏﺔ وﻧﻘﻮم ﺑﻌﻤﻞ ذﻟﻚ ﺑﻄﺮﻳﻘﺘﻴﻦ‪-:‬‬

‫‪ -‬اﻟﻄﺮﻳﻘﺔ اﻻوﻟﻰ ‪ :‬ﺣﺬف اﻟﻌﻤﻮد ﻣﻦ ﻗﺎﺋﻤﺔ اﻷﻋﻤﺪة‪.‬‬

‫‪INSERT INTO departments‬‬ ‫‪(department_id,‬‬
‫)‪department_name‬‬
‫‪VALUES‬‬ ‫;)’‪(30, ’Purchasing‬‬
‫‪1 row created.‬‬

‫اﻟﻄﺮﻳﻘﺔ اﻷوﻟﻰ وهﻲ إﻏﻔﺎل ذآﺮ أﺳﻢ‬

‫اﻟﻌﻤﻮد اﻟﻤﺮاد ﺟﻌﻞ ﻗﻴﻤﺘﻪ ﻓﺎرﻏﺔ )‪.(NULL‬‬
‫وﺗﺴﻤﻲ هﺬﻩ اﻟﻄﺮﻳﻘﺔ ﺑﺎﻟﻄﺮﻳﻘﺔ اﻟﻀﻤﻨﻴﺔ‪.‬‬

‫‪ -‬اﻟﻄﺮﻳﻘﺔ اﻟﺜﺎﻧﻴﺔ‪:‬ادراج اﻟﻌﻤﻮد و ﺗﺤﺪﻳﺪ آﻠﻤﺔ ‪ NULL‬ﻓﻲ ﻓﻘﺮة ‪VALUES‬‬

‫)‪Insert into dept (deptno,dname,loc‬‬
‫;)‪Values (50,'EDUCATION',NULL‬‬
‫وهﺬﻩ هﻲ اﻟﻄﺮﻳﻘﺔ اﻟﺜﺎﻧﻴﺔ وهﻰ وﺿﻊ آﻠﻤﺔ ‪ NULL‬و ﺗﺴﻤﻲ ﺑﺎﻟﻄﺮﻳﻘﺔ اﻟﻮاﺿﺤﺔ أو اﻟﺼﺮﻳﺤﺔ ‪.‬‬

‫اﻟﻄﺮق ﻹدﺧﺎل ﻗﻴﻢ ﻓﺎرﻏﺔ‬

‫‪Implicit‬‬ ‫ﺣﺬف اﻟﻌﻤﻮد ﻣﻦ ﻗﺎﺋﻤﺔ اﻻﻋﻤﺪة اﻟﻤﺮاد ادﺧﺎل ﺑﻴﺎﻧﺎت ﺑﻬﺎ‬
‫ﺗﺤﺪﻳﺪ ‪ NULL‬ﻟﻠﻌﻤﻮد او ﺗﺤﺪﻳﺪ ﻣﺠﻤﻮﻋﺔ ﻓﺎرﻏﺔ ) ‘ ‘( ﻓﻲ ﻗﺎﺋﻤﺔ‬
‫‪Explicit‬‬
‫‪VALUES‬‬

‫* أﺧﻄﺎء ﺷﺎﺋﻌﺔ ﺗﺤﺪث ﻋﻨﺪ اﺳﺘﺨﺪام ‪-: INSERT‬‬

‫ﻋﺪم ادﺧﺎل ﻗﻴﻤﺔ ﻓﻰ ﻋﻤﻮد ﻻﺑﺪ ﻣﻦ ادﺧﺎل ﻗﻴﻤﺔ ﺑﺔ ﻣﺜﻞ ﻋﻤﻮد )‪.(Primary Key‬‬ ‫‪-‬‬
‫ادﺧﺎل ﻗﻴﻤﺔ ﺳﺒﻖ ادﺧﺎﻟﻬﺎ ﻓﻰ ﻋﻤﻮد )‪. (Primary Key‬‬ ‫‪-‬‬
‫ادﺧﺎل ﻗﻴﻢ ﻋﺪد ﺣﺮوﻓﻬﺎ اآﺒﺮ ﻣﻦ اﻟﻤﺘﺎح ﻟﺘﻠﻚ اﻟﻌﻤﻮد‪.‬‬ ‫‪-‬‬
‫)‪Insert into EMP (ename, job‬‬
‫)'‪Values ('ZAKI','MANAGER‬‬ ‫;‬

‫وﺳﺒﺐ هﺬا ‪: Error‬‬

‫ان ﻋﻤﻮد ‪ EMPNO‬ﻳﻌﺘﺒﺮ ‪ Primary Key‬وﻻ ﻳﻤﻜﻦ ان ﻳﺘﺮك ﺑﺪون ﻗﻴﻤﺔ‪.‬‬
‫اﺳﺘﺨﺪام ‪ SYSDATE‬و ‪ USER‬ﻓﻰ ﺟﻤﻠﺔ ‪Insert‬‬
‫ﻋﻨﺪ إﺿﺎﻓﺔ ﺻﻔﻮف ﺟﺪﻳﺪة ﻳﻤﻜﻦ اﺳﺘﺨﺪام ‪ SYSDATE‬ﻟﻠﺘﻌﺒﻴﺮ ﻋﻦ اﻟﺘﺎرﻳﺦ اﻟﺤﺎﻟﻰ ﺑﺪون آﺘﺎﺑﺘﺔ‬
‫ﻳﺪوﻳﺎ‪ .‬وﻳﻤﻜﻦ اﺳﺘﺨﺪام آﻠﻤﺔ ‪ User‬آﻘﻴﻤﺔ ﻻﺿﺎﻓﺔ اﺳﻢ اﻟﻤﺴﺘﺨﺪم اﻟﺤﺎﻟﻰ آﻤﺎ ﻓﻰ اﻟﻤﺜﺎل‬
‫اﻟﺘﺎﻟﻰ‪:‬‬
‫;)‪Insert into login values (user, sysdate‬‬
‫ﻓﻠﻨﻔﺘﺮض وﺟﻮد ﺟﺪول ﻳﺤﺘﻮى ﻋﻠﻰ ﻋﻤﻮدﻳﻦ اﻻول ﻻﺳﻢ اﻟﻤﺴﺘﺨﺪم واﻻﺧﺮ ﻟﺘﺴﺠﻴﻞ اﻟﻮﻗﺖ‬
‫اﻟﺤﺎﻟﻰ‪.‬‬
‫ﻣﺜﺎل‪:‬‬
‫‪Insert into employees‬‬
‫)‪(employee_id, last_name, job_id, hire_date, commission_pct‬‬
‫;)‪Values (113,user,'ac_account',sysdate,null‬‬

‫هﻨﺎ ﻧﺠﺪ أن ‪ SYSDATE‬أدت إﻟﻲ إدﺧﺎل ﺗﺎرﻳﺦ اﻟﻨﻈﺎم وﻗﺖ ﺗﻨﻔﻴﺬ اﻷﻣﺮ‬
‫وأدت آﻠﻤﺔ ‪ user‬إﻟﻲ إدﺧﺎل أﺳﻢ اﻟﻤﺴﺘﺨﺪم اﻟﺤﺎﻟﻲ وهﻮ ‪.Popp‬‬
‫وادى اﺳﺘﺨﺪام آﻠﻤﺔ ‪ NULL‬اﻟﻰ ادراج ‪ NULL‬ﺑﺪاﺧﻞ اﻟﻌﻤﻮد‪.‬‬
‫إدﺧﺎل ﻗﻴﻢ اﻟﺘﺎرﻳﺦ‬
 ‫ﻟﻠﺘﺤﻘﻖ ﻣﻦ اﻹﺿﺎﻓﺔ‬ ‫‪-‬‬
‫‪Select * from employees‬‬
‫;‪Where employee_id=114‬‬

‫ﻋﻨﺪ إدﺧﺎل ﺗﺎرﻳﺦ ﻳﺠﺐ ﻣﺮاﻋﺎة آﺘﺎﺑﺘﺔ ﺑﻄﺮﻳﻘﺔ ﻣﺒﺪﺋﻴﺔ وهﻲ اﻟﻴﻮم ﻣﻜﻮن ﻣﻦ رﻗﻤﻴﻦ واﻟﺸﻬﺮ‬
‫ﻣﻜﻮن ﻣﻦ ﺛﻼﺛﺔ ﺣﺮوف ﺛﻢ اﻟﺴﻨﺔ ﻣﻜﻮﻧﺔ ﻣﻦ أرﺑﻌﺔ أرﻗﺎم‪.‬‬
‫) ‪(DD-MON-YY‬وﻋﻨﺪ إدﺧﺎل اﻟﺘﺎرﻳﺦ ﺑﻄﺮﻗﺔ ﻣﺨﺘﻠﻔﺔ ﻧﺴﺘﺨﺪم اﻟﺪاﻟﺔ ‪TO_DATE‬‬
‫وذﻟﻚ ﻟﺘﺤﻮﻳﻞ اﻟﺘﺎرﻳﺦ إﻟﻲ اﻟﻄﺮﻳﻘﺔ اﻟﺘﻲ ﻳﻘﺒﻠﻬﺎ اﻷوراآﻞ واﻟﻨﺎﺗﺞ ﻳﻮﺿﺢ ﺷﻜﻞ اﻟﺘﺎرﻳﺦ ﺑﻌﺪ إدﺧﺎﻟﻬﺎ‬
‫آﻤﺎ هﻮ ﻣﻮﺿﺢ أﻋﻠﻲ‪.‬‬
‫‪03-FEB-99‬‬ ‫ﺣﻴﺚ ﻳﻜﻮن اﻟﻨﺎﺗﺞ آﺎﻟﺘﺎﻟﻲ‬

‫اﺿﺎﻓﺔ ﻋﺪة ﺳﺠﻼت إﻟﻰ ﺟﺪول اﻟﺒﻴﺎﻧﺎت‬

‫ﻣﻦ ﺧﻼل هﺬﻩ اﻟﻄﺮﻳﻘﺔ ﻳﻤﻜﻦ ادﺧـﺎل أآﺜـﺮ ﻣـﻦ ﺳـﺠﻞ واﺣـﺪ إﻟـﻰ ﺟـﺪول اﻟﺒﻴﺎﻧـﺎت ﻋـﻦ ﻃﺮﻳـﻖ‬
‫اﺳﺘﺨﺪام ﻣﺘﻐﻴﺮات اﻻدﺧﺎل وهﻲ ﻋﺒﺎرة ﻋﻦ ﻣﺘﻐﻴﺮات ﺗﻮﺿﻊ ﻓـﻲ ﺟﻤﻠـﺔ اﻻدﺧـﺎل ﺑـﺪﻻ ﻣـﻦ اﻟﻘـﻴﻢ‬
‫ﻧﻔﺴﻬﺎ ةﻳﻤﻜﻦ أن ﻧﻄﻠﻖ ﻋﻠﻰ هﺬﻩ اﻟﻄﺮﻳﻘﺔ ﺟﻤﻠﺔ اﻻدﺧﺎل ﻣﺘﻌﺪدة اﻟﺴﺠﻼت‬

‫])]‪table [(column1 [, column2...‬‬ ‫‪INSERT INTO‬‬

‫;)]‪(&variable1 [,&variable1 ...‬‬ ‫‪VALUES‬‬

‫ﺣﻴﺚ ان‬
‫اﺳﻢ اﻟﺠﺪول اﻟﻤﺮاد إﻟﺤﺎق اﻟﺴﺠﻞ ﺑﻪ‬ ‫‪Table‬‬
‫اﺳﻤﺎء اﻷﻋﻤﺪة)اﻟﺤﻘﻮل( اﻟﻤﻄﻠﻮب إدﺧﺎل اﻟﺒﻴﺎﻧﺎت إﻟﻴﻬﺎ‬ ‫‪Column1,Column2‬‬
‫ﻣﺘﻐﻴـــﺮات اﻹدﺧـــﺎل‬ ‫‪Variable1, Variable 2‬‬
‫اﻟﺘــﻲ ﺳــﻮف ﻳــﺘﻢ‬
‫اﺳــــﺘﺒﺪاﻟﻬﺎ ﺑﻘــــﻴﻢ‬
‫ﺣﻘﻴﻘﻴﺔ ﺑﻌـﺪ ﺗﻨﻘﻴـﺬ‬
‫ﺟﻤﻠﺔ اﻻدﺧﺎل‬
‫اﻟﺸﺮح‬

‫ﺑﻌﺪ ﺗﻨﻔﻴﺬ ﺟﻤﻠﺔ ﻳﻬﺬﻩ اﻟﻄﺮﻳﻘﺔ ﺳﻮف ﻳﻄﻠﺐ ﻣﻨﻚ إدﺧﺎل اﻟﻘﻴﻢ ﻟﻠﻤﺘﻐﻴﺮات اﻟﻤﺬآﻮرة ﻓـﻲ ﺟﻤﻠـﺔ‬
‫اﻹدﺧﺎل وﺑﻌﺪ اﻻﻧﺘﻬﺎء ﻣﻦ ادﺧﺎل اﻟﻘﻴﻤﺔ ﺗﻀﻐﻂ ﻣﻔﺘﺎح ‪ ENTER‬ﻣﻦ ﻟﻮﺣﺔ اﻟﻤﻔـﺎﺗﻴﺢ وهﻜـﺬا ﺣﺘـﻰ‬
‫ﺗﻨﺘﻬﻲ ﻣﻦ إدﺧﺎل ﺣﻘﻮل ﻻﺳﺠﻞ اﻷول وﻹدﺣﺎل ﺳﺠﻞ ﺁﺧﺮ ﻳﻤﻜﻨﻚ اﻟﻀﻐﻂ ﻋﻠـﻰ ﺣـﺮف ) ‪ (R‬ﺛـﻢ‬
‫‪R‬‬

‫ﻣﻔﺘﺎح ‪ ENTER‬ﻣﻦ ﻟﻮﺣﺔ اﻟﻤﻔﺎﺗﻴﺢ وهﻮ ﻳﻌﻨﻲ ﺗﻜﺮار اﻹدﺧﺎل ﻟﺴﺠﻼت اﺧﺮى‬

‫ﻣﺜﺎل‬

‫)‪INSERT INTO s_dept (id, name, region_id‬‬

‫;)‪vALUES(&department_id,‘&department_name,&region_id‬‬
‫‪Enter value for department_id: 61‬‬
‫‪Enter value for department_name: Accounting‬‬
‫‪Enter value for region_id: 2‬‬
 ‫اﻟﻘﻮاﻋﺪ اﻟﺘﻲ ﻳﺠﺐ اﻟﺘﻘﻴﺪ ﺑﻬﺎ ﻓﻲ هﺬﻩ اﻟﻄﺮﻳﻘﺔ‬

‫ﺗﻨﻄﺒﻖ ﻋﻠﻰ هﺬﻩ اﻟﻄﺮﻳﻘﺔ ﺟﻤﻴﻊ اﻟﻘﻮاﻋﺪ اﻟﻤﺬآﻮرة ﻓﻲ اﻟﻄﺮﻳﻘﺔ اﻷوﻟﻰ وﻳﻀﺎف إﻟﻴﻬﺎ ﻣﺎﻳﻠﻲ ‪:‬‬
‫ﺗﺴﺘﺒﺪل اﻟﻘﻴﻢ ﻓﻲ ﺟﻤﻠﺔ اﻹدﺧﺎل ﺑﻤﺘﻐﻴﺮات‬ ‫‪-1‬‬
‫ﻳﻌﻮد اﺧﺘﻴﺎر أﺳﻤﺎء اﻟﻤﺘﻐﻴﺮات إﻟﻰ اﻟﻤﺴﺘﺨﺪم ﻣﻊ ﻣﺮاﻋﺎة ﺷﺮوط ﺗﺴﻤﻴﺔ اﻟﻤﺘﻐﻴﺮات‬ ‫‪-2‬‬
‫ﻳﺠﺐ أن ﺗﻮﺿﻊ ﻋﻼﻣﺔ & ﻗﺒﻞ ﻣﺘﻐﻴﺮ اﻻدﺧﺎل‬ ‫‪-3‬‬
‫ﻓﻲ ﺟﻤﻠﺔ اﻹدﺧﺎل ﻳﻤﻜﻦ وﺿﻊ ﻋﻼﻣﺘﻰ ﺗﻨﺼﻴﺺ ﻣﻔﺮدﺗﻴﻦ ﺣﻮل ﻣﺘﻐﻴـﺮ اﻻدﺧـﺎل اﻟﺨـﺎص‬ ‫‪-4‬‬
‫ﺑﺎﻟﺤﻘﻮل اﻟﻨﺼﺒﺔ‬

‫‪Coping a Rows from Another Table‬‬

‫اﻣﻜﺎﻧﻴﺔ اﺳﺘﻌﻤﺎل ‪ SubQuery‬ﻣﻊ ﺟﻤﻠﺔ ‪INSERT‬‬

‫ﻣﻦ ﺧﻼل هﺬﻩ اﻟﻄﺮﻳﻘﺔ ﻳﻤﻜﻦ إدﺧﺎل أآﺜﺮﻣﻦ ﻳﺠﻞ واﺣﺪ إﻟﻰ ﺟﺪول اﻟﺒﻴﺎﻧﺎت ﻋﻦ ﻃﺮﻳﻖ ﻧﺴﺦ‬
‫ﻳﺚ ﻧﺴﺘﺨﺪم ‪SELECT‬هﺬا اﻟﺴﺠﻞ ‪ /‬اﻟﺴﺠﻼت ﻣﻦ ﺟﺪول ﺁﺧﺮ ﺑﻮﺗﺴﻄﺔ ﺟﻤﻠﺔ اﻻﺳﺘﻔﺴﺎر‬
‫ﻣﻊ اﺳﺘﻌﻼم ﻓﺮﻋﻲ اﻧﻈﺮ اﻟﻰ اﻟﻤﺜﺎل اﻟﺘﺎﻟﻲ ‪INSERT‬ﺟﻤﻠﺔ‬

‫‪INSERT INTO history(id, last_name, salary, title,‬‬

‫)‪start_date‬‬
‫‪SELECT id, last_name, salary,title, start_date‬‬
‫‪FROM s_emp‬‬
‫;'‪WHERE start_date < '01-JAN-94‬‬

‫اﻟﺸﺮح‬

‫ﺑﻌﺪ ﺗﻨﻔﻴﺬ ﺟﻤﻠﺔ اﻹدﺧﺎل ﺑﻬﺬﻩ اﻟﻄﺮﻳﻘﺔ ﻳﻨﻢ ﻧﺴﺦ اﻟﺴﺠﻼت اﻟﺘـﻲ ﺗﺤﻘـﻖ اﻟـﺸﺮط ﻣـﻦ اﻟﺠـﺪوﻻ‬
‫ﻟﻤﺼﺪر إﻟﻰ اﻟﺠﺪول اﻟﻬﺪف وﻟﻠﺤﻘﻮل ااﻟﻤﺬآﻮرة ﻓﻲ ﺟﻤﻠﺔ اﻹدﺧﺎل‬

‫اﻟﻘﻮاﻋﺪ اﻟﺘﻲ ﻳﺠﺐ اﻟﺘﻘﻴﺪ ﺑﻬﺎ ﻓﻲ هﺬﻩ اﻟﻄﺮﻳﻘﺔ‬

‫آﺘﺎﺑﺔ ﺟﻤﻠﺔ اﻹدﺧﺎل ‪ INSERT‬ﻣﺤﺘﻮﻳﺔ ﻋﻠﻰ ﺟﻤﻠﺔ اﺳﺘﻔﺴﺎر ‪SELECT‬‬ ‫•‬
‫ﺗﺴﺘﺒﺪل اﻟﻘﻴﻢ ﻓﻲ ﺟﻤﻠﺔ اﻹدﺧﺎل ﺑﺄﺳﻤﺎء ﺣﻘﻮل اﻟﺠﺪول اﻟﻤﺼﺪر‬ ‫•‬
‫ﻋﺪم اﺳﺘﺨﺪم اﻟﻌﺒﺎرة ‪VALUES‬‬ ‫•‬
‫ﻳﺠﺐ ﻣﺮاﻋﺎة وﺟﻮب إدﺧﺎل ﻗﻴﻢ ﻓﻲ اﻟﻘﻮل اﻻﺟﺒﺎرﻳﺔ اﻟﺘﻲ ﺗﻢ ﻧﻌﺮﻳﻔﻬـﺎ ﻋﻠـﻰ أﻧﻬـﺎ‬ ‫•‬
‫ﻻ ﺗﺤﺘﻮي ﻓﺮاغ ‪NOT NULL‬‬
‫ﻣﻄﺎﺑﻘﺔ اﻟﺤﻘﻮل ﺑﻴﻦ اﻟﺠـﺪوﻟﻴﻦ ﻣـﻦ ﺣﻴـﺚ ﺗﺮﺗﻴـﺐ اﻟﺤﻘـﻮل وﻧـﻮع اﻟﺒﻴﺎﻧـﺎت وﻋـﺪد‬ ‫•‬
‫اﻟﺤﻘﻮل‬
‫اﻟﺒﻴﺎﻧﺎت‪.‬‬ ‫‪-‬‬
‫آﻲ ﻧﻨﺸﺊ ﻧﺴﺨﺔ ﻣﻦ اﻟﺼﻔﻮف ﻓﻲ اﻟﺠﺪول اﺳﺘﺨﺪم *‪ SELECT‬ﻓﻲ اﻻﺳﺘﻌﻼم‬ ‫‪-‬‬
‫اﻟﻔﺮﻋﻲ‪.‬‬
 ‫‪Changing Data in a Table‬‬
‫ﺗﻐﻴﻴﺮ اﻟﺒﻴﺎﻧﺎت ﻓﻲ اﻟﺠﺪول‬
‫اﻟﻤﻮﻇﻔﻴﻦ‬

‫ﺗﻌﺪﻳﻞ اﻟﺼﻔﻮف ﻓﻲ ﺟﺪول اﻟﻤﻮﻇﻔﻴﻦ‪.‬‬

‫اﻟﻤﺜﺎل اﻟﻤﻌﺮوض أﻣﺎﻣﻨﺎ ﻳﻘﻮم ﺑﺘﻐﻴﻴﺮ رﻗﻢ ﻗﺴﻢ اﻟﻤﻮﻇﻔﻴﻦ ﺑﻘﺴﻢ ‪ 60‬إﻟﻲ اﻟﻘﺴﻢ رﻗﻢ ‪.30‬‬

‫اﻟﺼﻴﻐﺔ اﻟﺮﺋﻴﺴﻴﺔ ﻟﺘﻌﺒﻴﺮ ‪ UPDATE‬ﺗﺤﺪﻳﺚ أآﺜﺮ ﻣﻦ ﺻﻒ واﺣﺪ ﻓﻲ ﻧﻔﺲ اﻟﻮﻗﺖ ‪،‬إذا ﺗﻄﻠﺐ‬
‫ذﻟﻚ ﻳﻤﻜﻦ أن ﺗﻌﺪل ﺻﻔﻮف ﻣﻮﺟﻮدة ﺑﺎﺳﺘﺨﺪام ﺗﻌﺒﻴﺮ ‪.UPDATE‬ﻋﻠﻰ اﻟﻨﺤﻮ اﻟﺘﺎﻟﻰ‪:‬‬
‫أﺳﻢ اﻟﺠﺪول‬ ‫‪Table‬‬
‫أﺳﻢ اﻟﻌﻤﻮد اﻟﻤﺮاد ﺗﻐﻴﺮة‪.‬‬ ‫‪Column‬‬
‫اﻟﻘﻴﻤﺔ اﻟﺠﺪﻳﺪة‪.‬‬ ‫‪Value‬‬
‫‪ Condition‬ﺗﺤﺪﻳﺪ اﻟﺼﻔﻮف اﻟﺘﻰ ﻳﻨﻄﺒﻖ ﻋﻠﻴﻬﺎ اﻟﺸﺮط اﻟﻤﻄﻠﻮب‪.‬‬
‫وﺑﺎﻏﻔﺎل اﻟﺸﺮط ﻳﺤﺪث ﺗﻐﻴﻴﺮ ﺑﻜﻞ اﻻﻋﻤﺪة‪.‬‬
‫ﻣﻠﺤﻮﻇﺔ ‪:‬‬
‫ﺑﺸﻜﻞ ﻋﺎم ﻳﻤﻜﻦ اﺳﺘﺨﺪام اﻟﻤﻔﺘﺎح اﻟﺮﺋﻴﺴﻲ )‪ (Primary Key‬ﻟﺘﺤﺪﻳﺪ ﺻﻒ وﺣﻴﺪ‪ .‬ﺣﻴﺚ‬
‫اﺳﺘﺨﺪام اﻷﻋﻤﺪة اﻷﺧﺮى ﻳﻤﻜﻦ أن ﻳﺆدى اﻟﻰ ﻧﺘﺎﺋﺞ ﻏﻴﺮ ﻣﺘﻮﻗﻌﺔ واﻟﺴﺒﺐ أن ﺻﻔﻮف ﻋﺪﻳﺪة‬
‫ﻳﻨﻄﺒﻖ ﻋﻠﻴﻬﺎ ﻧﻔﺲ اﻟﺸﺮط‪.‬‬
‫آﻤﺜﺎل‪ :‬ﺗﺤﺪﻳﺪ ﺻﻒ واﺣﺪ ﻣﻦ ﺟﺪول اﻟﻤﻮﻇﻔﻴﻦ ﻋﻦ ﻃﺮﻳﻖ اﺳﺘﺨﺪام ﻋﻤﻮد اﻻﺳﻤﺎء آﺸﺮط‬
‫ﻻﺟﺮاء اﻟﺘﻐﻴﺮ اﻟﻤﻄﻠﻮب وهﺬا ﻗﺪ ﻳﺆدى اﻟﻰ ﺣﺪوث ﺧﻄﺄ ﻷﻧﺔ ﻣﻦ اﻟﻤﻤﻜﻦ ان ﻳﻜﻮن أآﺜﺮ ﻣﻦ ﻣﻮﻇﻒ‬
‫ﺑﻨﻔﺲ اﻻﺳﻢ‪ .‬وﻓﻰ ﺗﻠﻚ اﻟﺤﺎﻟﺔ ﻣﻦ اﻻﻓﻀﻞ اﺳﺘﺨﺪام ﻋﻤﻮد ‪ Primary Key‬ﻟﻜﻰ ﻧﺘﻤﻜﻦ ﻣﻦ‬
‫اﺟﺮاء اﻟﺘﻐﻴﺮ ﺑﺪﻗﺔ ﺣﻴﺚ ان اﻟﺒﻴﺎﻧﺎت ﺑﺘﻠﻚ اﻟﻌﻤﻮد ﺗﻜﻮن ﻏﻴﺮ ﻣﺘﻜﺮرة‪.‬‬

‫ﺗﻌﺪﻳﻞ ﺑﻴﺎﻧﺎت ﻓﻲ اﻟﺠﺪول‬

‫ﺗﺤﺪﻳﺪ ﺻﻒ أو ﻣﺠﻤﻮﻋﺔ ﺻﻔﻮف ﻓﻰ ﻓﻘﺮة ‪. WHERE‬‬

‫ﻳﻤﻜﻦ ﻟﺼﻔﻮف اﻟﺠﺪول آﻠﻬﺎ ان ﺗﻌﺪل ﻋﻦ ﻃﺮﻳﻖ ﺣﺬف ﻓﻘﺮة ‪.WHERE‬‬

‫ﻋﻨﺪﻣﺎ ﻧﺮﻳﺪ ﺗﻌﺪﻳﻞ ﺑﻴﺎﻧﺎت ﻧﺴﺘﺨﺪم اﻷﻣﺮ ‪ UPDATE‬وﻳﻜﺘﺐ ﻋﻠﻲ اﻟﻨﺤﻮ اﻟﺘﺎﻟﻲ‪:‬‬
‫اﻷﻣﺮ ‪ UPDATE‬ﻳﻠﻴﻪ أﺳﻢ اﻟﺠﺪول ﻣﺜﻼ ‪ Employees‬اﻟﻤﺮاد ﺗﻌﺪﻳﻞ ﺑﻴﺎﻧﺎﺗﻪ ﺛﻢ آﻠﻤﺔ ‪SET‬‬
‫ﻳﻠﻴﻬﺎ أﺳﻢ اﻟﻌﻤﻮد اﻟﻤﺮاد ﺗﻐﻴﻴﺮ ﻗﻴﻤﺘﻪ ﺛﻢ ﻋﻼﻣﺔ ﻳﺴﺎوي ﺛﻢ اﻟﻘﻴﻤﺔ اﻟﺠﺪﻳﺪة‪ .‬و ﻳﻠﻲ ذﻟﻚ ﺟﻤﻠﺔ‬
‫اﻟﺸﺮط )‪ (Condition‬اﻟﺘﻲ ﺳﻮف ﺗﺤﺪد اﻟﺼﻔﻮف اﻟﻤﺮاد ﺗﻌﺪﻳﻠﻬﺎ ﻓﻲ اﻟﺠﺪول‪.‬‬

‫ﻣﻼﺣﻈﺔ‪ :‬اذا ﻟﻢ ﺗﻘﻢ ﺑﺘﺤﺪﻳﺪ اﻟﺼﻔﻮف اﻟﻤﺮاد ﺗﻐﻴﺮهﺎ ﻓﻲ ﺟﻤﻠﺔ اﻟﺸﺮط )‪ (Condition‬ﻓﺈن‬
‫اﻟﺘﻌﺪﻳﻞ ﺳﻴﻜﻮن ﻋﻠﻲ ﺟﻤﻴﻊ ﺻﻔﻮف اﻟﺠﺪول‪.‬‬
‫آﻤﺜﺎل ﻧﺮﻳﺪ ﻧﻘﻞ اﻟﻤﻮﻇﻒ رﻗﻢ ‪ (SCOTT ) 7788‬ﻟﻠﻘﺴﻢ رﻗﻢ ‪. 30‬‬
‫‪Update EMP set deptno=30‬‬
‫;‪Where empno=7788‬‬
‫ﻗﺒﻞ اﺟﺮاء اﻟﺘﻌﺪﻳﻞ آﺎن رﻗﻢ اﻟﻘﺴﻢ ‪ 20‬ﻟﻠﻤﻮﻇﻒ ‪. SCOTT‬‬

‫ﺑﻌﺪ اﺟﺮاء اﻟﺘﻌﺪﻳﻞ اﺻﺒﺢ رﻗﻢ اﻟﻘﺴﻢ ‪ 30‬ﻟﻠﻤﻮﻇﻒ ‪. SCOTT‬‬

‫*إذا ﺣﺬﻓﺖ ﻓﻘﺮة ‪ WHERE‬ﻓﺄن آﻞ ﺻﻔﻮف اﻟﺠﺪول ﺳﻮف ﺗﻌﺪل وﻳﺼﺒﺢ اﻟﻤﻮﻇﻔﻴﻦ آﻠﻬﻢ ﻓﻰ‬
‫اﻻدارة رﻗﻢ ‪.30‬‬
‫‪ Update Tow Column With SubQuery‬ﺗﻌﺪﻳﻞ اﻟﺒﻴﺎﻧﺎت ﺑﺎﺳﺘﺨﺪام ‪Subquery‬‬

‫اﻟﻤﺜﺎل اﻟﺘﺎﻟﻰ ﻳﺮﻳﺪ ﺗﻌﺪﻳﻞ اﻟﻤﻮﻇﻒ رﻗﻢ ‪ 114‬ﺑﻮﻇﻴﻔﺔ وﻣﺮﺗﺐ اﻟﻤﻮﻇﻒ رﻗﻢ ‪.205‬‬

‫هﻨﺎ ﻧﺠﺪ أﻣﻜﺎﻧﻴﺔ ﺗﻌﺪﻳﻞ اﻟﺒﻴﺎﻧﺎت ﺑﺎﺳﺘﺨﺪام اآﺜﺮ ﻣﻦ اﺳﺘﻌﻼم ﻓﺮﻋﻲ آﻤﺎ ﻓﻰ اﻟﻤﺜﺎل اﻟﺴﺎﺑﻖ‪.‬‬

‫ﻣﻠﺤﻮﻇﺔ ‪:‬‬
‫إذ ﻟﻢ ﻳﻨﻄﺒﻖ اﻟﺸﺮط ﺑﻤﻌﻨﻰ ﻋﺪم وﺟﻮد اى ﻣﻮﻇﻒ ﺑﺎﻟﺮﻗﻢ ‪ 114‬ﺗﻈﻬﺮ‬
‫وﺑﺎﻟﺘﺎﻟﻰ ﻟﻢ ﻳﻘﻢ ﺑﺎﺟﺮاء‬ ‫ﻟﻨﺎ ﺗﻠﻚ اﻟﺮﺳﺎﻟﺔ ‪ 0 Rows Updated‬ﺑﻤﻌﻨﻰ ان اﻟﺸﺮط ﻟﻢ ﻳﺘﺤﻘﻖ‬
‫اى ﺗﻐﻴﺮ ﺑﺎﻟﺠﺪول‪.‬‬

‫*ﺗﻌﺪﻳﻞ ﺻﻔﻮف ﻣﻌﺘﻤﺪا ﻋﻠﻲ ﺟﺪول ﺁﺧﺮ‬

‫ﻳﻤﻜﻦ أن ﺗﺴﺘﺨﺪم اﻻﺳﺘﻌﻼم اﻟﻔﺮﻋﻲ آﻲ ﺗﻌﺪل ﺻﻔﻮف ﺑﺠﺪول ﻋﻦ ﻃﺮﻳﻖ اﺳﺘﺨﺪام ﺑﻴﺎﻧﺎت‬
‫ﻣﻦ ﺟﺪول اﺧﺮ آﻤﺎ ﻓﻰ اﻟﻤﺜﺎل اﻟﺴﺎﺑﻖ ‪.‬‬
‫اﻟﻤﺜﺎل اﻟﻤﻌﺮوض ﻟﺘﻌﺪﻳﻼت ﺑﺠﺪول ‪ COPY_EMP‬ﻣﻌﺘﻤﺪ ﻋﻠﻲ ﻗﻴﻢ ﻣﻦ ﺟﺪول اﻟﻤﻮﻇﻔﻴﻦ‪.‬‬

‫‪(Primary‬‬ ‫ﻋﻨﺪ ﻣﺤﺎوﻟﺔ ﺗﻌﺪﻳﻞ اﻟﻤﻔﺘﺎح اﻷﺟﻨﺒﻲ )‪ (Foreign Key‬ﺑﺮﻗﻢ ﻏﻴﺮ ﻣﻮﺟﻮد ﻓﻰ ﻋﻤﻮد‬
‫)‪ Key‬اﻟﻤﺮﺗﺒﻂ ﺑﺔ ﺑﺎﻟﺠﺪول اﻻﺧﺮ ﻓﻴﻨﺘﺞ ﻋﻦ ذﻟﻚ ‪.Error‬‬
‫ﻓﻔﻰ اﻟﻤﺜﺎل اﻟﺴﺎﺑﻖ ﺣﺎول ﺗﻐﻴﺮ رﻗﻢ اﻟﻘﺴﻢ ‪ 110‬ﺑﺎﻟﺮﻗﻢ ‪ 55‬ﻣﻊ اﻟﻌﻠﻢ ان اﻟﺮﻗﻢ ‪ 55‬ﻏﻴﺮ ﻣﻮﺟﻮد‬
‫ﺑﻌﻤﻮد اﻻﻗﺴﺎم )‪ (Primary Key‬ﺑﺠﺪول اﻻﻗﺴﺎم وﻟﻬﺬا ﺣﺪث ‪. Error‬‬
 ‫وهﺬا ﻳﻌﻨﻲ أن رﻗﻢ اﻹدارة اﻟﺠﺪﻳﺪ ﻻﺑﺪ أن ﻳﻜﻮن ﻣﻮﺟﻮد ﻓﻰ ﻋﻤﻮد )‪ (Primary Key‬ﺑﺎﻟﺠﺪول‬
‫اﻟﺮﺋﻴﺴﻰ اوﻻ‪.‬‬

‫‪Removing a Row from Table‬‬

‫ﺣﺬف اﻟﺼﻒ ﻣﻦ اﻟﺠﺪول‬

‫ﺟﺪول اﻷﻗﺴﺎم‬

‫ﺗﻢ ﺣﺬف ﺻﻒ ﻣﻦ ﺟﺪول اﻷﻗﺴﺎم‬

‫ﻟﺤﺬف ﺻﻒ أو ﻣﺠﻤﻮﻋﺔ ﻣﻦ اﻟﺼﻔﻮف ﻟﺠﺪول ﻣﺎ ﻧﺴﺘﺨﺪم اﻷﻣﺮ ‪Delete‬‬

‫وﻳﺘﻢ آﺘﺎﺑﺘﺔ آﻤﺎ ﻳﻠﻲ‪:‬‬
‫‪1-Delete‬‬ ‫‪ 2- From‬ﺛﻢ‬ ‫‪3- Table‬‬

‫اﻟﺠﺪول اﻟﺬي ﻳﺘﻢ اﻟﺤﺬف ﻣﻨﻪ‬

‫ﺛﻢ ﺟﻤﻠﺔ اﻟﺸﺮط ‪ WHERE‬اﻟﺘﻲ ﺳﺘﺤﺪد اﻟﺼﻒ اﻟﻤﺮاد ﺣﺬﻓﻪ‪ .‬وﻳﺠـﺐ ﻣﻼﺣﻈـﺔ أﻧـﻪ ﻓـﻲ ﺣﺎﻟـﺔ‬
‫إﻏﻔﺎل ﺟﻤﻠﺔ اﻟﺸﺮط ﻓﺈﻧﻪ ﻳﻘﻮم ﺑﺤﺬف آﻞ ﺻﻔﻮف اﻟﺠﺪول‪.‬‬
‫واﻟﻤﺜﺎل اﻟﺴﺎﺑﻖ ﻳﺤﺬف ﻗﺴﻢ اﻟﻤﺎﻟﻴﺔ ﻣﻦ ﺟﺪول اﻷﻗﺴﺎم‪.‬‬

‫ﻣﻠﺤﻮﻇﺔ ‪:‬‬
‫إذا ﻟﻢ ﻳﻜﻦ هﻨﺎك ﺻﻒ ﻳﻨﻄﺒﻖ ﻋﻠﻴﺔ اﻟﺸﺮط ﻓﺘﻈﻬﺮ ﺗﻠﻚ اﻟﺮﺳﺎﻟﺔ ‪ 0 Rows Deleted‬وﺗﻌﻨﻰ‬
‫ﻋﺪم اﻟﻘﻴﺎم ﺑﺤﺬف اى ﺻﻒ‪.‬‬
‫ﺣﺬف ﺻﻔﻮف ﻣﻌﺘﻤﺪة ﻋﻠﻲ ﺟﺪول ﺁﺧﺮ ذﻟﻚ ﻋﻦ ﻃﺮﻳﻖ اﺳﺘﺨﺪم اﻻﺳﺘﻌﻼم‬
‫اﻟﻔﺮﻋﻲ )‪ (SubQuery‬ﻓﻲ ﻓﻘﺮة ‪. Where‬‬

‫ﻳﻤﻜﻨﻚ اﺳﺘﺨﺪام اﻻﺳﺘﻌﻼم اﻟﻔﺮﻋﻲ آﻲ ﺗﺤﺬف ﺻﻔﻮف ﻣﻦ ﺟﺪول ﻣﻌﺘﻤﺪا ﻋﻠﻲ ﻗﻴﻢ ﻣﻦ ﺟﺪول‬
‫أﺧﺮ ﻓﻰ ﺟﻤﻠﺔ اﻟﺸﺮط‪.‬‬
‫واﻟﻤﺜﺎل اﻟـﺴﺎﺑﻖ ﻳﻘـﻮم ﺑﺤـﺬف آـﻞ اﻟﻤـﻮﻇﻔﻴﻦ ﺑﺎﻟﻘـﺴﻢ اﻟـﺬي ﻳﺤﺘـﻮي اﺳـﻤﺔ ﻋﻠـﻲ ﻣﺠﻤﻮﻋـﺔ‬
‫اﻟﺤﺮوف “ ‪ ، ”Public‬واﻻﺳﺘﻌﻼم اﻟﻔﺮﻋﻲ ﻳﺒﺤﺚ ﻓﻰ ﺟـﺪول اﻷﻗـﺴﺎم ﻋـﻦ رﻗـﻢ اﻟﻘـﺴﻢ اﻟـﺬي‬
‫ﻳﺤﺘﻮي اﺳﻤﺔ ﻋﻠﻲ ﻣﺠﻤﻮﻋﺔ اﻟﺤﺮوف “ ‪. ”Public‬‬

‫*ﻣﻼﺣﻈﺔ ‪:‬‬
‫ﻋﻨﺪ اﺟﺮاء ﻋﻤﻠﻴﺔ ﺣﺬف ﻓﻰ ﺟﺪول ﻓﻼ ﻳﻤﻜﻦ ﺣﺬف ﻋﻤﻮد ﻳﺘﻢ اﻻﻋﺘﻤﺎد ﻋﻠﻴﺔ ﻓﻰ ﺟﺪول اﺧﺮ اى‬
‫ان ﺗﻠﻚ اﻟﻌﻤﻮد ‪ Primary Key‬و ﻟﻌﻼج ذﻟﻚ ﻻﺑﺪ ﻣﻦ ﺣﺬف آﻞ اﻟﺼﻔﻮف اﻟﻤﻮﺟﻮدة ﻓﻰ اﻟﺠﺪول‬
‫اﻻﺧﺮ ﺑﻌﻤﻮد )‪ (Foreign Key‬اوﻻ ‪.‬‬
‫*ﻳﻤﻜﻨﻚ اﻻﺳﺘﻐﻨﺎء ﻋﻦ آﻠﻤﺔ ‪ From‬آﻤﺎ ﻓﻰ اﻟﻤﺜﺎل اﻟﺘﺎﻟﻰ‪:‬‬
‫‪Delete employees‬‬
‫;‪Where employees_id=7788‬‬
‫اﺳﺘﺨﺪام اﻻﺳﺘﻌﻼم اﻟﻔﺮﻋﻲ ﻓﻲ ﺗﻌﺒﻴﺮ ‪INSERT‬‬

‫‪INTO‬‬ ‫ﻳﻤﻜﻦ أن ﺗﺴﺘﺨﺪم اﻻﺳﺘﻌﻼم اﻟﻔﺮﻋﻲ )‪ (Subquery‬ﺑﺪﻻ ﻣﻦ اﺳﻢ اﻟﺠﺪول ﻓﻲ ﻓﻘﺮة‬

‫ﻓﻰ ﻓﻘﺮة ‪. INSERT‬‬
‫ﻻﺣﻆ ان ﻗﺎﺋﻤﺔ اﻻﻋﻤﺪة ﻓﻰ اﻻﺳﺘﻌﻼم اﻟﻔﺮﻋﻲ )‪ (SubQuery‬ﻳﺠﺐ أن ﻳﻜﻮن ﺑﻨﻔﺲ اﻟﺘﺮﺗﻴﺐ‬
‫ﻟﻠﻘﻴﻢ ﻓﻰ ﻓﻘﺮة ‪.VALUES‬‬

‫‪Using With Check Option on DML Statement‬‬

‫ﺗﺴﺘﺨﺪم ﻓﻘﺮة ‪ With Check Option‬ﻋﻨﺪﻣﺎ ﺗﺮﻳﺪ ﺗﺤﺪﻳﺪ ﺑﻌﺾ اﻟﺸﺮوط ﻋﻨﺪ اﺿﺎﻓﺔ ﺻﻔﻮف‬
‫ﺟﺪﻳﺪة ‪.‬‬

‫ﻓﻘﺮة ‪ WITH CHECK OPTION‬ﺗﻤﻨﻌﻚ ﻣﻦ اﺿﺎﻓﺔ ﺻﻔﻮف ﻟﻴﺴﺖ ﻓﻲ اﻻﺳﺘﻌﻼم اﻟﻔﺮﻋﻲ‪.‬‬

‫ﻓﺎﻟﻤﺜﺎل اﻟﺴﺎﺑﻖ آﺎن ﺳﺒﺐ ‪ Error‬اﻧﺔ ﻟﻢ ﻳﻘﻢ ﺑﺎﺿﺎﻓﺔ رﻗﻢ اﻟﻘﺴﻢ اﻟﻤﺤﺪد ﻓﻰ ﺟﻤﻠﺔ اﻟﺸﺮط‬
‫وهﻮ )‪ (50‬ﻓﻰ ﻋﻤﻮد رﻗﻢ اﻻﻗﺴﺎم ﺑﺎﻟﻨﺴﺒﺔ ﻟﻠﺼﻒ اﻟﺠﺪﻳﺪ‪.‬‬
‫وﻟﻤﻌﺎﻟﺠﺔ ذﻟﻚ ﻧﻘﻢ ﺑﺎﺿﺎﻓﺔ اﻟﻘﺴﻢ ‪ 50‬ﻟﻠﻤﻮﻇﻒ اﻟﺠﺪﻳﺪ ﺣﻴﺚ اﻧﺔ ﺗﻢ ﺗﺤﺪﻳﺪة ﻓﻰ ﺟﻤﻠﺔ‬
‫‪. Where‬اى اﻧﻨﺎ ﻻﻳﻤﻜﻨﺎ ﻣﻦ اﺿﺎﻓﺔ ﻣﻮﻇﻔﻴﻦ اﻻ ﻓﻰ اﻟﻘﺴﻢ رﻗﻢ ‪.50‬‬

‫‪Insert into (select employee_id, last_name, email,‬‬

‫‪hire_date,job_id,salary,‬‬
‫‪department_id from employees‬‬
‫)‪where department_id=50 with check option‬‬
‫‪values (9999, 'SMITH', 'JSMITH',‬‬
‫;)‪to_date ('12-oct-81','dd-mon-rr'), 'ST_CLERK' ,50000 ,50‬‬
‫‪1 row created‬‬
‫اﻣﺎ اذا ﻗﻤﻨﺎ ﺑﺘﻐﻴﺮ رﻗﻢ اﻟﻘﺴﻢ ﺑﺤﻴﺚ ﻳﻜﻮن ﻣﺨﺘﻠﻒ ﻋﻦ رﻗﻢ اﻟﻘﺴﻢ اﻟﻤﺤﺪد ﻓﻰ ﺟﻤﻠﺔ‬
‫‪ WHERE‬ﻓﻔﻰ ﺗﻠﻚ اﻟﺤﺎﻟﺔ ﻻﻳﺴﻤﺢ ﺑﺬﻟﻚ آﻤﺎ ﻓﻰ اﻟﻤﺜﺎل اﻟﺘﺎﻟﻰ وﻻﺣﻆ رﻗﻢ اﻟﻘﺴﻢ اﻟﺠﺪﻳﺪ‪:‬‬
‫‪Insert into (select employee_id, last_name, email,‬‬
‫‪hire_date,job_id,salary,‬‬
‫‪department_id from employees‬‬
‫)‪where department_id=50 with check option‬‬
‫‪values (9999, 'SMITH', 'JSMITH',‬‬
‫;)‪to_date ('12-oct-81','dd-mon-rr'), 'ST_CLERK' , 50000 ,30‬‬
 ‫اﺳﺘﺨﺪام اﻟﻘﻴﻢ اﻟﻤﺤﺪدة ﺳﺎﺑﻘﺎ )‪(DEFAULT‬‬

‫‪ Default‬هﻮ ﻗﻴﻤﺔ اﻓﺘﺮاﺿﻴﺔ ﺗﻢ وﺿﻌﻬﺎ ﻟﻌﻤﻮد ﻣﻌﻴﻦ وذﻟﻚ ﻋﻨﺪ اﻧﺸﺎء اﻟﺠﺪول‪ .‬ﺑﺤﻴﺚ اذا ﻟﻢ ﻳﺘﻢ‬
‫ادﺧﺎل ﺑﻴﺎﻧﺎت ﻣﺤﺪدة ﻓﻰ ﺗﻠﻚ اﻟﻌﻤﻮد ﻳﻤﻜﻨﻚ اﺳﺘﺨﺪام‬
‫‪ Default‬اﻟﻤﺤﺪد ﻣﺴﺒﻘﺎ آﻤﺎ ﻓﻰ اﻟﻤﺜﺎل اﻟﺴﺎﺑﻖ‪.‬‬
‫وهﺬا ﺳﻮف ﻳﻨﺎﻗﺶ إن ﺷﺎء اﷲ ﺗﻌﺎﻟﻲ ﻓﻲ اﻟﻔﺼﻞ اﻟﺘﺎﻟﻰ‪.‬‬

‫‪The MERGE Statement‬‬

‫‪) MERGE‬اﻟﺪﻣﺞ(‬

‫‪ -1‬اﻣﻜﺎﻧﻴﺔ اﻟﺘﻌﺪﻳﻞ ﻓﻰ ﺑﻴﺎﻧﺎت ﺑﺸﻜﻞ ﺷﺮﻃﻲ أوإدﺧﺎل ﺑﻴﺎﻧﺎت ﻓﻲ ﺟﺪاول ﻗﻮاﻋﺪ اﻟﺒﻴﺎﻧﺎت‪.‬‬
‫‪ -2‬زﻳﺎدة اﻷداء واﻟﺴﻬﻮﻟﺔ ﻓﻲ اﻻﺳﺘﺨﺪام و ﻣﻔﻴﺪ ﻓﻲ ﺗﺨﺰﻳﻦ اﻟﺒﻴﺎﻧﺎت‪.‬‬
‫‪ -3‬أﻣﺮ ‪ MERGE‬ﻳﺠﻤﻊ أواﻣﺮ ‪ INSERT, UPDATE‬ﺣﻴﺚ أﻧﻚ ﺗﺤﺘﺎج آﻼهﻤﺎ‪.‬‬
‫‪ -4‬أﻣﺮ ‪ MERGE‬ﻳﻘﻮم ﺑﺪﻣﺞ ﺟﺪوﻟﻴﻦ ﻣﻌﺎ وﻟﻜﻰ ﻳﺘﻢ ذﻟﻚ ﻓﻼﺑﺪ ﻣﻦ اﻟﺘﺎآﺪ ان‬
‫آﻼ ﻣﻦ اﻟﺠﺪوﻟﻴﻦ ﻳﺘﻀﻤﻦ ﻧﻔﺲ ﻋﺪد اﻻﻋﻤﺪة وﺑﻨﻔﺲ ﻧﻮع اﻟﺒﻴﺎﻧﺎت‪.‬‬

‫اﻟﺼﻴﻐﺔ اﻟﺮﺋﻴﺴﻴﺔ ﻟﺠﻤﻠﺔ ‪MERGE‬‬

‫‪MERGE‬‬ ‫ﻳﻤﻜﻨﻚ ﺗﻌﺪﻳﻞ اﻟﺼﻔﻮف اﻟﻤﻮﺟﻮدة و إدﺧﺎل ﺻﻔﻮف ﺷﺮﻃﻴﺔ ﺟﺪﻳﺪة ﺑﺎﺳﺘﺨﺪام ﺗﻌﺒﻴﺮ‬
‫وﻳﻌﻨﻰ ادﻣﺞ‪.‬‬
‫ﺗﺤﺪﻳﺪ اﻟﺠﺪول اﻟﻤﺴﺘﻬﺪف اﻟﺬي ﻳﺘﻢ ﺗﻌﺪﻳﻠﺔ او أدﺧﺎل‬ ‫ﻓﻘﺮة ‪INTO‬‬
‫ﺑﻴﺎﻧﺎت ﻋﻠﻴﻪ‪.‬‬
‫ﻳﻌﻨﻰ ﻣﺼﺪر اﻟﺒﻴﺎﻧﺎت آﻲ ﺗﻌﺪل أو ﺗﺪﺧﻞ‪.‬‬ ‫ﻓﻘﺮة ‪USING‬‬
‫اﻟﺸﺮط اﻟﺬى ﻳﻌﺘﻤﺪ ﻋﻠﻴﺔ ﻓﻰ ‪. MERGE‬‬ ‫ﻓﻘﺮة ‪ON‬‬
‫و ﻳﻌﻨﻰ ﻣﺎذا ﻳﻔﻌﻞ ﻋﻨﺪ ﺗﺤﻘﻖ اﻟﺸﺮط ‪.‬‬ ‫‪WHEN MATCHED‬‬
‫‪ WHEN NOT MATCHED‬و ﻳﻌﻨﻰ ﻣﺎذا ﻳﻔﻌﻞ ﻋﻨﺪ ﻋﺪم ﺗﺤﻘﻖ اﻟﺸﺮط ‪.‬‬
 ‫ﻣﺜﺎل ﻋﻠﻲ دﻣﺞ ﺻﻔﻮف آﻼ ﻣﻦ ﺟﺪول ‪ Employees‬وﺟﺪول ‪Copy_emp‬‬

‫اﻟﺸﺮط اﻟﻤﻮﺟﻮد ﻓﻰ اﻟﻤﺜﺎل اﻟﺴﺎﺑﻖ هﻮ ﺗﺴﺎوى رﻗﻢ اﻟﻤﻮﻇﻒ ﻓﻰ آﻼ ﻣﻦ اﻟﺠﺪوﻟﻴﻦ وﻋﻨﺪ‬

‫ﺗﺤﻘﻖ ﺗﻠﻚ اﻟﺸﺮط ﻳﻘﻮم ﺑﺘﻌﺪﻳﻞ اﻟﺒﻴﺎﻧﺎت ﻓﻰ ﺟﺪول ‪ Copy_emp‬ﺑﺎﻟﺒﻴﺎﻧﺎت اﻟﻤﻮﺟﻮدة ﻓﻰ ﺟﺪول‬
‫‪. Employees‬‬
‫وﻋﻨﺪ ﻋﺪم ﺗﺤﻘﻖ ﺗﻠﻚ اﻟﺸﺮط ﻓﻬﺬا ﻳﻌﻨﻰ ان اﻟﻤﻮﻇﻒ ﻏﻴﺮ ﻣﻮﺟﻮد ﻓﻰ ﺟﺪول ‪Copy_emp‬‬
‫وﻟﻬﺬا ﺳﻮف ﻧﻘﻮم ﺑﺎﺿﺎﻓﺔ ﺗﻠﻚ اﻟﻤﻮﻇﻒ اﻟﻰ ﺟﺪول ‪. Copy_emp‬‬
‫واﻟﻬﺪف ﻣﻦ ‪ MERGE‬ان ﻳﻜﻮن ﺑﻴﺎﻧﺎت اﻟﺠﺪوﻟﻴﻦ ﻣﺘﻤﺎﺛﻠﺔ‪.‬‬

‫) ‪(Database Transactions‬‬
‫ﺗﺤﺘﻮي ﻋﻠﻲ واﺣﺪ ﻣﻦ اﻟﺘﺎﻟﻲ‪-:‬‬
‫‪ -‬ﺗﻌﺒﻴﺮ ‪(Data Manipulating Language) DML‬وﺗﺤﺘﻮى ﻋﻠﻰ‪:‬‬
‫‪(INSERT,UPDATE,DELETE,MERGE) -‬‬
‫‪ -‬ﺗﻌﺒﻴﺮ ‪ (Data Definition Language) DDL‬وﺗﺤﺘﻮى ﻋﻠﻰ‪:‬‬
‫‪(CREATE,MODIFY,DROP,RNAME,TRUNCATE) -‬‬
‫‪ -‬ﺗﻌﺒﻴﺮ ‪(Data Control Language) DCL‬و ﺗﺤﺘﻮى ﻋﻠﻰ‪(GRANT,REVOKE) :‬‬
‫ﻣﻌﺎﻣﻼت اﻟﺘﺤﻜﻢ‬

‫ﻳﻤﻜﻨﻚ اﻟﺘﺤﻜﻢ ﻓﻲ اﻟﻤﻌﺎﻣﻼت ﺑﺎﺳﺘﺨﺪام أواﻣﺮ ‪.COMMIT,SAVEPOINT,ROLLBACK‬‬

‫اﻷواﻣﺮ‬ ‫اﻟﻮﺻﻒ‬
‫ﻳﻘﻮم ﺑﺤﻔﻆ اى ﺗﻌﺪﻳﻼت ﻋﻠﻰ ﻗﺎﻋﺪة اﻟﺒﻴﺎﻧﺎت‬
‫‪COMMIT‬‬
‫ﻣﻦ ‪.,Insert,Update,Delete,MERGE‬‬
‫‪SAVEPOINT name‬‬ ‫ﻣﺆﺷﺮات ﻟﺤﻔﻆ اﻟﺒﻴﺎﻧﺎت اﻟﻰ ﺣﺪ او ﻣﻜﺎن ﻣﻌﻴﻦ‬
‫‪ROLLBACK‬‬ ‫ﻳﻘﻮم ﺑﺎﻟﻐﺎء آﻞ اﻟﺘﻐﻴﺮات اﻟﺘﻰ ﺗﻤﺖ‬
‫ﻳﻘﻮم ﺑﺎﻟﺮﺟﻮع ﺣﺘﻰ ﻧﻘﻄﺔ ﻣﻌﻴﻨﺔ ﻣﺤﺪدة ﻓﻰ ﻓﻘﺮة‬
‫‪ROLLBACK TO‬‬
‫) ‪ .(savepoint‬ﺣﺘﻰ ﻳﺘﺮاﺟﻊ ﻋﻦ ﺟﺰﺋﻴﺔ ﻣﻌﻴﻨﺔ ﻣﻦ‬
‫‪SAVEPOINT name‬‬
‫اﻟﻌﻤﻠﻴﺎت ‪.‬‬
 ‫ﺑﻌﻤﻞ‬ ‫*ﻳﺴﺘﺨﺪم اﻻﻣﺮ ‪ Commit‬ﻟﺤﻔﻆ اى ﺗﻌﺪﻳﻼت ﻓﻰ ﻗﺎﻋﺪة اﻟﺒﻴﺎﻧﺎت ﻓﺄذا ﻗﻤﺖ‬
‫‪ DML‬واردت ﺣﻔﻆ ﺗﻠﻚ اﻟﺘﻐﻴﺮات ﻓﻼﺑﺪ ﻣﻦ اﺳﺘﺨﺪام اﻻﻣﺮ ‪.Commit‬‬
‫ﻣﺜﺎل‪:‬‬
‫'‪Update emp set ename ='ASAS‬‬
‫;‪Where empno=7782‬‬
‫ﺛﻢ ﺑﻌﺪ ذﻟﻚ‬
‫;‪Commit‬‬
‫ﻓﻬﺬا ﻳﻌﻨﻰ اﻧﻚ ﺗﺮﻳﺪ ﺣﻔﻆ ﺗﻠﻚ اﻟﺘﻐﻴﺮ‪.‬‬

‫*ﻳﺴﺘﺨﺪم اﻻﻣﺮ ‪ Savepoint‬ﻻﻣﻜﺎﻧﻴﺔ اﻧﺸﺎء ﻋﻼﻣﺔ ﺗﺬآﺮك ﺑﺄﺧﺮ اﻟﺘﻌﺪﻳﻼت اﻟﺘﻰ ﻗﻤﺖ ﺑﻬﺎ و‬
‫ﻳﻤﻜﻨﻚ اﻟﺮﺟﻮع اﻟﻴﻬﺎ ‪.‬‬
‫ﻣﺜﺎل‪:‬‬
‫)‪Insert into emp (empno,ename‬‬
‫;)'‪Values(10,'MOMO‬‬
‫ﺛﻢ اردت ﺣﻔﻆ هﺬا اﻟﺘﻌﺪﻳﻞ ﺑﻌﻼﻣﺔ ﻟﻜﻰ ﻳﻤﻜﻨﻚ ﺑﻌﺪ ذﻟﻚ اﻟﺮﺟﻮع ﻟﻬﺎ‪.‬‬
‫;‪Savepoint a‬‬
‫ﺛﻢ ﻗﻤﺖ ﺑﻌﺪ ذﻟﻚ ﺑﺘﻌﺪﻳﻞ ﻣﺮﺗﺐ ﻣﻮﻇﻒ ﻣﻌﻴﻦ ﻣﺜﻼ‬
‫‪Update emp set sal=2500‬‬
‫;‪Where empno=4444‬‬
‫واردت ﺑﻌﺪ ذﻟﻚ اﻟﻐﺎء ﺗﻠﻚ اﻟﺘﻐﻴﺮ اﻻﺧﻴﺮ ﻓﻰ اﻟﻤﺮﺗﺐ ‪.‬ﺑﺪون اﻟﻐﺎء ﺟﻤﻠﺔ ‪ Insert‬اﻻوﻟﻰ‪ .‬وذﻟﻚ‬
‫ﻋﻦ ﻃﺮﻳﻖ اﺳﺘﺨﺪام ‪.Rollback‬‬

‫*ﻳﺴﺘﺨﺪم اﻻﻣﺮ ‪ Rollback‬ﻻﻣﻜﺎﻧﻴﺔ اﻟﺮﺟﻮع ﻋﻦ آﻞ اﻟﺘﻌﺪﻳﻼت اﻟﺘﻰ ﺗﻤﺖ او ﻟﺘﺤﺪﻳﺪ اﻟﻤﻜﺎن‬

‫اﻟﺬى ﺗﺮﻏﺐ ﻓﻰ اﻟﺮﺟﻮع اﻟﻴﺔ‪.‬‬

‫ﻣﺜﺎل‪:‬‬
‫اذا اردﻧﺎ اﻟﺮﺟﻮع اﻟﻰ اﺧﺮ ﺗﻌﺪﻳﻞ ﺣﺪث ﻓﻨﻘﻮم ﺑﺎﻻﺗﻰ‪:‬‬

‫;‪Rollback to a‬‬
 ‫ﻣﻠﺨﺺ اﻟﻔﺼﻞ‬

‫ﺗﻨﺎوﻟﻨﺎ ﻣﻦ ﺧﻼل هﺬا اﻟﻔﺼﻞ ﻣﻮﺿﻮع اﺿـﺎﻓﺔ اﻟﺒﻴﺎﻧـﺎت إﻟـﻰ اﻟﺠـﺪاول ﺑﻮاﺳـﻄﺔ ﺟﻤﻠـﺔ ‪INSERT‬‬
‫وهﻨﺎﻟﻚ ﺛﻼﺛﺔ ﻃﺮق ﻹﺟﺮاء ﻋﻤﻠﻴﺔ اﻹﺿﺎﻓﺔ‬

‫إﺿﺎﻓﺔ ﺳﺠﻞ واﺣﺪ إﻟﻰ ﺟﺪو ل اﻟﺒﻴﺎﻧﺎت‬ ‫™‬

‫ﺑﻬﺬﻩ اﻟﻀﺮﻳﻔﺔ ﺳﻮف ﻳﺘﻢ إﺿﺎﻓﺔ ﺑﻴﺎﻧﺎت ﺳﺠﻞ واﺣﺪ ﻓﻘﻂ إﻟﻰ ﺟﺪول ﻳﺤﺘـﻮي ﻋﻠـﻰ اﻟﻘـﻴﻢ اﻟﺘـﻲ‬
‫ﺳﺘﺬآﺮ ﻓﻲ ﺟﻤﻠﺔ اﻹدﺧﺎل‬

‫إﺿﺎﻓﺔ ﻋﺪة ﺳﺠﻼت إﻟﻰ ﺟﺪول اﻟﺒﻴﺎﻧﺎت‬ ‫™‬

‫ﺑﻬﺬﻩ اﻟﻄﺮﻳﻘﺔ ﻳﻤﻜﻦ إدﺧﺎل أآﺜﺮ ﻣـﻦ ﺳـﺠﻞ واﺣـﺪ إﻟـﻰ ﺟـﺪول اﻟﺒﻴﺎﻧـﺎت ﻋـﻦ ﻃﺮﻳـﻖ اﺳـﺘﺨﺪام‬
‫ﻣﺘﻐﻴﺮات اﻻدﺧﺎل وهﻲ ﻋﺒﺎرة ﻋﻦ ﻣﺘﻐﻴﺮات ﺗﻮﺿـﻊ ﻓـﻲ ﺟﻤﻠـﺔ اﻹدﺧـﺎل ﺑـﺪﻻ ﻣـﻦ اﻟﻘـﻴﻢ ﻧﻔـﺴﻬﺎ‬
‫وﻳﻤﻜﻦ أن ﻧﻄﻠﻖ ﻋﻠﻰ هﺬﻩ اﻟﻄﺮﻳﻘﺔ ﺟﻤﻠﺔ اﻻدﺧﺎل ﻣﺘﻌﺪدة اﻟﺴﺠﻼت‬

‫إﺿﺎﻓﺔ ﺳﺠﻼت ﻓﻲ ﺟﺪول ﻋﻦ ﻃﺮﻳﻖ ﻧﺴﺨﻬﺎ ﻣﻦ ﺟﺪول ﺁﺧﺮ‬ ‫™‬

‫ﺑﻬﺬﻩ اﻟﻄﺮﻳﻘﺔ ﻳﻤﻜﻦ إدﺧﺎل أآﺜﺮ ﻣﻦ ﺳﺠﻞ واﺣـﺪ إﻟـﻰ ﺟـﺪول اﻟﺒﻴﺎﻧـﺎت ﻋـﻦ ﻃﺮﻳـﻖ ﻧـﺴﺦ هـﺬا‬
‫اﻟﺴﺠﻞ ‪ /‬اﻟﺴﺠﻼت ﻣﻦ ﺟﺪول ﺁﺧﺮ ﺑﻮاﺳﻄﺔ ﺟﻤﻠﺔ ‪ SELECT‬اﻟﻤﻮﺟﻮدة ﺑﺪاﺧﻞ ﺟﻤﻠﺔ ‪INSERT‬‬

‫ﺗﻌﺪﻳﻞ ﺑﻴﺎﻧﺎت ﺣﻘﻞ‪ /‬ﺣﻘﻮل ﻟﺴﺞ واﺣﺪ أو اآﺜﺮ‬ ‫™‬

‫ﺣﻴﺚ ﻳﺘﻢ اﻟﻐﺎء اﻟﻘﻴﻢ اﻟﻤﻮﺟﻮدة ﺑﻬﺎ ﻟﺘﺤﺘﻮي ﻋﻠﻰ اﻟﻘﻴﻢ اﻟﺠﺪﻳﺪة اﻟﻤﺬآﻮرة ﻓـﻲ ﺟﻤﻠـﺔ اﻟﺘﻌـﺪﻳﻞ‬
‫ﻋﻠﻤﺎ ﺑﺄن اﻟﺴﺠﻼت اﻟﺘﻲ ﺳﻴﺘﺘﻢ اﻟﺘﻌﺪﻳﻞ ﺑﻬﺎ هﻲ اﻟﺴﺠﻼن اﻟﺘﻲ ﺗﺤﻘﻖ اﻟﺸﺮط‪.‬‬

‫ﻧﻌﺪﻳﻞ ﺑﻴﺎﻧﺎت ﺣﻔﻞ ‪ /‬ﺣﻘﻮل ﻟﺠﻤﻴﻊ اﻟﺴﺠﻼت ﻓﻲ اﻟﺠﺪول‬ ‫™‬

‫ﺣﻴﺚ ﻳﺘﻢ اﻟﻐﺎء اﻟﻘﻴﻢ اﻟﻤﻮﺟﻮدة ﺑﻬﺎ ﻟﺘﺤﺘﻮي ﻋﻠﻰ اﻟﻘﻴﻢ اﻟﺠﺪﻳﺪة اﻟﻤﺬآﻮرة ﻓـﻲ ﺟﻤﻠـﺔ اﻟﺘﻌـﺪﻳﻞ‬
‫ﻋﻠﻤﺎ اﻧﻪ ﺳﻴﺘﻢ ﺗﻌﺪﻳﻞ ﺑﻴﺎﻧﺎت ﺟﻤﻴﻊ اﻟﺤﻘﻮل ﻟﻌﺪم وﺟﻮد ﺷﺮط‬

‫ﺛﻢ ﺗﻨﺎوﻟﻨﺎ ﻣﻮﺿﻮع ﺣﺬف اﻟﺴﺠﻼت ﻋﻦ ‪ DELETE‬وهﻨﺎﻟﻚ ﻃﺮﻳﻘﺘﺎن ﻹﺟﺮاء ﻋﻤﻠﻴﺔا اﻟﺤﺬف‬

‫ﺣﺬف ﺳﺠﻞ أو أآﺜﺮ ﻣﻦ اﻟﺠﺪول‬ ‫™‬

‫ﺑﻬﺬﻩ اﻟﻄﺮﻳﻘﺔ ﺳﻮف ﻳﺘﻢ ﺣﺬف اﻟﺴﺠﻞ ‪ /‬اﻟﺴﺠﻼت اﻟﺘﻲ ﺗﺤﻘﻖ اﻟﺸﺮط ﻓﻲ ﺟﻤﻠﺔ اﻟﺸﺮط‬

‫ﺛﺎﻧﻴﺎ ‪ :‬ﺣﺬف ﺟﻤﻴﻊ ﺳﺠﻼت اﻟﺠﺪول‬ ‫™‬

‫ﺑﻬﺬﻩ اﻟﻄﺮﻳﻘﺔ ﺳﻮف ﻳﺘﻢ ﺣﺬف ﺟﻤﻴﻊ اﻟﺴﺠﻼت ﻓﻲ اﻟﺠﺪول‬

 ‫ﻧﻈﺮة ﻋﺎﻣﺔ ﻋﻠﻰ اﻟﻜﻮرس‬

‫ﻣﻘﺪﻣﻪ ‪:‬‬
‫‪ PL / SQL‬هﻮ أﻣﺘﺪاد ﻟﻠﻐﺔ ‪ SQL‬ﺑﺄﺿﺎﻓﺔ ﻣﻤﻴﺰات ﻟﻐﺎت اﻟﺒﺮﻣﺠﺔ اﻻﺟﺮاﺋﻴﺔ ‪.‬‬ ‫‪-‬‬
‫وﺟﻤﻞ اﻟﺘﻌﺎﻣﻞ واﻷﺳﺘﻌﻼم اﻟﺨﺎﺻﺔ ﺑﻠﻐﺔ ‪ SQL‬وﻳـﺘﻢ أدراﺟﻬـﺎ داﺧـﻞ اﻟﻜـﻮد اﻟﺨـﺎص ﺑﻠﻐـﺔ‬ ‫‪-‬‬
‫‪. PL / SQL‬‬
‫ﺑﻴﺌﺔ ﻟﻐﺔ ‪ PL / SQL‬ﻓﺼﻞ ﺟﻤﻞ ‪ SQL‬وﺗﻨﻔﻴـﺬ ﺟﻤـﻞ ‪ PL / SQL‬آـﻼ ﻋﻠـﻰ ﺣـﺪى ﻟﻌﻤـﻞ‬ ‫‪-‬‬
‫ﻣﺨﺮﺟﺎت اﻟﺒﺮﻧﺎﻣﺞ ‪.‬‬
‫ﻣﺰاﻳﺎ ﻟﻐﺔ ‪: PL / SQL‬‬ ‫•‬
‫أ‪ -‬اﻟﺘﻜﺎﻣﻞ ‪ :‬وهﺬﻩ اﻟﻠﻐﺔ ﺗﻠﻌﺐ دور أﺳﺎﺳﻰ ﺑﻴﻦ اﺟﺰاء وأدوات أوراآﻞ ﺣﻴﺚ ﻳﻜﺘﺐ ﺑﻬﺎ اآﻮاد‬
‫)‪ (FORMS‬وﻳﺘﻢ ﺑﻬﺎ ﺑﺮﻣﺠﺔ أﺟﺰاء وأدوات اﻻوراآﻞ ‪.‬‬
‫ب‪ -‬ﺗﺤﺴﻴﻦ اﻷداء ‪ :‬ﺣﻴﺚ ﻳﻤﻜﻦ ‪ PL / SQL‬ﺗﺤﺴﻴﻦ اداء اﻟﺘﻄﺒﻴﻘﺎت وذﻟﻚ ﻣﻦ ﺧﻼل ‪:‬‬
‫ﺗﺠﻤﻴﻊ ‪ SQL‬ﻣﻌﺎ ﻓﻰ ﺑﻠﻮك واﺣﺪ ) آﺘﻠـﺔ واﺣـﺪة ( وأرﺳـﻠﻬﻤﺎ اﻟـﻰ ﺧـﺎدم )‪(Data base‬‬ ‫‪-‬‬
‫ﻟﺘﻨﻔﻴﺬهﺎ دﻓﻌﺔ واﺣﺪة وذﻟﻚ ﻳﺆدى اﻟىﺎ أرﺗﻔﺎع ﻣﺴﺘﻮى اﻻداء ﻋﺎﻣﺔ ‪.‬‬
‫ﻳﻤﻜﻦ ﻟـ ‪ PL / SQL‬اﻟﻌﻤﻞ داﺧﻞ اى ﺟﺰء ﻣﻦ أﺟﺰاء وأدوات أوراآـﻞ وذﻟـﻚ ﻳـﻀﻴﻒ ﻗـﻮة‬ ‫‪-‬‬
‫‪Oracle forms‬‬ ‫‪، oracle reports‬‬ ‫اﻟﻤﻌﺎﻟﺠــﺔ اﻻﺟﺮاﺋﻴــﺔ اﻟــﻰ هــﺬﻩ اﻻدوات ﻣﺜــﻞ‬
‫‪ .................. ،‬ﻣﻤﺎ ﻳﺆدى اﻟﻰ ﺗﺤﺴﻦ ﻣﺴﺘﻮى اﻷداء ‪.‬‬
‫ﺟـ‪ -‬ﺗﻄﻮﻳﺮ اﻟﺒﺮﻧﺎﻣﺞ ‪: Modularized‬‬
‫وذﻟﻚ ﺑﺘﺠﻤﻴﻊ ﻣﻨﻄﻘﻰ ﻟﻠﺒﻴﺎﻧﺎت داﺧﻞ آﺘﻞ )‪ (Blocks‬اﻟﺒﺮﻧﺎﻣﺞ ‪.‬‬ ‫‪-‬‬
‫اﻟﻜﺘﻞ اﻟﻤﺘﺪاﺧﻠﺔ ) ‪ ( Nested blocks‬ﺗﺘﻴﺢ اﻟﻌﺪﻳﺪ ﻣﻦ اﻟﻤﺰاﻳﺎ ‪.‬‬ ‫‪-‬‬
‫اﺗﺎﺣﺔ ﺗﻘﺴﻴﻢ اﻟﻤـﺸﺎآﻞ اﻟﻤﻌﻘـﺪة اﻟـﻰ ﻣﺠﻤﻮﻋـﺔ أﺑـﺴﻂ ﻣـﻦ اﻟﻤـﺸﺎآﻞ ﻳﻤﻜـﻦ ﺣﻠﻬـﺎ‬ ‫‪-‬‬
‫ﺑﺒﺴﺎﻃﺔ ‪.‬‬
‫اﻷﺳﺘﻔﺎدة ﻣﻦ ﺧﺒﺮات وأآﻮاد ﺳﺎﺑﻘﺔ ﺑﺠﻤﻌﻬﺎ ﻓﻰ ﺷـﻜﻞ ﻣﻜﺘﺒـﺎت ) ‪ ( Libraries‬ﻳﻤﻜـﻦ‬ ‫‪-‬‬
‫أن اﻻﺳﺘﻔﺎدة ﻣﻨﻬﺎ ﺑﻴﻦ أدوات أوراآﻞ اﻟﻤﺨﺘﻠﻔﺔ ‪.‬‬
‫د ‪ -‬ﻳﻤﻜﻦ ﺗﻨﻔﻴﺬ اﻟﻜﻮد ‪ PL / SQL‬ﻣﻦ اى أدوات ﻣﻦ أدوات اوراآﻞ‬
‫هـــ‪ -‬ﻳﻤﻜــﻦ ﺗﻌﺮﻳــﻒ اﻟﻤﺘﻐﻴــﺮات اﻟﺘــﻰ ﺗــﺴﺘﻘﺒﻞ اﻟﻌﺪﻳــﺪ ﻣــﻦ أﻧــﻮاع اﻟﺒﻴﺎﻧــﺎت اﻟﻤﺨﺘﻠﻔــﺔ ﻣﺜــﻞ‬
‫اﻟﻨﺼﻮص واﻷرﻗﺎم واﻟﺼﻮر واﻟﻔﻴﺪﻳﻮ واﻟﺒﻴﺎﻧﺎت اﻟﻤﺮآﺒﺔ ‪ .....‬اﻟﺦ ‪.‬‬
‫و ‪ -‬وﺗﺤﺘـــﻮى أﻳـــﻀﺎ ﻋﻠـــﻰ اﻟﻤﻤﻴـــﺰات ﻷى ﻟﻐـــﺔ أﺟﺮاﺋﻴـــﺔ ﻣـــﻦ ﺣﻴـــﺚ ﺗﻮاﺟـــﺪ أواﻣـــﺮ ‪loop‬‬
‫واﻟﺘﺤﻜﻢ ﻓﻰ ﺳﻴﺮ اﻟﺒﺮﻧﺎﻣﺞ وﻣﻌﺎﻟﺠﺔ اﻻﺧﻄﺎء واﻷﺳﺘﺜﻨﺎءات ‪.‬‬
‫ﺷﻜﻞ آﺘﻠﺔ ‪: PL / SQL‬‬ ‫•‬
 ‫ﻳﺘﻜﻮن ﺑﻠﻮك او آﺘﻠﺔ ‪ PL / SQL‬ﻣﻦ‪:‬‬
‫‪ -‬ﺟﺰء ﺗﻌﺮﻳﻔﻰ ﻟﻠﻤﺘﻐﻴﺮات ﻟﻠﺘﻌﺎﻣﻞ ﺑﻬﺎ وهﻮ ﺟﺰء أﺧﺘﻴﺎرى ﻟﻴﺲ اﺳﺎﺳﻰ ﻳﺒﺪأ ﺑـ ‪Declare‬‬
‫‪ -‬ﺟﺰء أﺧﺮ أﺳﺎﺳﻰ وﻳﺤﺘﻮى ﻋﻠﻰ ﺟﻤﻞ اﻟﺒﺮﻣﺠﺔ ﻳﺒﺪأ ﻣﻦ )‪ (Begin‬وﻳﻨﺘﻬﻰ ﺑـ );‪(End‬‬
‫‪ -‬ﺟﺰء أﺧﺮ أﺧﺘﻴﺎرى هﻮ ) ‪ ( Exception‬ﻳﺤﺘﻮى ﻋﻠﻰ ﺟﻤـﻞ اﻟﻤﻌﺎﻟﺠـﺔ واﻟﺘﻌﺎﻣـﻞ ﻣـﻊ اﻷﺧﻄـﺎء‬
‫واﻷﺳﺘﺜﻨﺎءات اﻟﻤﺨﺘﻠﻔﺔ ‪. Exception‬‬

‫اﻟﻤﺜﺎل اﻟﺘﺎﻟﻰ ﻳﻮﺿﺢ ﺷﻜﻞ ﺑﺮﻧﺎﻣﺞ اوﻟﻰ ﻟﻠـ ‪:PL/SQL‬‬ ‫•‬

‫وهﻮ ﻋﻨﺪ ﺗﻨﻔﻴﺬﻩ ﻳﻘﻮم ﺑﺎﻇﻬﺎر رﺳﺎﻟﺔ ﻋﻠﻰ اﻟﺸﺎﺷﺔ‪:‬‬

‫اﻟﻤﺜﺎل اﻟﺘﺎﻟﻰ ﻳﻘﻮم ﺑﻌﺮض رﺳﺎﻟﺔ اﻳﻀﺎ وﻟﻜﻦ ﻣﻊ ﺑﻌﺾ اﻟﺘﻐﻴﻴﺮات‪:‬‬ ‫•‬
 ‫اﻟﻔﺼﻞ اﻷول‪ :‬ﺗﻌﺮﻳﻒ اﻟﻤﺘﻐﻴﺮات‬
‫اﻟﻬﻴﻜﻞ اﻟﺒﻨﺎﺋﻰ ﻟﻜﺘﻠﺔ ‪: PL / SQL‬‬ ‫•‬

‫‪ : PL / SQL‬هﻰ ﻟﻐﺔ هﻴﻜﻠﻴﺔ وﺗﻌﻨﻰ أن اﻟﺒﺮﻧﺎﻣﺞ ﻳﻤﻜﻦ ﺗﻘﺴﻴﻤﻪ اﻟﻰ اﺟﺰاء وآﺘﻞ ﻣﻨﻄﻘﻴﺔ‬
‫وﻳﺘﻜﻮن ﺑﺮﻧﺎﻣﺞ ‪ PL / SQL‬ﻣﻦ وﺣﺪة أو آﺘﻠﺔ )‪ (Block‬وﺗﺤﺘﻮى اﻟﺒﻠﻮك ﻋﻠﻰ ﺛﻼﺛﺔ أﺟﺰاء‪:‬‬
‫ﺟﺰء ﺗﻌﺮﻳﻒ ‪ ) :‬أﺧﺘﻴﺎرى ( وهﻮ ﻳﻀﻢ ﺗﻌﺮﻳﻔﺎت اﻟﻤﺘﻐﻴﺮات ‪ ،‬اﻟﻤﺆﺷﺮات‪ ،‬اﻻﺳﺘﺜﻨﺎءات‬ ‫أ‪-‬‬
‫اﻟﻤﺴﺘﺨﺪﻣﺔ داﺧﻞ اﻟﺒﻠﻮك أو اﻟﻜﺘﻠﺔ ‪.‬‬
‫ﺟﺰء ﺗﻨﻔﻴﺬى ‪ ) :‬أﺳﺎﺳﻰ ( ﻳﺤﺘﻮى ﻋﻠﻰ ﺟﻤﻞ وﻋﺒﺎرات اﻟﻠﻐﺔ ﻟﻤﻌﺎﻟﺠﺔ وﺗﻨﺎول‬ ‫ب‪-‬‬
‫اﻟﺒﻴﺎﻧﺎت ‪.‬‬
‫ﺟﺰء ﻟﻸﺳﺘﺜﻨﺎءات ‪ ) :‬أﺧﺘﻴﺎرى ( ﺗﺤﺪد اﻷﻋﻤﺎل وﻣﺎذا ﺳﻴﺘﻢ أذا ﺣﺪث ﺧﻄﺄ ﻣﺎ أو‬ ‫ﺟـ‪-‬‬
‫اﺳﺘﺜﻨﺎء أﺛﻨﺎء ﺗﻨﻔﻴﺬ اﻟﺒﻠﻮك ‪.‬‬
‫ﺗﻨﻔﻴﺬ ﺟﻤﻞ وﻋﺒﺎرات ‪:PL / SQL‬‬ ‫•‬
‫ﻳﺘﻢ وﺿﻊ ﻋﻼﻣﺔ ) ; ( ﻓﺎﺻﻠﺔ ﻣﻨﻘﻮﻃﺔ ﻓﻰ ﻧﻬﺎﻳﺔ آﻞ ﺟﻤﻠﺔ أو ﻋﺒﺎرة ﻣﻦ ﺟﻤﻞ ﻟﻐﺔ ‪SQL‬‬ ‫‪-‬‬
‫‪PL /‬‬
‫ﻋﻨﺪ ﺗﻨﻔﻴﺬ اﻟﺒﻠﻮك ﺑﺪون اﺧﻄﺎء ﻳﻈﻬﺮ اﻟﺠﻤﻠﺔ اﻟﺘﺎﻟﻴﺔ ﻟﺘﻮﺿﻴﺢ ﺗﻤﺎم وﺻﺤﺔ اﻟﺘﻨﻔﻴﺬ‬ ‫‪-‬‬
‫‪. PL /SQL procedure successfully completed‬‬
‫ﻻﺣﻆ ﻋﺪم وﺟﻮد ﻋﻼﻣﺔ ﻓﺎﺻﻠﺔ ﻣﻨﻘﻮﻃﺔ ﻓﻰ ﻧﻬﺎﻳﺔ اﻟﺠﻤﻞ ‪، Declare‬او‬ ‫‪-‬‬
‫‪،Exception‬او ‪.Begin‬‬
‫ﻻﺣﻆ وﺟﻮد ﻋﻼﻗﺔ ﻓﺎﺻﻠﺔ ﻣﻨﻘﻮﻃﺔ ﻓﻰ ﻧﻬﺎﻳﺔ ﺟﻤﻠﺔ ) ; ‪( END‬‬ ‫‪-‬‬
 ‫ﻳﻤﻜﻦ آﺘﺎﺑﺔ أآﺜﺮ ﻣﻦ ﺟﻤﻠﺔ )ﻋﺒﺎرة( ﻋﻠﻰ ﻧﻔﺲ اﻟﺴﻄﺮ واﻟﻔﺼﻞ ﺑﻴﻨﻬﻢ ﺑﻌﻼﻣﺔ اﻟﻔﺎﺻﻠﺔ‬ ‫‪-‬‬
‫اﻟﻤﻨﻘﻮﻃﺔ ) ; ( وﻟﻜﻦ ﻻ ﻳﺤﺒﺬ ذﻟﻚ ﻟﺠﻌﻞ ﻗﺮاءة اﻟﺒﺮﻧﺎﻣﺞ أﺳﻬﻞ وآﺬﻟﻚ اﻟﺘﻌﺪﻳﻞ ﻓﻴﻪ ‪.‬‬
‫• اﻧﻮاع ﺑﻠﻮآﺎت وآﺘﻞ ﺑﻐﺔ ‪: PL / SQL‬‬
‫ﻻﺣﻆ أن اﻧﻮاع آﺘﻞ ﻟﻐﺔ ‪ PL / SQL‬ﻳﻤﻜﻦ أن ﺗﻜﻮن ﻣﻨﻔﺼﻠﺔ آﻠﻴﺎ أو ﻣﺘﺪاﺧﻠﺔ ﺿﻤﻦ ﺑﻌﻀﻬﺎ‬
‫وﺗﻨﻘﺴﻢ هﺬﻩ اﻟﻜﺘﻞ اﻟﻰ ﻗﺴﻤﻴﻦ وﻳﻄﻠﻖ ﻋﻠﻴﻬﺎ أﺳﻢ ﻋﺎم وهﻮ )‪(Sub programs‬‬
‫‪ -1‬آﺘﻠﺔ ﻣﺠﻬﻮﻟﺔ " ‪: " Anonymous block‬‬
‫وهﻮ ﺑﺮﻧﺎﻣﺞ وﻟﻴﺲ ﻟﻪ أﺳﻢ وﻳﺘﻢ ﺗﻌﺮﻳﻔﻬﺎ ﻋﻨﺪ ﻧﻘﻄﺔ اﻟﺘﻄﺒﻴﻖ وﺗﻨﻔﺬ ﺳﺎﻋﺘﻬﺎ وﻳﺘﻢ أرﺳﺎﻟﻬﺎ اﻟﻰ‬
‫ﻣﻌﺎﻟﺞ أوراآﻞ ﻟﺘﺮﺟﻤﺘﻬﺎ وﺗﻨﻔﻴﺬهﺎ ‪.‬‬
‫‪ "Subprograms " -2‬وﺣﺪات ﺑﺮﻣﺠﻴﺔ ‪:‬‬
‫وهﻰ وﺣﺪات وآﺘﻞ ﻣﻦ اﻟﺒﺮاﻣﺞ ﺗﻘﺒﻞ ﻣﻌﺎﻣﻼت )ﻋﻮاﻣﻞ ( ﻳﻤﻜﻦ أن ﺗﺴﺘﻨﺪ ﻋﻠﻴﻬﺎ ﻓﻰ ﺗﻨﻔﻴﺬ‬
‫اﻟﺒﺮﻧﺎﻣﺞ ‪.‬‬
‫وﺗﻨﻘﺴﻢ هﺬﻩ اﻟﻮﺣﺪات اﻟﻰ اﻧﻮاع أﺧﺮى ﻣﺜﻞ اﻷﺟﺮاء )‪ (Procedure‬داﻟﺔ )‪ ، (Function‬زﻧﺎد‬
‫) ‪............... (Trigger‬‬
‫وهﺬﻩ اﻟﻮﺣﺪات ﻳﺘﻢ ﺣﻔﻈﻬﺎ داﺧﻞ اﻷوراآﻞ وﻳﺘﻢ أﺳﺘﺪﻋﺎءهﺎ ﻋﻨﺪ اﻟﺤﺎﺟﺔ اﻟﻴﻬﺎ ‪.‬‬
‫أﺳﺘﺨﺪام اﻟﻤﺘﻐﻴﺮات ‪-:‬‬ ‫•‬
‫ﻳﻤﻜﻦ أﺳﺘﺨﺪام اﻟﻤﺘﻐﻴﺮات ﻓﻰ ‪:‬‬
‫ﺗﺨﺰﻳﻦ ﻣﺆﻗﺖ ﻟﻠﺒﻴﺎﻧﺎت ‪.‬‬ ‫‪-‬‬
‫اﻟﺘﻌﺎﻣﻞ ﻣﻊ ﻗﻴﻢ ﻣﺨﺰﻧﺔ ‪.‬‬ ‫‪-‬‬
‫أﻋﺎدة أﺳﺘﺨﺪام اﻟﺒﻴﺎﻧﺎت ﻧﺘﻴﺠﺔ ﺗﻐﻴﺮات داﺧﻞ وأﺛﻨﺎء ﺳﻴﺮ اﻟﺒﺮﻧﺎﻣﺞ ‪.‬‬ ‫‪-‬‬
‫ﺳﻬﻮﻟﺔ اﻟﺘﻌﺪﻳﻞ واﻟﺼﻴﺎﻧﺔ وذﻟﻚ ﻣﻦ ﺧﻼل أﺳﺘﺨﺪام ‪ % type ، % Rowtype‬اﻟﺘﻰ‬ ‫‪-‬‬
‫ﺳﻮف ﺗﺸﺮح ﻻﺣﻘﺎ ‪ ،‬وﻣﻦ ﺧﻼﻟﻬﻤﺎ ﻳﻤﻜﻦ ﺗﻌﺮﻳﻒ ﻣﺘﻐﻴﺮ ﺣﺴﺐ ﻧﻮع ﻋﻤﻮد أو ﺻﻒ ﻓﻰ‬
‫ﻗﺎﻋﺪة اﻟﺒﻴﺎﻧﺎت ﻣﻤﺎ ﻳﺘﻴﺢ ﻗﺪر آﺒﻴﺮ ﻣﻦ اﻟﻤﺮوﻧﺔ دون اﻟﺘﻘﻴﺪ ﺑﻨﻮع ﻣﻌﻴﻦ ﻣﻦ اﻟﺒﻴﺎﻧﺎت ‪.‬‬
‫اﻟﺘﻌﺎﻣﻞ ﻣﻊ اﻟﻤﺘﻐﻴﺮات ‪:‬‬ ‫•‬
‫اوﻻ ﻳﺘﻢ ﺗﻌﺮﻳﻒ اﻟﻤﺘﻐﻴﺮات وذﻟﻚ ﻓﻰ اﻟﺠﺰء اﻟﺘﻌﺮﻳﻔﻰ " ‪ "Declare‬وآﺬﻟﻚ ﻳﻤﻜﻦ أن ﻳﺘﻢ‬ ‫‪-‬‬
‫ﻗﻴﻢ أﺑﺘﺪاﺋﻴﺔ ﻟﻬﺬﻩ اﻟﻤﺘﻐﻴﺮات ‪.‬‬
‫ﺗﻌﻴﻴﻦ وأدﺧﺎل ﻗﻴﻢ ﺟﺪﻳﺪة ﻟﻠﻤﺘﻐﻴﺮات ﻓﻰ اﻟﺠﺰء اﻟﺘﻨﻔﻴﺬى ‪.‬‬ ‫‪-‬‬
‫ﻳﻤﻜﻦ أن ﺗﻤﺮر اﻟﻘﻴﻢ ﺑﻴﻦ آﺘﻞ ‪ PL / SQL‬ﻣﻦ ﺧﻼل اﻟﻤﻌﺎﻣﻼت ) ‪(parameters‬‬ ‫‪-‬‬
‫ﻋﺮض اﻟﻨﺘﺎﺋﺞ ﻣﻦ ﺧﻼل اﻟﻤﺘﻐﻴﺮات ‪.‬‬ ‫‪-‬‬

‫أﻧﻮاع اﻟﻤﺘﻐﻴﺮات‬
‫‪Types of variables‬‬
‫ﺗﻨﻘﺴﻢ اﻟﻤﺘﻐﻴﺮات اﻟﻰ ﻧﻮﻋﻴﻦ أﺳﺎﺳﻴﻴﻦ ‪-:‬‬
‫‪ -1‬ﻣﺘﻐﻴﺮات ‪ : PL / SQL‬وﺗﺤﺘﻮى ﻋﻠﻰ ﻋﺪة أﻧﻮاع ﻣﻨﻬﺎ‬
 ‫‪ Scalar -‬اﻟﻤﻔﺮدة‬
‫‪ Composite -‬اﻟﻤﺮآﺒﺔ ) اﻟﻤﻌﻘﺪة (‬
‫‪ Reference -‬اﻟﻤﺸﺎر ﺑﻬﺎ ) ﻋﻨﺎوﻳﻦ (‬
‫‪ "large objects" lob -‬ذات اﻷﺣﺠﺎم اﻟﻜﺒﻴﺮة‬
‫‪ -2‬ﻣﺘﻐﻴﺮات ﻟﻴﺴﺖ ‪ : PL / SQL‬ﻣﺜﻞ ﻣﺘﻐﻴﺮات ‪host ، Bind‬‬
‫أوﻻ اﻟﻤﺘﻐﻴﺮات اﻟﺨﺎﺻﺔ ‪: PL / SQL‬‬
‫اﻟﻤﻔﺮدة ‪ : Scalar‬وﺗﺤﺘﻮى ﻋﻠﻰ ﻗﻴﻢ ﻣﻔﺮدة وﻻ ﻳﻤﻜﻦ أن ﺗﺠﺰأ اﻟﻰ ﻗﻴﻢ ﻣﻔﺮدة أﺻﻐﺮ ﻣﺜﻞ‬ ‫‪-‬‬
‫‪ Boolean ، Data ، Varchar2 ، Number‬ﻓﻬﻰ اﻧﻮع ﻻ ﻳﻤﻜﻦ ان ﻳﺤﺘﻮى اﻟﻤﺘﻐﻴﺮ ﺳﻮى‬
‫ﻋﻠﻰ ﻗﻴﻤﻮ واﺣﺪة آﻤﺎ ﻻ ﻳﻤﻜﻦ ان ﺗﺠﺰأ هﺬﻩ اﻟﻘﻴﻤﺔ ‪.‬‬
‫اﻟﻤﺮآﺒﺔ ) اﻟﻤﻌﻘﺪة اﻟﺘﺮآﻴﺐ( ‪: Composite‬‬ ‫‪-‬‬
‫وﺗﺤﺘﻮى ﻋﻠﻰ ﻣﺠﻤﻮﻋﺔ ﻣﻦ اﻷﺟﺰاء آﻞ ﺟﺰء ذات ﺗﺮآﻴﺐ ﻣﺤﺪد وﻳﻤﻜﻦ أن ﻳﺨﺘﻠﻒ ﻋﻦ ﺟﺰء أﺧﺮ‬
‫وﻳﺘﻢ اﻟﺘﻌﺎﻣﻞ ﻣﻊ آﻞ ﺟﺰء ﻋﻠﻰ ﺣﺪى ﻣﺜﻞ ‪ Record‬ﻓﻬﻮ ﻳﻤﻜﻦ أن ﻳﺤﺘﻮى ﻋﻠﻰ ﺟﺰء ﻣﻦ اﻟﻨﻮع‬
‫‪ Number‬وﺟﺰء أﺧﺮ ﻣﻦ اﻟﻨﻮع ‪ Data‬وهﻜﺬا ‪ ،‬وﺳﻴﺘﻢ ﺷﺮﺣﻬﺎ ﻻﺣﻘﺎ ‪.‬‬
‫اﻟﻤﺸﺎر ﺑﻬﺎ ) ﻋﻨﺎوﻳﻦ (" ‪: " Reference‬‬ ‫‪-‬‬
‫وهﺬﻩ اﻟﻤﺘﻐﻴﺮات ﺗﺤﺘﻮى ﻗﻴﻢ ﺗﺸﻴﺮ اﻟﻰ ﺑﺮاﻣﺞ وﺗﻄﺒﻴﻘﺎت أﺧﺮى وﻟﻴﺴﺖ ﻗﻴﻢ ﺑﺬاﺗﻬﺎ ﻳﻤﻜﻦ‬
‫أﺳﺘﺨﺪاﻣﻬﺎ وهﺬا اﻟﻨﻮع ﻟﻦ ﻳﺘﻢ ﺗﻐﻄﻴﺔ ﻓﻰ هﺬا اﻟﻤﻨﻬﺞ ‪.‬‬
‫ﻣﺘﻐﻴﺮات ذات اﻷﺣﺠﺎم اﻟﻜﺒﻴﺮة " ‪: "Lob‬‬ ‫‪-‬‬
‫وهﻰ ﺗﺤﺘﻮى ﻋﻠﻰ أﻧﻮاع ﻣﻦ اﻟﺒﻴﺎﻧﺎت اﻟﺘﻰ ﺗﺤﺘﺎج اﻟﻰ ﻣﺴﺎﺣﺔ آﺒﻴﺮة ﻣﺜﻞ اﻟﺼﻮر ‪ ،‬اﻟﻔﻴﺪﻳﻮ ‪،‬‬
‫اﻟﻜﺘﺐ ‪ ،‬رﺳﻮﻣﺎت وﺳﻮف ﻳﺘﻢ ﺷﺮﺣﻬﺎ ﻻﺣﻘﺎ ‪.‬‬

‫أدﺧﺎل ﻗﻴﻢ وأﺧﺮاﺟﻬﺎ ﻣﻦ اﻟﻤﺘﻐﻴﺮات ‪:‬‬ ‫•‬

‫‪ -‬ﻟﻐﺔ ‪ PL / SQL‬ﻟﻴﺲ ﻟﺪﻳﻬﺎ ﻗﺪرات وأدوات ﻟﻸدﺧﺎل أو اﻷﺧﺮاج ﺑﺪاﺧﻠﻬﺎ ‪.‬‬
‫‪ -‬ﻟﺬﻟﻚ ﻳﺘﻢ أﺳﺘﺨﺪام ﻣﺘﻐﻴﺮات ﻣﻦ اﻟﻨﻮع ‪ host‬ﻷدﺧﺎل اﻟﻘﻴﻢ داﺧﻞ اﻟﻤﺘﻐﻴﺮات ﻓﻰ زﻣﻦ اﻟﺘﻨﻔﻴﺬ‬
‫) ‪ ( run time‬ﺗﻘﻮم اﻟﻤﺘﻐﻴﺮات ‪ (Bind) host‬ﺑﻤﻬﻤﺔ أدﺧﺎل وأﺧﺮاج اﻟﻘﻴﻢ ‪.‬‬
‫ﺗﻌﺮﻳﻒ اﻟﻤﺘﻐﻴﺮات ﻓﻰ ‪: PL / SQL‬‬
‫اﻟﺼﻴﻐﺔ‬
‫}‪Identifier (Constant) data type (not null) {:=/ default expr‬‬
‫أﻣﺜﻠﺔ‬
‫‪V_ Hiredate‬‬ ‫;‪Date‬‬
‫‪V_deptno‬‬ ‫; ‪number (2) not null := 10‬‬
‫; '‪V_location Varchar2 (15) :='DALLAS‬‬
‫‪C_ comm.‬‬ ‫; ‪Contrast number: = 1600‬‬
 ‫ﺷﺮح اﻟﺼﻴﻐﺔ ‪:‬‬
‫‪ :Identifier‬هﻮ أﺳﻢ اﻟﻤﺘﻐﻴﺮ ﻳﺠﺐ أن ﻳﻠﺘﺰم ﺑﻘﻮاﻋﺪ اﻟﺘﺴﻤﻴﺔ‪.‬‬
‫‪ :Constant‬أن اﻟﻤﺘﻐﻴﺮ اﻟﻤﺮاد ﺗﻌﺮﻳﻔﻪ هﻮ ﺛﺎﺑﺖ ﻻ ﺗﺘﻐﻴﺮ ﻗﻴﻤﺘﻪ اﻟﺘﻰ ﺳﻮف ﻳﺘﻢ ﺑﺪﺋﻪ‬
‫ﺑﻬﺎ‪.‬‬
‫‪ :Data type‬ﻧﻮع ﺑﻴﺎﻧﺎت اﻟﻤﺘﻐﻴﺮ ﺳﻮاء آﺎن ﻣﻔﺮد أو ﻣﻌﻘﺪ او ذات ﺣﺠﻢ آﺒﻴﺮ ‪.‬‬
‫‪ :Not null‬ﻻ ﻳﺴﻤﺢ ﻟﻪ ﺑﺄﺧﺬ ﻗﻴﻤﺔ ‪ Null‬أﺛﻨﺎء واﻟﺘﻨﻔﻴﺬ وﻳﺠﺐ أن ﻳﺒﺪأ ﺑﻘﻴﻤﺔ ﻣﻌﻴﻨﺔ‬
‫ﻋﻠﻰ اﻷﻗﻞ ‪.‬‬
‫‪ :Expr‬وهﻮ ﻗﻴﻤﺔ أﺑﺘﺪاﺋﻴﺔ ﻟﻠﻤﺘﻐﻴﺮ ﺳﻮاء آﺎﻧﺖ ﻗﻴﻤﺔ ﺛﺎﺑﺘﺔ ﻣﺜﻞ '‪ '22-may-oo‬او'‪ 'c‬او ‪5‬‬
‫أو ﻋﻤﻠﻴﺔ ﺣﺴﺎﺑﻴﺔ ﻣﺎ ‪.‬‬
‫ﺧﻄﻮط ﻋﺎﻣﺔ ﻟﺘﺴﻤﻴﺔ اﻟﻤﺘﻐﻴﺮات‬

‫ﻳﺠﺐ أﺗﺒﺎع ﻗﻮاﻋﺪ اﻟﺘﺴﻤﻴﺔ اﻟﺪاﻟﺔ ﻋﻠﻰ ﻣﺤﺘﻮى اﻟﻤﺘﻐﻴﺮ‬ ‫‪-‬‬

‫ﻳﺠﺐ وﺿﻊ ﻗﻴﻢ أﺑﺘﺪاﺋﻴﺔ ﻟﻠﻤﺘﻐﻴﺮات ﺧﺎﺻﺔ ذات ﻃﺒﻴﻌﺔ ‪ not null‬أو ‪ constant‬ﺛﺎﺑﺖ ‪.‬‬ ‫‪-‬‬
‫ﺗﻌﺮﻳﻒ ﻣﺘﻐﻴﺮ واﺣﺪ ﻓﻰ آﻞ ﺳﻄﺮ‬ ‫‪-‬‬
‫أﺳﺘﺨﺪام )=‪ (:‬أو ﺗﻌﺒﻴﺮ )‪ (Default‬ﻟﻮﺿﻊ ﻗﻴﻢ أﺑﺘﺪاﺋﻴﺔ داﺧﻞ اﻟﻤﺘﻐﻴﺮات ‪.‬‬ ‫‪-‬‬
‫أﻣﺜﻠﺔ ﻟﺘﻌﺮﻳﺒﻒ وأﺳﺘﺨﺪام اﻟﻤﺘﻐﻴﺮات ‪:‬‬
‫ﻣﺜﺎل ‪:1‬‬
‫‪Declare‬‬
‫;‪V_hiredate Date‬‬
‫‪Begin‬‬
‫;'‪V_hiredate:= '15-may – 1999‬‬
‫;‪End‬‬

‫ﻣﺜﺎل ‪2‬‬
‫‪Declare‬‬
‫;‪V_mgr number (4) Default 100‬‬
‫‪Begin‬‬
‫;‪V_mgr := 120‬‬
‫;‪End‬‬

‫ﻣﺜﺎل ‪3‬‬
‫‪Declare‬‬
‫)‪V_city varchar2 (30‬‬ ‫;'‪not null :='oxford‬‬
‫‪Begin‬‬
‫;'‪V_City := 'Dallas‬‬
 ‫;‪End‬‬
‫ﻣﺜﺎل ‪ -1‬ﻳﺘﻢ ﻓﻴﻪ ﺗﻌﺮﻳﻒ ﻣﺘﻐﻴﺮ أﺳﻤﻪ ) ‪ (V_hiredate‬ﻣﻦ اﻟﻨﻮع ﺗﺎرﻳﺦ )‪ (Date‬وذﻟﻚ اﻟﺠﺰء‬
‫)‪-15‬ﻣﺎﻳﻮ‬ ‫اﻟﺘﻌﺮﻳﻔﻰ ‪ ،‬وﻳﺘﻢ وﺿﻊ ﻗﻴﻤﺔ داﺧﻠﻪ ﻓﻰ اﻟﺠﺰء اﻟﺘﻨﻔﻴﺬى وهﺬﻩ اﻟﻘﻴﻤﺔ هﻰ ﺗﺎرﻳﺦ‬
‫‪. (1999‬‬
‫ﻣﺜﺎل ‪ :2‬ﻳﺘﻢ ﺗﻌﺮﻳﻒ ﻣﺘﻐﻴﺮ ﻣﻦ اﻟﻨﻮع اﻟﺮﻗﻤﻰ )اﻟﻌﺪدى ( ﻣﺴﺎﺣﺘﻪ أرﺑﻊ ﺧﺎﻧﺎت وذات ﻗﻴﻤﺔ‬
‫أﺗﻮﻣﺎﺗﻴﻜﻴﺔ هﻰ)‪ (100‬وذﻟﻚ ﻓﻰ اﻟﺠﺰء اﻟﺘﻌﺮﻳﻔﻰ ‪.‬‬
‫وﻓﻰ اﻟﺠﺰء اﻟﺘﻨﻔﻴﺬى ﻳﺘﻢ وﺿﻊ ﻗﻴﻤﺔ داﺧﻠﻪ )‪(120‬‬
‫ﻣﺜﺎل ‪ : 3‬ﻓﻰ اﻟﺠﺰء اﻟﺘﻌﺮﻳﻔﻰ ‪:‬‬
‫ﺗﻌﺮﻳﻒ ﻣﺘﻐﻴﺮ )‪ (V-city‬ﻣﻦ اﻟﻨﻮع اﻟﺤﺮﻓﻰ ﺳﻌﺘﻪ ‪ 30‬ﺣﺮف ﻣﻦ اﻟﻨﻮع )‪ ( not null‬ﻻ ﻳﺄﺧﺬ ﻗﻴﻢ‬
‫ﻓﺎرﻏﺔ ذات ﻗﻴﻤﺔ أﺑﺘﺪاﺋﻴﺔ )‪ (oxford‬ﻓﻰ اﻟﺠﺰء اﻟﺘﻨﻔﻴﺬى ‪:‬‬
‫ﻳﺘﻢ وﺿﻊ ﻗﻴﻤﺔ )'‪ ('Dallas‬ﻓﻰ هﺬا اﻟﻤﺘﻐﻴﺮ ‪.‬‬
‫اﻷﻧﻮاع اﻟﻤﻔﺮدة ﻟﻠﻤﺘﻐﻴﺮات ‪:‬‬
‫ﺗﺤﺠﺰ ﻗﻴﻤﺔ ﻣﻔﺮدة ‪.‬‬ ‫‪-‬‬
‫ﻻ ﺗﺤﺘﻮى ﻋﻠﻰ أﺟﺰاء داﺧﻠﻴﺔ أو ﺗﺮاآﻴﺐ ‪.‬‬ ‫‪-‬‬
‫أﻣﺜﻠﺔ ﻋﻠﻰ اﻻﻧﻮاع اﻟﻤﻔﺮدة ‪:‬‬
‫)‪ : Char (length‬ﻣﺘﻐﻴﺮ ﺣﺮﻓﻰ ﺛﺎﺑﺖ اﻟﺴﻌﺔ ﺳﻮاء ﺗﻢ ﻣﻼءهﺎ أو ﺗﺮآﺖ ﻓﺎرﻏﺔ وهﺬا اﻟﻨﻮع ﻣﻀﺮ‬
‫ﻓﻰ اﻟﻤﺴﺎﺣﺔ ﻟﻜﻨﻪ أﺳﺮع ﻓﻰ اﻟﺘﻌﺎﻣﻞ ‪.‬‬
‫) ‪ :Varchar2 (length‬ﻣﺘﻐﻴﺮ ﺣﺮﻓﻰ ذات ﺳﻌﺔ ﻣﻌﻴﻨﺔ ﻟﻜﻦ هﺬﻩ اﻟﺴﻌﺔ ﻣﺘﻐﻴﺮة ﺑﺤﺪ أﻗﺼﻰ وﻳﺘﻢ‬
‫ﻣﻼء اﻟﻤﺘﻐﻴﺮ ﺑﺴﻌﺔ اﻟﻨﺺ ﻓﻘﻂ ﺑﺤﺪ أﻗﺼﻰ ﺳﻌﺔ هﺬا اﻟﻤﺘﻐﻴﺮ ﻓﻤﺜﻼ‬
‫ﻣﺘﻐﻴﺮ ﺣﺮﻓﻰ ذات ﺳﻌﺔ ‪ 30‬ﺣﺮف وﻟﻢ ﻳﻮﺿﻊ ﺳﻮى ‪ 6‬ﺣﺮوف‬
‫ﻳﻤﻸ ﺑﺎﻟﺤﺮوف اﻟﺴﺘﺔ وﻳﺘﻢ ﺗﻮﻓﻴﺮ اﻟﺒﺎﻗﻰ وهﺬا اﻟﻨﻮع ﻣﻔﻴﺪ ﻓﻰ‬
‫اﻟﻤﺴﺎﺣﺔ ﻟﻜﻦ اﺑﻄﺊ ﻣﻦ اﻟﻨﻮع اﻟﺴﺎﺑﻖ )‪. (Char‬‬
‫‪ :Long‬هﻮ اﻟﻨﻮع اﻻﺳﺎﺳﻰ ﻟﻠﺒﻴﺎﻧﺎت اﻟﻨﺼﻴﺔ ذات ﺳﻌﺔ ﺑﺤﺪ أﻗﺼﻰ ‪ 32760‬ﺑﺎﻳﺖ أو ‪312‬‬
‫ﺣﺮف ‪.‬‬
‫‪ : Long row‬وهﻮ ﻣﺜﻞ ‪ long‬ﻟﻜﻨﻪ ﻻ ﻳﺘﻢ اﻟﺘﻌﺎﻣﻞ ﺑﻪ وﻻ ﻳﻔﻬﻤﻪ ‪. PL / SQL‬‬

‫)‪ : Number (p,s‬وهﻮ ﻣﺘﻐﻴﺮ رﻗﻤﻰ ﻳﺄﺧﺬ ﻧﻄﺎق ﻣﻦ ﺧﺎﻧﺎت واﺣﺪة اﻟﻰ ‪ 38‬ﺧﺎﻧﺔ وآﺬﻟﻚ ﻣﻦ آﺴﺮ‬
‫ﻋﺸﺮى ﻣﻦ ‪ 84-‬اﻟﻰ ‪127‬‬
‫‪ :‬ﻋﺪد ﺧﺎﻧﺎت اﻟﺮﻗﻢ ﻋﺎﻣﺔ ﺑﻤﺎ ﻓﻴﻬﺎ ﻣﻦ آﺴﺮ ﻋﺸﺮى ‪.‬‬ ‫‪P‬‬
‫‪ :‬ﻋﺪد ﺧﺎﻧﺎت اﻟﻜﺴﺮ اﻟﻌﺸﺮى ﻓﻘﻂ‪.‬‬ ‫‪S‬‬
‫ﺗﺎﺑﻊ أﻧﻮاع اﻟﻤﻔﺮدة ﻟﻠﻤﺘﻐﻴﺮات ‪:‬‬
‫‪ : binary_integer -‬وهﻮ اﻟﻨﻮع اﻟﺮﻗﻤﻰ اﻟﺼﺤﻴﺢ )ﻻﻳﺄﺧﺬ آﺴﻮر( وﻳﺄﺧﺬ ﻗﻴﻢ ﺧﻼل ‪. 2147483±‬‬
‫‪ : Pls_integer -‬وهﻮ ﻣﺜﻞ اﻟﻨﻮع اﻟﺴﺎﺑﻖ ﻟﻜﻨﻪ أﺳﺮع وﻳﺄﺧﺬ ﻣﺴﺎﺣﺔ أﻗﻞ ‪.‬‬
 ‫‪ : Boolean -‬وهﻮ ﻧﻮع ﻳﻤﻜﻦ أن ﻳﺄﺧﺬ ﺛﻼث ﻗﻴﻢ ﻓﻘﻂ هﻰ )‪( true ، false ، null‬‬
‫وﻳﺴﺘﺨﺪم ﻓﻰ ﺣﺎﻻت اﻟﺸﺮوط واﻟﻤﻘﺎرﻧﺎت اﻟﻤﻨﻄﻘﻴﺔ ﻓﻘﻂ ‪.‬‬
‫‪ : Data -‬ﻧﻮع اﻟﻤﺘﻐﻴﺮات اﻟﺘﺎرﻳﺨﻴﺔ )اﻟﻮﻗﺖ ( ﻳﺤﺘﻮى ﻋﻠﻰ ﺑﻴﺎﻧﺎت ﺗﺎرﻳﺦ أو وﻗﺖ أو زﻣﻦ‬
‫وهﻮ ﻳﺒﺪأ ﻣﻦ ‪ 4712‬ﻗﺒﻞ اﻟﻤﻴﻼد اﻟﻰ ‪ 9999‬ﻣﻴﻼدﻳﺔ ‪.‬‬
‫أﻣﺜﻠﺔ أﺧﺮى ﻋﻠﻰ ﺗﻌﺮﻳﻒ اﻟﻤﺘﻐﻴﺮات ‪:‬‬
‫‪Declare‬‬
‫;)‪v_job varchar2 (15‬‬ ‫ﻣﺘﻐﻴﺮ ﺣﺮﻓﻰ ﺳﻌﺔ ‪ 15‬ﺣﺮف‬
‫‪v_count‬‬ ‫;‪binary-integer:=o‬‬ ‫ﻣﺘﻐﻴﺮ رﻗﻤﻰ ﺻﺤﻴﺢ ﻳﺄﺧﺬ ﻗﻴﻤﺔ أﺑﺘﺪاﺋﻴﺔ ﺻﻔﺮ‬
‫‪v_total_sal‬‬ ‫ﻣﺘﻐﻴﺮ رﻗﻤﻰ ﻣﻦ ﺳﺒﻊ ﺧﺎﻧﺎت ﻣﻨﻬﻢ أﺛﻨﺎن آﺴﺮ ﻋﺸﺮى وﻳﺒﺪأ ﺑﺼﻔﺮ ‪number‬‬
‫=‪v_order_date date:‬‬ ‫;‪(7.2):= o‬ﻣﺘﻐﻴﺮ زﻣﻨﻰ ﻳﺒﺪأ ﻓﻰ اﻷﺳﺒﻮع اﻟﻘﺎدم‬
‫;‪sysdate +7‬‬
‫ﻣﺘﻐﻴﺮ ﺛﺎﺑﺖ رﻗﻤﻰ ﻣﻜﻮن ﻣﻦ أرﺑﻊ ﺧﺎﻧﺎت ﻣﻨﻬﻢ ﺧﺎﻧﺘﺎن وﻗﻴﻤﺘﻪ ‪17.25‬‬
‫;‪C-TAX-RATIO CONSTANT NUMBER (4.2):=17.25‬‬
‫" ‪ "boolean‬ﻻ ﻳﺄﺧﺬ ﻓﺎرغ "‪ "null‬وﻳﺒﺪأ ﺑﻘﻴﻤﺔ ‪true‬‬ ‫ﻣﺘﻐﻴﺮ ﻣﻨﻄﻘﻰ‬
‫‪V_Flag‬‬ ‫;‪Boolean Not Null :=True‬‬
 ‫اﻟﺨﺎﺻﻴﺔ ‪: %type‬‬
‫ﻳﻤﻜﻦ ﺗﻌﺮﻳﻒ ﻣﺘﻐﻴﺮ ﻋﻠﻰ أﺳﺎس ﺗﻌﺮﻳﻒ ﻋﻤﻮد ﻓﻰ ﺟﺪول ﺑﻘﺎﻋﺪة اﻟﺒﻴﺎﻧﺎت او ﻧﻔﺲ ﺗﻌﺮﻳﻒ ﻣﺘﻐﻴﺮ‬
‫ﺳﺒﻖ ﺗﻌﺮﻳﻔﻪ ‪ .‬ﻓﺎﻟﻤﺘﻐﻴﺮ اﻟﺠﺪﻳﺪ هﻨﺎ ﻧﻔﺲ ﻧﻮع اﻟﺒﻴﺎﻧـﺎت "‪ "data type‬ﻟﻠﻤﺘﻐﻴـﺮ اﻟﻘـﺪﻳﻢ دون أﺧـﺬ‬
‫ﻣﺎ ﺑﻪ ﻣﻦ ﻗﻴﻤﺔ وهﺬﻩ اﻟﺨﺎﺻﻴﺔ ﺗﺘﻴﺢ ﻗﺪر آﺒﻴـﺮ ﻣـﻦ اﻟﻤﺮوﻧـﺔ ﻓـﻰ ﺗﻌﺮﻳـﻒ اﻟﻤﺘﻐﻴـﺮات ﻷن ﺗﻌﺮﻳـﻒ‬
‫ﻣﺘﻐﻴﺮ رﻗﻤﻰ ﻣﺜﻼ وﻳﺄﺧـﺬ اﻟـﺮﻗﻢ اﻟﺘﻌﺮﻳﻔـﻰ "‪ "praimary key‬ﻟﺒﻴـﺎن ﻣـﺎ ) ﻣﻮﻇـﻒ ﻣـﺜﻼ ( واذا ﻣـﺎ‬
‫دﻋﺖ اﻟﺤﺎﺟﺔ ﻟﺘﻐﻴﻴﺮ ﻧﻮع اﻟﺒﻴﺎﻧﺎت ﻓﻰ اﻟﺠﺪول ﻣﻦ رﻗﻤـﻰ اﻟـﻰ ﺣﺮﻓـﻰ ﻓﺄﻧـﻪ ﺳـﻮف ﻳـﺆدى اﻟـﻰ‬
‫ﺗﻌﻄﻞ اﻟﺒﺮﻧﺎﻣﺞ اﻟﻤﺒﻨﻰ ﻋﻠﻰ اﺳﺎس اﻧﻪ هﻮ ﻣﺘﻐﻴﺮ )ﻋﻤﻮد( ﺣﺮﻓﻰ ﻟﺬﻟﻚ ﻋﻠﻰ اﺳﺎس اﻧﻪ ﻣﺘﻐﻴﺮ‬
‫)ﻋﻤﻮد ( ﺣﺮﻓﻰ ﻟﺬﻟﻚ ﻧﺴﺘﺨﺮج ﺧﺎﺻﻴﺔ ‪ % type‬ﻟﺘﻼﻗﻰ هﺬﻩ اﻟﻤﺸﻜﻠﺔ ‪.‬‬
‫ﻣﺜﺎل‬
‫‪Dedare‬‬
‫‪V_name‬‬ ‫; ‪emp. Ename % type‬‬
‫; ‪V_id emp. Emp no % type‬‬
‫‪V_sal‬‬ ‫; ‪emp, sal % type := 1200‬‬
‫اﻟﺼﻴﻐﺔ اﻟﻌﺎﻣﺔ ‪Ideutifier table,cdumn_name% type :‬‬
‫أﺳﺘﺨﺪام اﻟﻤﺘﻐﻴﺮات ‪host , Bind‬‬
‫ﺗﻌﺮﻳﻒ هﺬا اﻟﻨﻮع ﻳﻜﻮن ﺧﺎرج آﺘﻞ ‪ PL / SQL‬آﻤﺎ ﻳﺄﺗﻰ ‪:‬‬

‫‪Variable g_sal number‬‬ ‫ﻻﺣﻆ ﻋﺪم وﺟ ﻮد ﻋﻼﻣ ﺔ );( ﻓﺎﺻ ﻠﺔ ﻣﻨﻘﻮﻃ ﺔ ﻓ ﻰ‬

‫‪Begin‬‬ ‫أﺧ ﺮ ﺟﻤﻠ ﺔ ﺗﻌﺮﻳ ﻒ اﻟﻤﺘﻐﻴ ﺮ )‪ (gsal‬ﻷﻧﻬ ﺎ ﻟﻴ ﺴﺖ‬
‫; ‪:g_sal := 1200‬‬ ‫ﺟﻤﻠﺔ ‪. pl/sql‬‬
‫; ‪end‬‬ ‫ﻋﻨ ﺪ أﺳ ﺘﺨﺪام ه ﺬا اﻟﻨ ﻮع ﻧ ﻀﻊ أﻣ ﺎم اﻟﻤﺘﻐﻴ ﺮ )‪(:‬‬
‫‪/‬‬ ‫وذﻟﻚ داﺧﻞ آﻮد ‪. PL / SQL‬‬
‫; ‪print g_sal‬‬ ‫ﻳ ﺘﻢ ﻃﺒ ﻊ واﻇﻬ ﺎر ﻗ ﻴﻢ ه ﺬﻩ اﻟﻤﺘﻐﻴ ﺮات ﻣ ﻦ‬
‫ﺧ ﺎرج ‪ PL / SQL‬وذﻟ ﻚ ﻣ ﻦ ﺧ ﻼل‬
‫ﺟﻤﻠﺔ ‪. print‬‬
 ‫أﺳﺘﺨﺪام ‪DBMS_output . put_line :‬‬
‫‪ -‬وهﻰ داﻟﺔ داﺧﻠﻴﺔ ﻓﻰ اﻷوراآﻞ اﻟﻐﺮض ﻣﻨﻬﻤﺎ أﻇﻬﺎر ﻗﻴﻢ وﻧﺼﻮص وﻋﺮض اﻟﺒﻴﺎﻧـﺎت داﺧـﻞ‬
‫ﺑﻠﻮآﺎت وآﺘﻞ ‪. PL / SQL‬‬
‫‪ -‬ﻳﺠﺐ أن ﻳﻜﻮن أﺧﺘﻴﺎر ) ‪ ( set server out put on‬ﻟﻌﺮض وﻣﺎ ﺳﺘﻌﺮﺿﻪ هﺬﻩ اﻟﺪاﻟﺔ ‪.‬‬
‫ﻣﺜﺎل‪:‬‬
 ‫اﻟﻔﺼﻞ اﻟﺜﺎﻧﻰ‬
‫آﺘﺎﺑﺔ ﺟﻤﻞ ‪PL / SQL‬‬
‫‪ -‬ﻓﻰ ﻧﻬﺎﻳﺔ آﻞ ﺑﻠﻮك ﻓﻰ ﻟﻐﺔ ‪ PL / SQL‬ﻳﺠﺐ وﺿﻊ ﻋﻼﻣﺔ )‪ "salash" (/‬ﻟﺘﻨﻔﻴﺬ‬
‫ﻣﺎ ﺳﺒﻘﻬﺎ ﻣﻦ آﺘﻞ )اﻟﺒﻠﻮآﺎت ( ‪. PL / SQL‬‬
‫ﺻﻴﻎ اﻟﻤﻼﺣﻈﺎت وﺟﻌﻞ اﻟﻜﻮد ﻻ ﻳﺄﺧﺬ ﺑﻪ ﻣﻦ ﻗﺒﻞ اﻟﻤﺘﺮﺟﻢ ‪:‬‬
‫‪ -1‬ﻟﺠﻌﻞ ﺳﻄﺮ ﻣﺎ ﺗﻌﻠﻴﻖ )ﻣﻼﺣﻈﺔ( ﻧﻀﻊ ﻓﻰ أول اﻟﺴﻄﺮ ﻋﻼﻣﺘﻴﻦ )‪ "dash" (- -‬أو‬
‫ﻧﺎﻗﺺ أو آﺘﺎﺑﺔ ﻓﻰ أول اﻟﺴﻄﺮ آﻠﻤﺔ )‪. (rem‬‬
‫‪ -2‬ﻟﺠﻌﻞ أآﺜﺮ ﻣﻦ ﺳﻄﺮ ﺗﻌﻠﻴﻖ أو ﻣﻼﺣﻈﺔ ﻧﺴﺘﺨﺪم ﻋﻼﻣﺎت ﻓﻰ اﻟﺒﺪاﻳﺔ )*‪ (/‬وﻋﻼﻣﺔ‬
‫)‪ (*/‬ﻓﻰ ﻧﻬﺎﻳﺔ اﻟﺘﻌﻠﻴﻖ او اﻟﻤﻼﺣﻈﺔ ‪.‬‬
‫ﻣﺜﺎل ‪:‬‬

‫وﺗﺴﺘﺨﺪم هﺬﻩ اﻟﻤﻼﺣﻈﺎت ﻟﻌﻤﻞ ﻣﻼﺣﻈﺎت ﺗﻌﻴﻴﻦ اﻟﻤﺒﺮﻣﺞ ﻋﻠﻰ ﻓﻬﻢ اﻟﺒﺮﻧﺎﻣﺞ وآﻴﻔﻴﺔ‬
‫ﻋﻤﻠﻪ وذﻟﻚ ﻣﻦ اﻷﻣﻮر اﻟﻤﻌﺮوﻓﺔ ‪.‬‬
‫اﻟﺪول اﻟﻌﺎﻣﻠﺔ داﺧﻞ ﻟﻐﺔ ‪PL / SQL‬‬ ‫•‬
‫آﻞ اﻟﺪوال " ‪ "single row function‬ﻓﻰ ﻟﻐﺔ ‪ SQL‬أﻳﻀﺎ هﻨﺎ ﻣﺎ ﻋﺪا داﻟﺔ " ‪"decode‬‬ ‫‪-‬‬
‫وﺑﻌﺾ اﻟﺪوال اﻷﺧﺮى‬
‫ﻣﺜﺎل‪:‬‬ ‫‪-‬‬

‫اﻟﻜﺘﻞ واﻟﺒﻠﻮآﺎت اﻟﻤﺘﺪاﺧﻠﺔ ﻧﻄﺎق ﻋﻤﻞ اﻟﻤﺘﻐﻴﺮات ‪:‬‬

‫‪ -‬ﻳﻤﻜﻦ داﺧﻞ ‪ PL / SQL‬ﺗﺪاﺧﻞ أآﺜﺮ ﻣﻦ ﺑﻠﻮك ) آﺘﻠﺔ ( ﻣﻊ ﺑﻌﻀﻬﻢ اﻟﺒﻌﺾ ‪.‬‬
‫‪ -‬ﻧﻄﺎق ﻋﻤﻞ اﻟﻤﺘﻐﻴﺮات داﺧﻞ اﻟﺒﻠﻮآﺎت آﺎﻷﺗﻰ ‪:‬‬
‫ﻓﻰ اﻟﺸﻜﻞ اﻟﻤﺘﻐﻴﺮ )‪ (x‬ﻳﺘﻢ اﻟﺘﻌﺎﻣﻞ ﻣﻌﻪ ﻓﻰ اﻟﺒﻠﻮك اﻟﺨﺎرﺟﻰ واﻟﺪاﺧﻠﻰ أﻣﺎ اﻟﻤﺘﻐﻴﺮ )‪ (y‬ﻧﻄﺎق‬
‫ﻋﻤﻠﻪ ﻓﻘﻂ ﻓىﺎ اﻟﺒﻠﻮك اﻟﺪاﺧﻠﻰ ‪.‬‬
‫وﻣﻦ ذﻟﻚ ﻳﺘﻀﺢ أن – اﻟﺒﻠﻮك ﻳﺮى اﻟﺒﻠﻮآﺎت اﻟﺘﻰ ﺗﺤﺘﻮﻳﻪ ﻓﻘﻂ ‪.‬‬ ‫‪-‬‬
‫اﻟﺒﻠﻮآﺎت اﻟﺘﻰ داﺧﻞ هﺬا اﻟﺒﻠﻮك اﻟﺨﺎرﺟﻰ ﻟﻬﺎ ﻻ ﻳﺴﺘﻄﻴﻊ اﻟﺘﻌﺎﻣﻞ ﻣﻌﻬﺎ هﺬا اﻟﺒﻠﻮك‬ ‫‪-‬‬
‫اﻟﺨﺎرﺟﻰ ‪.‬‬

‫وﺿﻊ ﺗﺴﻤﻴﺔ اﻟﺒﻠﻮآﺎت‬

‫ﻳﻤﻜﻦ ﺗﺴﻤﻴﺔ اﻟﺒﻠﻮك وأﺳﺘﺨﺪام هﺬﻩ اﻟﺘﺴﻤﻴﺔ اذا ﺣﺪث أن اﻟﻤﺘﻐﻴﺮات آﺎﻧﺖ ﺑﻨﻔﺲ اﻷﺳﻤﺎء‬
‫داﺧﻞ ﺑﻠﻮآﺎت ﻣﺘﻌﺪدة – وآﺬﻟﻚ ﻷﻋﻄﺎء ﻣﺰﻳﺪ ﻣﻦ اﻟﺘﻮﺿﻴﺢ ﻟﻠﻜﻮد ﻟﻤﻌﺮﻓﺔ آﻞ ﺑﻠﻮك ﺑﺄﺳﻢ ﻣﻌﻴﻦ‬
‫ﻳﺴﺎﻋﺪ ﻋﻠﻰ اﻟﻔﻬﻢ واﻷﺳﺘﺪﻻل ‪.‬‬
 ‫ﻣﺜﺎل ‪:‬‬

‫ﻓﻰ اﻟﻤﻮﺿﻮع ‪ -1‬ﻳﺘﻢ أدﺧﺎل ﻗﻴﻤﺔ اﻟﻤﻌﺎدﻟﺔ ﻓﻰ ‪ v_com‬اﻟﺨﺎرﺟﻰ‬

‫ﻓﻰ اﻟﻤﻮﺿﻊ ‪ -2‬ﻳﺘﻢ وﺿﻊ ﻗﻴﻤﺔ ﺟﺪﻳﺪة ‪ v_message‬وهﺬا اﻟﻤﺘﻐﻴﺮ ﻓﻰ اﻟﺒﻠﻮك )‪ (outer‬اﻟﻌﻤﻠﻴﺎت‬
‫‪.‬‬
‫وﺿﻊ اﻟﻌﻤﻠﻴﺎت اﻟﺤﺴﺎﺳﻴﺔ واﻟﻤﻨﻄﻘﻴﺔ ﻓﻰ ‪: PL / SQL‬‬ ‫•‬
‫ﻣﺜﻞ ‪ SQL‬ﺗﻤﺎﻣﺎ ﺑﻨﻔﺲ اﻟﻔﻜﺮ واﻟﺘﺮﺗﻴﺐ ‪.‬‬
‫أﻣﺜﻠﺔ ‪:‬‬
‫‪v:=v+1‬‬ ‫;‬ ‫‪ -1‬ﻟﻌﻤﻞ ﻋﺪاد رﻗﻤﻰ‬
‫) ‪v_flag := ( v1 = v2‬‬ ‫;‬ ‫‪ - 2‬ﻟﻌﻤﻞ ﻣﺆﺷﺮ ﻣﻨﻄﻘﻰ‬
‫ﻓﻰ اﻟﻤﺜﺎل ‪ : 2‬ﻣﻌﻨﺎﻩ اذا آﺎﻧﺖ ‪ V1‬ﻳﺴﺎوى ‪ V2‬ﻓﺄن اﻟﻤﺘﻐﻴﺮ ‪ v_flag‬ﻗﻴﻤﺔ ‪ true‬ﻷﻧﻪ ﻣﻦ ﻧﻮع‬
‫ﻷﻧﻪ ﻣﻦ ﻧﻮع ‪ Boolean‬واذا ﻟﻢ ﻳﺘﺴﺎوى ‪ ، v1‬ﻳﺴﺎوى ‪ v2‬ﻓﺎن اﻟﻤﺘﻐﻴﺮ ‪ v_flag‬ﻳﺄﺧﺬ ‪False‬‬
‫وﻳﺄﺧﺬ ‪ v_flag‬واذا آﺎن أﺣﺪهﻤﺎ ‪ null‬ﻳﺄﺧﺬ اﻟﻘﻴﻤﺔ ‪. null‬‬
 ‫اﻟﻔﺼﻞ اﻟﺜﺎﻟﺚ‬
‫ﺗﻔﺎﻋﻞ أورآﺎل آﻘﺎﻋﺪة ﺑﻴﺎﻧﺎت ﻣﻊ ﻟﻐﺔ ‪PL / SQL‬‬
‫ﺟﻤﻞ ‪ SQL‬ﻓﻰ ﻟﻐﺔ ‪: PL / SQL‬‬
‫أﺣﻀﺎر ﺑﻴﺎﻧﺎت ﻣﻦ ﻗﺎﻋﺪة اﻟﺒﻴﺎﻧﺎت ﺑﺄﺳﺘﺨﺪام أﻣﺮ )‪(select‬‬
‫ﻋﻤﻞ أﺿﺎﻓﺎت وﺗﻐﻴﺮات ﻟﺼﻔﻮف ﻓﻰ ﻗﺎﻋﺪة اﻟﺒﻴﺎﻧﺎت ﺑﺄﺳﺘﺨﺪام أواﻣﺮ ‪DML‬‬ ‫‪-‬‬
‫أﺳﺘﺨﺪام أواﻣﺮ اﻟﺘﺤﻜﻢ ﻓﻰ اﻟﺘﻔﺎﻋﻞ ﻣﻊ ﻗﺎﻋﺪة اﻟﺒﻴﺎﻧﺎت )‪control transaction‬‬ ‫‪-‬‬
‫‪ (commands‬ﻣﺜﻞ ‪. save point ، rollback ، Commit‬‬
‫أدراج ﻣﺨﺮﺟﺎت ﻋﻤﻠﻴﺎت ‪ DML‬ﺑﺄﺳﺘﺨﺪام ﺻﻔﺎت ) ‪ (implicit cursor‬اﻟﻤﺆﺷﺮات اﻟﻀﻤﻨﻴﺔ ‪.‬‬ ‫‪-‬‬
‫ﺟﻤﻠﺔ ‪ select‬ﻓﻰ ﻟﻐﺔ ‪: PL / SQL‬‬ ‫•‬
‫‪Select name,…….‬‬ ‫اﻟﺼﻴﻐﺔ اﻟﻌﺎﻣﺔ ‪-:‬‬
‫)‪Into (variable_name / record_name‬‬
‫‪From‬‬ ‫‪table‬‬
‫]‪[Where condition‬‬
‫ﻣﻦ اﻟﻤﻼﺣﻆ ﻣﻦ اﻟﺼﻴﻐﺔ اﻟﻌﺎﻣﺔ ﻻ ﻳﻮﺟﺪ أى ﺗﻐﻴﻴﺮ ﻋﻠﻰ ﺟﻤﻠﺔ ‪ select‬ﻓﻰ ﻟﻐﺔ ‪ PL/SQL‬ﺳﻮى‬
‫أﺿﺎﻓﺔ ﺟﻤﻠﺔ )‪ (into‬وﺑﻌﺪهﺎ أﺳﻤﺎء اﻟﻤﺘﻐﻴﺮات أو )‪ (record‬اﻟﺬى ﺳﻮف ﻳﺴﺘﻘﺒﻞ ﻗﻴﻢ ﺟﻤﻠﺔ‬
‫‪select‬‬
‫وﺗﻮﺿﻊ ﺟﻤﻠﺔ ) ‪ (into‬ﺑﻌﺪ ﺳﺮد أﻋﻤﺪة ‪ select‬وﻗﺒﻞ آﻠﻤﺔ ‪ from‬وﻓﻰ أﺧﺮ ﺟﻤﻠﺔ ‪ select‬ﺗﻮﺿﻊ‬
‫اﻟﻔﺎﺻﻠﺔ اﻟﻤﻨﻘﻮﻃﺔ ) ; ( دﻻﻟﺔ ﻋﻠﻰ ﻧﻬﺎﻳﺔ اﻟﺠﻤﻠﺔ وﻟﻴﺲ داﺧﻠﻬﺎ ‪.‬‬
‫ﻻﺣﻆ ان ﺟﻤﻠﺔ )‪ (where‬أﺧﺘﻴﺎرﻳﺔ ﻟﻴﺴﺖ أﺳﺎﺳﻴﺔ ‪.‬‬ ‫‪-‬‬
‫ﻻﺣﻆ ان ﻋﺪد وﻧﻮع ﺑﻴﺎﻧﺎت اﻟﻤﺘﻐﻴﺮات ﻓﻰ ‪ into‬ﻣﺘﻮاﻓﻖ ﻣﻊ ﻋﺪد وﻧﻮع اﻟﺒﻴﺎﻧﺎت اﻟﻤﺨﺘﺎرة ﺑﻌﺪ‬ ‫‪-‬‬
‫آﻠﻤﺔ ‪select‬‬
‫ﻣﻠﺤﻮﻇﺔ أﺳﺎﺳﻴﺔ ‪ :‬ﻳﺠﺐ ان ﺗﺮﺟﻊ ‪ select‬ﺑﻘﻴﻤﺔ واﺣﺪة أو ﺻﻒ واﺣﺪ ﻓﻘﻂ وذﻟﻚ ﻟﻮﺿﻌﻬﺎ داﺧﻞ‬
‫اﻟﻤﺘﻐﻴﺮات ‪.‬‬

‫ﺗﺎﺑﻊ ‪ :‬ﺟﻤﻠﺔ ‪ select‬ﻓﻰ ﻟﻐﺔ ‪PL / SQL‬‬

 ‫ﻓﻰ اﻟﻤﺜﺎل اﻟﺴﺎﺑﻖ ﻳﺘﻢ ﺗﻌﺮﻳﻒ ﻣﺘﻐﻴﺮا اﺳﻤﻪ ‪ v_deptno‬وﻧﻮﻋﻪ رﻗﻤﻰ ﺳﻌﺘﻪ أرﺑﻌﺔ ﺣﺮوف‬
‫وﻣﺘﻐﻴﺮ أﺳﻤﻪ ‪ v_location_id‬وﻧﻮﻋﻪ رﻗﻤﻰ ﺳﻌﺘﻪ أرﺑﻌﺔ ﺣﺮوف ‪.‬‬
‫ﺛﻢ اﻟﺠﺰء اﻟﺘﻨﻔﻴﺬى ‪:‬‬
‫ﺑﻪ ﺟﻤﻠﺔ ‪ Select‬وﺗﺨﺘﺎر رﻗﻢ اﻷدارة " ‪ "department_id‬ورﻗﻢ اﻟﻤﻜﺎن "‪ " location_id‬وﻧﻀﻌﻬﻢ‬
‫ﺑﺄﺳﺘﺨﺪام ) ‪ ( into‬ﻓﻰ اﻟﻤﺘﻐﻴﺮﻳﻦ ‪ location_id ، v_deptno‬ﻋﻠﻰ اﻟﺘﺮﺗﻴﺐ وذﻟﻚ ﻣﻦ ﺟﺪول )‬
‫‪ (departments‬ﺣﻴﺚ ) ‪ ( where‬ﺗﻔﻌﻞ ﻋﻠﻰ ذﻟﻚ ﻋﻠﻰ اﻷدارة أﻟﺘﻰ اﺳﻤﻬﺎ‬
‫'‪.(department_name) ' sales‬‬
‫ﻻ ﻳﻌﻤﻞ اﻟﻜﻮد ﻓﻰ ﺣﺎﻟﺘﻴﻦ ‪:‬‬
‫‪ -1‬اذا رﺟﻌﺖ ﺟﻤﻠﺔ ‪ select‬ﺑﺄآﺜﺮ ﻣﻦ ﻗﻴﻤﺔ ﺳﺘﻈﻬﺮ أﺳﺘﺜﻨﺎء أﺳﻤﻪ "‪ "too_many_ows‬وﻳﻈﻬﺮ‬
‫ﺧﻄﺄ وﻻ ﻳﺴﺘﻜﻤﻞ اﻟﺒﺮﻧﺎﻣﺞ ‪.‬‬
‫‪ -2‬أذا رﺟﻌﺖ ﺟﻤﻠﺔ ‪ select‬وﻻ ﻗﻴﻤﺔ ) ﻻ ﺗﻮﺟﺪ ﻗﻴﻢ ﻧﺎﺗﺠﺔ ﻋﻦ ﺟﻤﻠﺔ ‪ ( select‬وهﺬا ﻳﻨﺸﺄ أﺳﺘﺜﻨﺎء‬
‫أﺳﻤﻪ " ‪ " no_date_found‬وآﺬﻟﻚ ﻳﻈﻬﺮ ﺧﻄﺄ وﻻ ﻳﺴﺘﻤﻜﻞ اﻟﺒﺮﻧﺎﻣﺞ ‪.‬‬
‫‪:‬‬ ‫أﺳﺘﺮﺟﺎع اﻟﺒﻴﺎﻧﺎت ﻓﻰ ﻟﻐﺔ ‪PL / SQL‬‬ ‫•‬

‫ﻣﻦ هﺬا اﻟﻜﻮد ﻧﺴﺘﻨﺘﺞ ﻧﻔﺲ اﻷﻓﻜﺎر ﻣﺜﻞ اﻟﻜﻮد اﻟﺴﺎﺑﻖ ﻣﻊ ﺑﻌﺾ اﻷﺿﺎﻓﺎت اﻟﺒﺴﻴﻄﺔ ﻣﺜﻞ –‬
‫أﺳﺘﺨﺪام ﺧﺎﺻﻴﺔ ‪ % type‬ﻓﻰ ﺗﻌﺮﻳﻒ اﻟﻤﺘﻐﻴﺮات ‪.‬‬
‫وهﺬا اﻟﻤﺜﺎل ﻳﻮﺿﺢ آﻴﻔﻴﺔ أﺳﺘﺨﺪام اﻟﻤﺘﻐﻴﺮات وآﺬﻟﻚ اﺳﺘﺮﺟﺎع اﻟﺒﻴﺎﻧﺎت ﺑﺄﺳﺘﺨﺪام ‪، select‬‬
‫وﻋﻤﻞ ‪ group function‬ﺗﺘﻴﺢ ﻟﻨﺎ ﻣﻌﺮﻓﺔ ﻣﺠﻤﻮع ﻣﺮﺗﺒﺎت ﻣﻮﻇﻔﻰ ادارة ﻣﻌﻴﻨﺔ آﻤﺎ ﻓﻰ اﻟﻤﺜﺎل‬
‫وﻋﺮض هﺬا اﻟﻤﺠﻤﻮع ﻓﻰ ﻧﻬﺎﻳﺔ اﻟﻤﺜﺎل ‪.‬‬
‫‪ o‬اﻣﺜﻠﺔ)ﻋﻠﻰ اﻟﻤﺴﺘﺨﺪم ‪:(Scott‬‬

‫ﻣﺜﺎل ‪:2‬‬

‫ﻣﺜﺎل ‪:3‬‬
 ‫ﻗﻮاﻋﺪ اﻟﺘﺴﻤﻴﺔ ‪:‬‬

‫ﻳﻮﺿﺢ اﻟﺸﻜﻞ اﻟﺴﺎﺑﻖ ﺣﺪوث ﺗﻌﺎرض ﻧﺘﺞ ﻋﻨﻪ ﺗﻨﻔﻴﺬ اﻟﺒﺮﻧﺎﻣﺞ وذﻟﻚ ﻟﺘﺴﻤﻴﺔ اﻟﻤﺘﻐﻴﺮات ﺑﺄﺳﻤﺎء‬
‫اﺟﺰاء ﻓﻰ ﻗﺎﻋﺪة اﻟﺒﻴﺎﻧﺎت )أﻋﻤﺪة ﻓﻰ ﺟﺪاول ( وهﺬا ﻏﻴﺮ ﻣﺮﻏﻮب ﻣﻤﺎ ﻳﻨﺘﺞ ﻋﻨﻪ ﻣﻦ ﻣﺸﺎآﻞ‬
‫أﺛﻨﺎء اﻟﺘﻨﻔﻴﺬ واﻟﻔﻬﻢ وآﺬﻟﻚ ﺑﻌﺪهﺎ ﻓﻰ اﻟﺘﻄﻮﻳﺮ ‪.‬‬
‫‪:‬‬ ‫اﻟﺘﻌﺎﻣﻞ ﻣﻊ اﻟﺒﻴﺎﻧﺎت ﺑﺄﺳﺘﺨﺪام ‪PL / SQL‬‬
 ‫ﻳﺘﻌﺎﻣﻞ ﻣﻊ ﺟﻤﻠﺔ ‪ DML‬ﺑﻄﺮﻳﻘﺔ‬ ‫وﻧﻌﻨﻰ هﻨﺎ ﺟﻤﻞ ‪ : DML‬آﻤﺎ هﻮ ﻣﻌﺮوف أن ‪PL / SQL‬‬
‫ﻣﺒﺎﺷﺮة آﻤﺎ ﻳﻠﻰ اﻣﺎ ﺟﻤﻞ ‪ DDL‬ﻓﺄﻧﻬﺎ ﻻ ﺗﺘﻌﺎﻣﻞ ﻣﻌﻬﺎ ﻟﻐﺔ ‪ PL / SQL‬اﻻ ﺑﻄﺮﻳﻘﺔ ﻏﻴﺮ ﻣﺒﺎﺷﺮة‬
‫ﻧﺮاهﺎ ﻻﺣﻘﺎ وﻓﻰ اﻟﺠﺰء اﻟﺘﺎﻟﻰ ﺳﻨﺘﻌﺎﻣﻞ ﻣﻊ ﺟﻤﻞ‬
‫) ‪( merge, delete, update, insert‬‬

‫أوﻻ ‪insert‬‬

‫ﺟﻤﻠﺔ ‪ insert‬ﻣﺜﻞ ‪ SQL‬ﺗﻤﺎﻣﺎ ﺑﺎﻷﺿﺎﻓﺔ اﻟﻰ ‪:‬‬ ‫ﻓﻰ ‪PL / SQL‬‬

‫أﺳﺘﺨﺪام اﻟﺪوال اﻟﻤﺨﺘﻠﻔﺔ ﻓﻴﻬﺎ ‪.‬‬ ‫‪-‬‬
‫أﺳﺘﺨﺪام اﻟﻤﺘﻐﻴﺮات )‪ (sequence‬ﻷدﺧﺎل ﻗﻴﻢ اﻟﻤﻔﺘﺎح ) ‪. ( primary key‬‬ ‫‪-‬‬
‫أﺿﺎﻓﺔ ﻗﻴﻢ أﺗﻮﻣﺎﺗﻴﻜﻴﺔ ﻟﻌﻤﻮد ﻣﺎ ﻓﻰ اﻟﺠﺪول ‪.‬‬ ‫‪-‬‬
‫ﻣﺜﺎل ﻋﻠﻰ ﺟﻤﻠﺔ ‪:Insert‬‬

‫ﺛﺎﻧﻴﺎ ‪update‬‬
 ‫وﻟﻜﻦ اﻟﺠﺪﻳﺪ أﻧﻬﺎ أﺻﺒﺤﺖ ﻟﺪى اﻟﻤﺒﺮﻣﺞ‬ ‫ﻳﻤﻜﻦ أﺿﺎﻓﺔ ﺟﻤﻠﺔ )‪ (update‬داﺧﻞ آﻮد ‪PL / SQL‬‬
‫اﻟﻜﺜﻴﺮ ﻣﻦ اﻟﺤﺮﻳﺔ ﻧﺘﻴﺠﺔ وﺟﻮد أﻣﻜﺎﻧﻴﺎت ‪ PL / SQL‬ﻣﺜﻞ اﻟﻤﺘﻐﻴﺮات وآﺬﻟﻚ )‪ (cursors‬ﻓﻴﻤﺎ ﺑﻌﺪ‬
‫ﺳﻴﺘﻢ ﺷﺮﺣﻪ وﺑﺎﻗﻰ أﻣﻜﺎﻧﻴﺎت اﻟﻠﻐﺔ ‪.‬‬
‫ﻣﺜﺎل ﻋﻠﻰ ﺟﻤﻠﺔ ‪: Update‬‬

‫ﺛﺎﻟﺜﺎ ‪delete‬‬

‫ﻳﻤﻜﻦ آﺘﺎﺑﺔ ﺟﻤﻞ اﻟﺤﺬف ‪ delete‬ﺑﻜﻞ ﺳﻬﻮﻟﺔ وﻳﺴﺮ آﻤﺎ ﻧﺮى ﻓﻰ اﻟﻜﻮد اﻟﺴﺎﺑﻖ ﻣﻊ ﻣﺮاﻋﺎة‬
‫ﺷﺮوط‬
 ‫)‪ ( integrity constraint‬اﻟﺘﻰ ﺗﺤﺎﻓﻆ ﻋﻠﻰ اﻟﺮﺑﻂ ﺑﻴﻦ اﻟﺠﺪاول وﺑﻌﻀﻬﺎ ﺑﺎﻷﺿﺎﻓﺔ اﻟﻰ أن‬
‫اﻟﻤﺘﻐﻴﺮات اﻟﺴﺎﺑﻘﺔ ذآﺮهﺎ ﻣﻊ ﺟﻤﻠﺔ ‪ update‬ﻣﻄﺒﻘﺔ هﻨﺎ أﻳﻀﺎ وﺳﻮف ﻧﺮى ﻣﺪى ﺟﺪوى هﺬﻩ‬
‫اﻷﻣﻜﺎﻧﺎت ‪.‬‬
‫اﻟﻤﺜﺎل اﻟﺘﺎﻟﻰ ﻳﻮﺿﺢ ﻋﻤﻠﻴﺔ اﻟﺤﺬف ﺑﺎﺳﺘﺨﺪام اﻟﺠﻤﻠﺔ اﻟﺴﺎﺑﻘﺔ‪:‬‬

‫راﺑﻌﺎ ‪Merge‬‬
‫ﺑﻜﻞ ﺳﻬﻮﻟﺔ وﻳﺴﺮ آﻤﺎ ﻓﻰ اﻟﻤﺜﺎﻟﻴﻦ اﻟﺴﺎﺑﻘﻴﻦ ‪.‬‬ ‫ﺟﻤﻠﺔ ‪ Merge‬ﻧﺮى أﻧﻬﺎ ﺗﻄﺒﻖ داﺧﻞ ‪PL / SQL‬‬

‫اﻟﻤﺆﺷﺮ ‪ SQL‬أو " ‪" SQL cursor‬‬

‫س ‪ :‬ﻣﺎ هﻮ اﻟﻤﺆﺷﺮ ‪ SQL‬أو " ‪ " SQL cursor‬؟‬
‫ﺟـ ‪ -‬هﻮ ﺟﺰء ﺧﺎص ﻣﻦ اﻟﺬاآﺮة ﻳﻔﺘﺤﻪ اﻷوراآﻞ ﻟﺘﻨﻔﻴﺬ أى ﺟﻤﻠﺔ ‪ DML‬داﺧﻠﻪ ‪.‬‬
 ‫ﺧﺼﺎﺋﺺ اﻟﻤﺆﺷﺮ ‪- : ( SQL cursor ) SQL‬‬
‫ﻳﻮﺿﺢ ﻋﺪد اﻟﺼﻔﻮف اﻟﺘﻰ ﺗﻤﺖ ﻋﻠﻴﻬﺎ أﺧﺮ ﺟﻤﻠﺔ ‪DML‬‬ ‫‪SQL % rowcount -1‬‬
‫ﻧﻔﺬهﺎ اﻷوراآﻞ ‪.‬‬
‫وهﻮ ﻳﺮﺟﻊ ﻗﻴﻢ ‪ Boolean‬وﻳﺮﺟﻊ ﺑﻘﻴﻤﺔ ‪ true‬اذا آﺎﻧﺖ‬ ‫‪SQL % found -2‬‬
‫أﺧﺮ ﺟﻤﻠﺔ ‪ DML‬ﻧﻔﺬهﺎ اﻷوراآﻞ ﻧﻔﺬت ﻋﻠﻰ ﺻﻒ واﺣﺪ‬
‫ﻋﻠﻰ اﻷﻗﻞ واﻟﻌﻜﺲ ﺻﺤﻴﺢ ‪.‬‬
‫‪ SQL % notfound -3‬وهﻰ ﻋﻜﺲ اﻟﺨﺎﺻﻴﺔ اﻟﺴﺎﺑﻘﺔ ‪.‬‬
‫ﺗﻮﺿﺢ ﻣﺎ اذا آﺎن اﻟﻤﺆﺷﺮ ﻣﻔﺘﻮﺣﺎ ام ﻻ وهﻰ داﺋﻤﺎ ‪.false‬‬ ‫‪SQL % ISOPEN -4‬‬
‫ﻣﺜﺎل ﻋﻠﻰ إﺳﺘﺨﺪام ‪: SQL CURSOR‬‬

‫ﻳﻘﻮم اﻟﻤﺜﺎل ﺑﺎﻟﺘﺎﻟﻰ ‪:‬‬

‫‪ -‬ﺗﻌﺮﻳﻒ ﻣﻨﻐﻴﺮ ﻣﻦ اﻟﻨﻮع ) ‪ Row_deleted ( Bind‬وﻧﻮع ﺑﻴﺎﻧﺎﺗﻪ )‪ varchar2(30‬وذﻟﻚ‬
‫ﺧﺎرج ﺑﻠﻮك ‪. Pl/SQL‬‬
‫‪ -‬اﻟﺠﺰء اﻟﺘﻌﺮﻳﻔﻰ ‪:‬‬
‫‪ o‬ﻳﻌﺮف ﻣﺘﻐﻴﺮ اﺳﻤﻪ ‪ V_EMPLOYEE_ID‬ﻣﻦ ﻧﻔﺲ ﻧﻮع اﻟﻌﻤﻮد‬
‫‪ EMPLOYEE_ID‬ﻓﻰ ﺟﺪول ‪ EMPLOYEE‬وﻳﺄﺧﺬ ﻗﻴﻤﺔ اﺑﺘﺪاﺋﻴﺔ ‪. 176‬‬
‫‪ -‬اﻟﺠﺰء اﻟﺘﻨﻔﻴﺬى ‪:‬‬
‫‪ o‬ﻳﺴﺘﺨﺪم اﻷﻣﺮ ‪ DELETE‬ﻟﺤﺬف اﻟﺼﻒ اﻟﺬى ‪ EMPLOYE_ID‬ﻳﺴﺎوى ‪. 176‬‬
‫‪ o‬ﺛﻢ ﻳﺴﺘﺨﺪم اﻟﻤﺘﻐﻴﺮ اﻟﺨﺎرﺟﻰ ) ‪" ( BIND‬ﻻﺣﻆ وﺟﻮد )‪ (:‬ﻗﺒﻞ اﺳﺘﺨﺪاﻣﻪ"‬
‫وﻳﻀﻊ ﻓﻴﻪ ﻋﺪد اﻟﺼﻔﻮف اﻟﻤﺤﺰوﻓﻪ ﺑﺈﺳﺘﺨﺪام اﻟﺨﺎﺻﻴﺔ ‪SQL%ROWCOUAT‬‬
‫ﻟﻴﻌﺮف ﻋﺪد اﻟﺼﻔﻮف اﻟﺘﻰ ﺗﻢ ﺣﺬﻓﻬﺎ ‪.‬‬

‫ﺟﻤﻠﺔ اﻟﺘﺤﻜﻢ ‪: TRANSACTION CONTEROL STATEMANTS‬‬

‫‪ -‬ﻳﻤﻜﻦ داﺧﻞ ﺑﻠﻮآﺎت وآﻮد ﻟﻐﺔ ‪ PL/SQL‬اﺳﺘﺨﺪام أواﻣﺮ ‪ ROLLBACK‬أو ‪CAMMIT‬‬
‫وآﺬﻟﻚ اﻷﻣﺮ ‪. SAVEPOINT‬‬
 ‫اﻟﻔﺼﻞ اﻟﺨﺎﻣﺲ‬

‫اﻟﺘﻌﺎﻣﻞ ﻣﻊ اﻧﻮاع اﻟﺒﻴﺎﻧﺎت اﻟﻤﻌﺘﻤﺪة‬

‫‪Working with Composite datatypes‬‬

‫ﻓﻰ هﺬا اﻟﻔﺼﻞ ﺳﻮف ﻧﻐﻄﻰ ﻧﻮﻋﻴﻦ ﻣﻦ أﻧﻮاع اﻟﺒﻴﺎﻧﺎت اﻟﻤﻌﺘﻤﺪة اﻟﺘﺮآﻴﺐ‬
‫)‪index by table(array‬‬ ‫‪-1‬‬
‫اﻟﺴﺠﻞ ‪record‬‬ ‫‪-2‬‬
‫وﺗﺘﻤﻴﺰ هﺬﻩ اﻻﻧﻮاع ﺑﺼﻔﺎت ﻋﺎﻣﺔ هﻰ ‪:‬‬
‫‪ -‬ﻳﻤﻜﻦ ﺗﻘﺴﻴﻤﻬﺎ داﺧﻠﻴﺎ اﻟﻰ ﻣﻜﻮﻧﺎت ﻣﺨﺘﻠﻔﺔ‬
‫‪ -‬ﻳﻤﻜﻦ أﻋﺎدة اﺳﺘﺨﺪاﻣﻬﺎ‬

‫أوﻻ‪ :‬اﻟﺴﺠﻞ ‪record‬‬

‫وهﻮ ﻣﺜﻞ اﻟﻤﺘﻐﻴﺮات اﻟﻤﻔﺮدة ﻓﻰ آﺜﻴﺮ ﻣﻦ اﻟﺼﻔﺎت‬
‫‪ -‬اﻟﺴﺠﻞ ﻋﺒﺎرة ﻋﻦ ﻣﺘﻐﻴﺮات ﻣﺮﺗﺒﻄﺔ ﺑﺒﻌﻀﻬﺎ وﻳﺘﻢ اﻟﺘﻌﺎﻣﻞ آﻮﺣﺪة واﺣﺪة‪.‬‬
‫‪ -‬وهﻮ ﻣﺸﺎﺑﺔ ﻓﻰ ﺗﺮآﻴﺒﺔ ﻟﻞ )‪ (structure‬ﻓﻰ ﻟﻐﺎت اﻟﺒﺮﻣﺠﺔ ﻣﻦ اﻟﺠﻴﻞ اﻟﺜﺎﻟﺚ‬
‫ﻣﺜﻞ ‪.Pascal , c‬‬
‫‪ -‬وهﻰ ﻟﻴﺴﺖ ﻣﺜﻞ ﺻﻒ ﻣﻦ ﺻﻔﻮف اﻟﺠﺪاول ﺗﻤﺎﻣﺎ‪.‬‬
‫‪ -‬ﻳﻤﻜﻦ اﺳﺘﻘﺒﺎل ﻗﻴﻢ ﺻﻒ ﻣﻦ ﻗﺎﻋﺪة اﻟﺒﻴﺎﻧﺎت أو ﺟﺪول ﻣﻨﻬﺎ ﻣﺒﺎﺷﺮة‪.‬‬

‫ﻓﻤﺜﻼ ﻣﻤﻜﻦ ﻟﻠﺴﺠﻞ ‪ record‬أن ﻳﺤﺘﻮى ﻋﻠﻰ ﺟﺰء ‪ number‬ﻟﻠﻤﺮﺗﺐ ‪ salary‬وﺟﺰء‬

‫رﻗﻤﻰ اﺧﺮ ﻟﺮﻗﻢ اﻻدارة وأﺧﺮى ﺣﺮﻓﻰ‪ char‬ﻻﺳﻢ اﻟﻤﻮﻇﻒ وهﻜﺬا‪.......‬‬
‫وﻟﻜﻦ آﻞ واﺣﺪ ﻣﻦ هﺬﻩ اﻟﺤﻘﻮل ﻳﻜﻮن ﻟﺪﻳﻪ ﻗﻴﻤﺔ واﺣﺪة ﻓﻘﻂ‬
‫اﻟﺼﻴﻐﺔ اﻟﻌﺎﻣﺔ ‪:‬‬

‫‪ : Type_name‬هﻮ ﻧﻮع اﻟﺴﺠﻞ‬

‫‪ : Filed-name‬اﺳﻢ اﻟﺤﻘﻞ داﺧﻞ اﻟﺴﺠﻞ‬
‫‪ : Field-type‬ﻧﻮع اﻟﺒﻴﺎﻧﺎت داﺧﻞ اﻟﺤﻘﻞ اﻟﺬى داﺧﻞ اﻟﺴﺠﻞ‬

‫أوﻻ ‪ :‬ﻳﺘﻢ ﺗﻌﺮﻳﻒ ﻧﻮع اﻟﺬى ﻳﺤﺘﻮى ﻋﻠﻰ ﺑﻴﻨﺔ اﻟﺴﺠﻞ ﻟﻜﻰ ﻳﺘﻢ ﻋﻤﻞ ﻣﻨﻬﺎ ﺳﺠﻼت‬
‫ﺑﻨﻔﺲ اﻟﺒﻴﻨﺔ ﻓﻤﺜﻼ هﻨﺎك ﺑﻨﻴﺔ ‪) datatype‬هﻴﻜﻞ( رﻗﻤﻰ )‪ (number‬داﺧﻞ ﻗﺎﻋﺪة‬
‫اﻟﺒﻴﺎﻧﺎت وﻧﻌﻤﻞ ﻣﻨﻪ أﻣﺜﻠﺔ وأﺷﻜﺎل وهﻰ اﻟﻤﺘﻐﻴﺮات اﻟﺮﻗﻤﻴﺔ‪.‬‬
‫ﻣﺜﻼ ‪v_id number :‬‬
 ‫ﻷن اﻟﻨﻮع )‪ (number‬ﻣﻮﺟﻮد اﺻﻼ داﺧﻞ ﻗﺎﻋﺔ اﻟﺒﻴﺎﻧﺎت ﻟﺬﻟﻚ ﻧﻀﻊ اوﻻً ﻟﻨﺎ ﻧﻮع ﺟﺪﻳﺪ‬
‫وهﻮ اﻟﺴﺠﻞ وﻧﺤﺪد ﺗﺮآﻴﺒﻪ داﺧﻠﻴﺎ وﺑﻌﺪهﺎ ﻧﺤﺪد ﻣﺜﺎل ﻣﻨﻪ وهﻮ اﻟﺬى ﺳﻮف ﻧﺴﺘﺨﺪﻣﻪ‬
‫ﻓﻰ داﺧﻞ اﻟﺒﺮﻧﺎﻣﺞ‬
‫ﻣﺜﺎل ‪:‬‬

‫ﻓﻰ هﺬا اﻟﻤﺜﺎل ﻳﺘﻢ ﺗﺤﺪﻳﺪ ﻧﻮع ‪ emp_record_type‬وﻧﻜﻮن هﺬا اﻟﻨﻮع آﻤﺎ ﻓﻰ اﻟﻤﺜﺎل‬
‫ﺛﻢ ﻧﻜﻮن ﻣﻦ هﺬا اﻟﻨﻮع ﻣﺜﺎل او ﺣﺎﻟﺔ وهﺬا اﻟﻤﺜﺎل هﻮ اﻟﺬى ﺳﻮف ﻳﺴﺘﺨﺪم ﻓﻰ‬
‫اﻟﺒﺮﻧﺎﻣﺞ ﺑﻌﺪ ذﻟﻚ وهﺬا اﻟﻤﺜﺎل ﻓﻰ اﻟﻜﻮد هﻮ ‪ emp_record‬و ﻃﺒﻌﺎ ﻟﻪ ﻧﻔﺲ ﺗﺮآﻴﺐ‬
‫اﻟﻨﻮع اﻟﺬى هﻮ ﻣﻜﻮن ﻣﻨﻪ‪.‬‬
‫اﻟﻔﺮق ﺑﻴﻦ اﻟﻨﻮع‪ ،‬اﻟﻤﺜﺎل ‪:‬‬

‫وﻳﺘﻢ اﻟﺘﻌﺎﻣﻞ ﻣﻊ اﺟﺰاء اﻟﺴﺠﻞ آﻼً ﻋﻠﻰ ﺣﺪى ﻣﺜﻞ اﻟﺠﻤﻠﺔ اﻟﺘﺎﻟﻴﺔ‬
‫;'‪Emp_record. Job_id : = 'manger‬‬
‫اﻟﺠﺰء اﻻول هﻰ اﺳﻢ اﻟﺴﺠﻞ ﺛﻢ ﻧﻘﻄﺔ ﺛﻢ اﺳﻢ اﻟﺤﻘﻞ وﻳﺘﻢ اﻟﺘﻌﺎﻣﻞ ﻣﻌﻪ ﺑﻬﺬﻩ‬
‫اﻟﻄﺮﻳﻘﺔ ‪.‬‬

‫اﻟﺨﺎﺻﻴﺔ ‪rowtype %‬‬

‫ﺑﻬﺬﻩ اﻟﺨﺎﺻﻴﺔ ﻳﻤﻜﻦ ﻋﻤﻞ ﺳﺠﻞ ﻳﺄﺧﺬ ﻧﻔﺲ ﺗﺮآﻴﺐ اﻟﺴﺠﻞ ﻓﻰ ﺟﺪول ﻣﻮﺟﻮد‬
‫ﺑﻘﺎﻋﺪة اﻟﺒﻴﺎﻧﺎت ﻟﺬﻟﻚ ﻻ ﻧﺤﺘﺎج أن )ﻧﻀﻊ( ﻧﻌﺮف اوﻻ ﻧﻮع ﻣﻮﺟﻮد ﺑﺎﻟﻔﻌﻞ وهﻮ ﺑﻨﻴﻪ هﺬا‬
‫اﻟﺠﺪول وهﻨﺎ ﻳﺘﻢ أﺧﺬ ﺑﻨﻴﻪ اﻟﺠﺪول ﺑﻨﻔﺲ أﻧﻮاع اﻟﺒﻴﺎﻧﺎت وأﺳﻤﺎء اﻻﻋﻤﺪة وﻗﻴﻢ ‪not‬‬
‫‪ null‬واﻟﻘﻴﻢ اﻻﺗﻮﻣﺎﺗﻴﻜﻴﺔ )اﻻﻓﺘﺮﺿﻴﺔ( ‪default‬‬
‫ﻣﺜﺎل ‪- :‬‬
‫‪Declare‬‬
‫‪Emp_record‬‬ ‫;‪employees % rowtype‬‬
‫‪Begin‬‬
‫'‪Emp_record. last_name: ='smith‬‬
‫;‪End‬‬

‫اﻟﻤﺜﺎل اﻟﺘﺎﻟﻰ ﻳﻮﺿﺢ آﻴﻔﻴﺔ اﺳﺘﺨﺪام اﻟﺴﺠﻞ "‪ "record‬ﻓﻰ اﺳﺘﻘﺒﺎل ﻧﺘﺎﺋﺞ ﺟﻤﻠﺔ‬
‫"‪"select‬‬
‫‪Declare‬‬
‫;‪Emp_record employees%RowType‬‬
‫‪Begin‬‬
‫* ‪Select‬‬ ‫‪into emp_record‬‬
‫‪From employees‬‬
‫;‪Where employee_id = 100‬‬

‫ﻣﻤﻴﺰات اﻟﺨﺎﺻﻴﺔ ‪% rowtype‬‬

‫‪ -‬ﻓﻰ ﺑﻌﺾ اﻻﺣﻴﺎن ﻳﻜﻮن ﻣﻄﻠﻮب ﻋﺪم ﻣﻌﺮﻓﺔ اﻧﻮاع اﻟﺒﻴﺎﻧﺎت وﻋﺪد اﻻﻋﻤﺪة ﻓﻰ‬
‫ﻗﺎﻋﺪة اﻟﺒﻴﺎﻧﺎت‪.‬‬
‫‪ -‬ﻣﻦ اﻟﻤﻤﻜﻦ ﺗﻌﺪﻳﻞ ﻋﺪد واﻧﻮاع ﺑﻴﺎﻧﺎت اﻋﻤﺪة ﻗﺎﻋﺪة اﻟﺒﻴﺎﻧﺎت اﺛﻨﺎء اﺳﺘﺨﺪام‬
‫اﻟﺘﻄﺒﻴﻘﺎت‬
‫‪ -‬هﺬﻩ اﻟﺨﺎﺻﻴﺔ ﻣﻔﻴﺪة ﺟﺪا ﻋﻦ اﺳﺘﺨﺪام ﺟﻤﻠﺔ ) * ‪(select‬‬
‫ﻣﺜﺎل ﻋﻠﻰ اﺳﺘﺨﺪام اﻟﺨﺎﺻﻴﺔ ‪% rowtype‬‬

‫اﻟﻤﺜﺎل ﻳﻮﺿﺢ اﺳﺘﻘﺒﺎل ﻧﺘﻴﺠﺔ ) * ‪ ( select‬ﻓﻰ ﺳﺠﻞ ﺛﻢ اﺳﺘﺨﺪام هﺬا اﻟﺴﺠﻞ‬

‫ﻻدﺧﺎﻟﺔ ﻓﻰ ﺟﺪول ﺁﺧﺮ ﻟﻪ ﻧﻔﺲ اﻟﻬﻴﻜﻞ اﻟﺒﻨﺎﺋﻰ ﻟﻠﺴﺠﻞ‬

‫‪Index by‬‬
‫وهﻮ ﻧﻮع أﺧﺮ ﻣﻦ اﻧﻮاع اﻟﺒﻴﺎﻧﺎت اﻟﻤﻌﻘﺪة وﻳﺘﻜﻮن ﻣﻦ ﺟﺰﺋﻴﻦ اﺳﺎﺳﻴﻴﻦ ‪- :‬‬
‫‪ - 1‬ﻣﻔﺘﺎح اﺳﺎﺳﻰ ﻣﻦ اﻟﻨﻮع ‪ binary_integer‬او اﻟﻨﻮع ‪integer‬‬
‫‪ - 2‬ﻋﻤﻮد ﻣﻦ اﻟﻨﻮع اﻟﻤﻔﺮد او اﻟﻨﻮع ﺳﺠﻞ‬
‫ﻃﻮل هﺬا اﻟﻨﻮع ﻏﻴﺮ ﻣﺤﺪد وﻻ ﻗﻴﻮد ﻋﻠﻴﻪ‬
‫وهﻮ ﻧﻔﺲ اﻟﺸﻜﻞ )‪ (array‬او اﻟﻤﺼﻔﻮﻓﻪ ﻓﻰ اى ﻟﻐﺔ ﺑﺮﻣﺠﻪ ﻣﺜﻞ ‪ c‬ﻟﻜﻦ هﻨﺎ هﻮ‬
‫)‪ (array‬ﻣﻦ ﺑﻌﺪ واﺣﺪ ﻓﻘﻂ‪.(one dimension) .‬‬
‫اﻟﺼﻴﻐﺔ اﻟﻌﺎﻣﺔ ‪:‬‬

‫وهﻮ ﻳﺴﻴﺮ ﻋﻠﻰ ﻧﻔﺲ ﻃﺮﻳﻘﺔ ﺗﻌﺮﻳﻒ وﻋﻤﻞ ﺳﺠﻞ ﺣﻴﺚ اﻧﻪ ﻳﺘﻢ ‪:‬‬
‫أوﻻ ‪ -‬ﺗﻌﺮﻳﻒ اﻟﻨﻮع وﺿﻊ ﺷﻜﻞ اﻟﺒﻨﻴﻪ‬
‫ﺛﺎﻧﻴﺎ ‪ -‬ﻋﻤﻞ اﻣﺜﻠﺔ وﺣﺎﻻت ﻣﻦ هﺬا اﻟﻨﻮع اﻟﺬى ﺗﻢ ﺗﻌﺮﻳﻔﻪ ﻣﺴﺒﻘﺎ‪.‬‬

‫ﻣﻦ ﺧﻼل اﻟﺼﻴﻐﺔ اﻟﻌﺎﻣﺔ ‪:‬‬

‫‪ : TYBE_NAME‬اﺳﻢ اﻟﻨﻮع اﻟﻤﺮاد ﺗﺼﻤﻴﻤﻪ‬
‫‪ : Column_type‬اى ﻧﻮع ﻣﻔﺮد أو ﻣﺮآﺐ ﻣﺜﻞ ‪( varchar2 ,% type) date,‬‬
‫‪ : Identifier‬هﻮ اﻟﻤﺜﺎل او اﻟﺤﺎﻟﺔ اﻟﺘﻰ ﺗﺴﺘﺨﺪم ﻓﻰ آﻮد ‪PL \ SQL‬‬

‫هﻴﻜﻞ ‪:index by‬‬

 ‫ﻓﻰ اﻟﺸﻜﻞ آﻤﺎ ﻧﺮى ﻳﺸﺒﻪ ﺣﺪ آﺒﻴﺮ ﺟﺪاول ﻗﺎﻋﺪة اﻟﺒﻴﺎﻧﺎت‬
‫ﻻﺣﻆ ان ‪ index by‬ﻻ ﻳﺤﺪد ﻟﻪ ﻃﻮل أو ﺑﺪاﻳﻪ و ﻧﻬﺎﻳﻪ وﻟﻜﻦ ﻳﺘﻢ اﺿﺎﻓﺔ آﻞ ﺻﻒ داﺧﻠﻪ‬
‫ﻋﻨﺪ اﺳﺘﺨﺪاﻣﻪ‪.‬‬
‫ﻣﻦ اﻟﺸﻜﻞ ﻧﺮى ان هﻨﺎك ﻋﻤﻮد ﻳﺤﺘﻮى ﻋﻠﻰ "‪ "primary key‬واﻟﻌﻤﻮد اﻻﺧﺮ اﻟﺬى‬
‫ﺗﺤﺪد ﻧﻮﻋﻪ وﻳﻮﺿﻊ ﺑﻪ اﻟﻘﻴﻢ‬
‫ﻻﺣﻆ ‪ :‬ﻻﻳﻤﻜﻦ ﻋﻤﻞ ﻗﻴﻢ اﺑﺘﺪاﺋﻴﺔ ﻓﻰ ﺗﻌﺮﻳﻒ ‪index by‬‬
‫@ ﻣﺜﺎل ﻋﻠﻰ ‪: index by‬‬

‫ﻓﻰ اﻟﻤﺜﺎل ﻋﻤﻞ اﺛﻨﻴﻦ ﻣﻦ ‪ index by‬واﺣﺪ ﻳﺤﺘﻮى ﻋﻠﻰ اﺳﻤﺎء اﻟﻤﻮﻇﻔﻴﻦ ى اﻻﺧﺮ‬
‫ﻳﺤﺘﻮى ﻋﻠﻰ ﺗﺎرﻳﺦ اﻟﺘﻌﻴﻴﻦ ‪0‬‬
‫ﻣﻦ اﻟﻤﺜﺎل ﻳﺘﻢ ادﺧﺎل اﺳﻢ "‪ "Cammron‬ﻓﻰ اﻟﺼﻒ رﻗﻢ )‪ (1‬ﻓﻰ ‪ index by‬اﻻول‬
‫و ﻳﺘﻢ ادﺧﺎل ﺗﺎرﻳﺦ اﺳﺒﻮع ﻣﻦ اﻻن ﻓﻰ اﻟﺼﻒ رﻗﻢ )‪ (8‬ﻓﻰ )‪ (index by‬اﻻﺧﺮ‬
‫‪ -‬ﻣﻦ ﺧﻼل اﻟﻤﺜﺎل ﻳﺘﻢ اﺳﺘﺨﺪام ‪index by :-‬‬
‫آﺘﺎﺑﺔ اﺳﻢ ‪ index by‬ﺛﻢ آﺘﺎﺑﺔ رﻗﻢ اﻟﺼﻒ داﺧﻞ ﻗﻮﺳﻴﻦ ) ( ﺑﻌﺪ اﺳﻢ ‪index by‬‬
‫وهﻜﺬا ﻳﺘﻢ اﻟﺘﻌﺎﻣﻞ ﻣﻊ آﻞ ﺧﻠﻴﺔ ) ﺻﻒ ( داﺧﻞ ‪index by‬‬
‫; ﻗﻴﻤﺔ = ‪ ) :‬رﻗﻢ اﻟﺼﻒ ( اﺳﻢ ‪index by‬‬
‫ﺧﺼﺎﺋﺺ ‪- : index by‬‬
‫• ‪ - : exist‬وهﻰ ﻟﻤﻌﺮﻓﺔ هﻞ هﺬﻩ اﻟﺨﻠﻴﺔ ) ﺻﻒ ( ﻣﻮﺟﻮد ﻓﻰ ‪index by‬‬
‫• ‪ - : count‬ﻳﺎﺗﻰ ﺑﻌﺪد اﻟﺨﻼﻳﺎ داﺧﻞ ‪ index by‬اﻟﺘﻰ ﺗﺤﺘﻮى ﻋﻠﻰ ﻗﻴﻢ‬
‫• ‪ - : first‬ﺗﺎﺗﻰ ﺑﺮﻗﻢ )‪ (primary key‬اﻟﺨﺎص ﺑﺎول ﺧﻠﻴﺔ )ﺻﻒ( ﻓﻰ ‪index‬‬
‫‪by‬‬
‫• ‪ - : last‬ﻳﺎﺗﻰ ﺑﺮﻗﻢ اﺧﺮ ﺧﻠﻴﺔ ﻓﻰ ‪index by‬‬
‫• )‪ - : prior (n‬ﻳﺮﺟﻊ )‪ (index number‬ﺑﻌﺪد ﺧﻼﻳﺎ ‪.n‬‬
‫• )‪ :next (n‬ﺗﺎﺗﻰ )‪ (index number‬ﺑﻌﺪد اﻟﺨﻠﻴﻪ اﻟﺤﺎﻟﻴﻪ ﺑﻌﺪد ﺧﻼﻳﺎ )‪(n‬‬
‫• )‪ :term (n‬ﻳﻤﺴﺢ ﻋﺪد ﺧﻼﻳﺎ )‪ (n‬ﻣﻦ ﻧﻬﺎﻳﺔ ‪index by‬‬
‫• )‪: delete (m,n‬ﻳﻤﺴﺢ اﻟﺨﻼﻳﺎ ﻣﻦ اﻟﻨﻄﺎق ‪ m‬اﻟﻰ ‪ n‬ﻓﻰ ‪index by‬‬
‫ﻣﺜﺎل ﻋﻠﻰ ‪ index by‬ﻣﻊ اﻟﺴﺠﻞ " ‪" record‬‬
‫ﻳﺘﻢ ﻓﻰ اﻟﻤﺜﺎل ﻋﻤﻞ اﻟﺨﻼﻳﺎ ﻣﻦ اﻟﻨﻮع ﺳﺠﻞ ﻳﺤﺘﻮى ﻋﻠﻰ ﺻﻒ آﺎﻣﻞ ﻟﻠﺒﻴﺎﻧﺎت ﻣﻦ‬
‫اﻟﺠﺪول ‪ employees‬وﻳﺘﻢ ادﺧﺎل اﻟﺼﻔﻮف آﻤﺎ ﻧﺮى ﻓﻰ ﺷﻜﻞ ‪.Loop‬‬
‫ﻣﺜﺎل اﺧﺮ ﻋﻠﻰ اﺳﺘﺨﺪام اﻟﺨﻮاص ‪:‬‬
 ‫اﻟﻔﺼﻞ اﻟﺴﺎدس‬

‫اﻟﺘﻌﺎﻣﻞ ﻣﻊ ‪cursors‬‬

‫ﻣﺎ هﻮ "‪"cursors‬‬
‫هﻮ ﻋﺒﺎرﻩ ﻋﻦ ﻣﻜﺎن ﻓﻰ ‪ RAM‬او اﻟﺬاآﺮة ﻳﺘﻢ ﺣﺠﺰﻩ ﻟﻌﻤﻞ ﺟﻤﻠﻪ او اﻣﺮ ﻓﻰ ﻟﻐﺔ ‪.SQL‬‬
‫اﻧﻮاع ‪-: cursors‬‬
‫‪ - 1‬ﺻﺮﻳﺢ ‪explicit‬‬
‫‪ - 2‬ﺿﻤﻨﻰ ‪implicit‬‬

‫ﻣﺮاﺣﻞ ﻋﻤﻞ ‪ cursor‬ﻣﻦ اﻟﻨﻮع اﻟﺼﺮﻳﺢ ‪-:‬‬

‫ﻣﻦ اﻟﺸﻜﻞ ﻳﺘﻀﺢ اﻵﺗﻰ ‪-:‬‬

‫ﻳﻤﺮ ‪ cursor‬ﺑﻌﺪة ﻣﺮاﺣﻞ‬
‫‪ - 1‬ﻣﺮﺣﻠﺔ اﻟﺘﻌﺮﻳﻒ ‪:‬‬
‫ﻳﺘﻢ ﺧﻼﻟﻬﺎ ﺗﻌﺮﻳﻒ ‪ cursor‬وﻣﺎذا ﺳﻴﺤﺘﻮى واﺳﻤﻪ‬
‫‪ - 2‬ﻣﺮﺣﻠﺔ اﻟﻔﺘﺢ ‪:‬‬
‫واﻟﻤﺘﻐﻴﺮات "‬ ‫وﻳﺘﻢ ﻓﻴﻬﺎ ﻓﺘﺢ ‪ cursor‬وﺗﻨﻔﻴﺬ ﺟﻤﻠﺔ اﻻﺳﺘﻌﻼم"‪"query‬‬
‫"‪bind‬‬
‫‪ - 3‬ﻣﺮﺣﻠﺔ اﺣﻀﺎر اﻟﺒﻴﺎﻧﺎت ‪ :‬وﻳﺘﻢ ﻓﻴﻬﺎ اﺣﻀﺎر اﻟﺒﻴﺎﻧﺎت‬
‫‪ - 4‬ﻣﺮاﺣﻞ ﻏﻠﻖ ‪cursor‬‬
‫وﻳﺘﻢ ﻓﻴﻬﺎ ﻏﻠﻖ ‪ cursor‬وﻣﺴﺤﻪ ﻣﻦ اﻟﺬاآﺮﻩ و ﻻ ﻳﻤﻜﻦ اﻟﺘﻌﺎﻣﻞ ﺑﻬﺬا‬
‫"‪ " cursor‬ﻗﺒﻞ ﻓﺘﺤﻪ او ﺑﻌﺪ ﻏﻠﻘﻪ ‪.‬‬
‫اﻟﺸﻜﻞ اﻟﺘﺎﻟﻰ ﻳﻮﺿﺢ آﻴﻔﻴﺔ ﻋﻤﻞ "‪ "cursor‬ﻣﻊ اﻟﺒﻴﺎﻧﺎت ‪:‬‬
 ‫ﻻﺣﻆ ان "‪ "cursor‬ﻳﺘﻌﺎﻣﻞ ﻣﻊ اﻟﺒﻴﺎﻧﺎت ﺻﻒ ﺻﻒ ﻓﺎذا اﻧﺘﻬﻰ ﻣﻦ اﻟﺼﻒ ﻳﺘﻢ اﺣﻀﺎر‬
‫ﻏﻴﺮﻩ وﻻﻳﺮﺟﻊ ﺛﺎﻧﻴﻪ ﻟﺼﻒ ﺗﻢ اﻟﺘﻌﺎﻣﻞ ﻣﻌﻪ ﻧﻔﺲ ﻃﺮﻳﻘﺔ ﻋﻤﻞ "‪."stack‬‬
‫اﻟﺼﻴﻐﺔ اﻟﻌﺎﻣﺔ ﻟﺘﻌﺮﻳﻒ "‪ "cursor‬اﻟﺼﺮﻳﺢ ‪:‬‬

‫ﻓﻰ هﺬا اﻟﺸﻜﻞ ﻳﺘﻢ ﺗﻌﺮﻳﻒ "‪ "cursor‬وذﻟﻚ ﻓﻰ اﻟﺠﺰء اﻟﺘﻌﺮﻳﻔﻰ داﺧﻞ ﺑﻠﻮك ‪pl \ spl‬‬
‫ﻻﺣﻆ ‪:‬ﻻ ﺗﺴﺘﺨﺪم آﻠﻤﺔ ‪ into‬ﻓﻰ ﺟﻤﻠﺔ "‪ "select‬اﻟﺨﺎﺻﺔ ﺑﺎﻟـ "‪"cursor‬‬
‫ﻳﻤﻜﻦ ﻋﻤﻞ أى ﺷﻜﻞ ﻟﺠﻤﻠﺔ ‪ select‬ﺳﻮاء ‪----\ subquery \ join‬‬

‫ﻣﺜﺎل‪:‬‬

‫ﻓﻰ اﻟﺸﻜﻞ ﻳﺘﻢ ﺗﻌﺮﻳﻒ أﺛﻨﻴﻦ ﻣﻦ "‪ "cursor‬اﻻول ﻟﺠﻤﻠﺔ ﺗﺴﺘﺪﻋﻰ رﻗﻢ اﻟﻤﻮﻇﻒ‬
‫واﺳﻤﻪ \ واﻻﺧﺮ ﻳﺴﺘﺪﻋﻰ ﺑﻴﺎﻧﺎت اﻻدارات اﻟﺘﻰ رﻗﻢ ﻣﻜﺎﻧﻬﺎ ﻳﺴﺎوى ‪.170‬‬
‫ﻻﺣﻆ أن‬
‫ﺣﺘﻰ اﻻن ﻻﻳﻤﻜﻦ اﻟﺘﻌﺎﻣﻞ ﺑﻬﺬا "‪ "cursor‬ﻻﻧﻪ ﻟﻢ ﻳﺘﻢ ﻓﺘﺤﻪ ﺑﻌﺪ‬

‫ﻓﺘﺢ ‪"open cursor" cursor‬‬ ‫•‬

‫اﻟﺼﻴﻐﻪ هﻰ‬
 ‫هﻨﺎ ﻳﺘﻢ ﻓﺘﺢ "‪ "cursor‬ﺑﻌﺪهﺎ ﻳﻤﻜﻦ اﻟﺘﻌﺎﻣﻞ ﻣﻌﻪ‬

‫ﻋﻤﻠﻴﺔ اﻟﻔﺘﺢ ﺗﻨﻔﺬ ﻣﺎ ﻳﻠﻰ ‪- :‬‬

‫‪ - 1‬ﻳﺘﻢ ﺗﺤﺪﻳﺪ ﺟﺰء ﻣﻦ اﻟﺬاآﺮﻩ ﻟﻬﺬا "‪" cursor‬‬

‫‪ - 2‬ﺗﻨﻔﻴﺬ ﺟﻤﻠﺔ ‪select‬‬
‫‪ - 3‬وﺿﻊ ﻗﻴﻢ "‪"bind variables‬‬
‫‪ - 4‬ﻳﺘﻢ ﺗﻨﺸﻴﻂ هﺬﻩ اﻟﺼﻔﻮف اﻟﺘﻰ ﻓﻰ ‪ cursor‬ﻟﺘﺠﻬﻴﺰهﺎ ﻟﻠﻌﻤﻞ‬
‫‪ - 5‬وﺿﻊ ﻣﺆﺷﺮ ﻋﻠﻰ أول ﺻﻒ ﻟﻜﻰ ﻳﺘﻢ اﻟﺘﻌﺎﻣﻞ ﻣﻌﻪ ﻣﺒﺎﺷﺮة‪.‬‬
‫ﻻﺣﻆ ان ‪:‬‬
‫ﺟﻤﻠﺔ ‪ select‬اذا ﻟﻢ ﺗﺎﺗﻰ ﺑﺼﻔﻮف ﻓﺎﻧﻬﺎ ﻻ ﺗﻨﺘﺞ اﺧﻄﺎء ﻣﺜﻞ ﺟﻤﻠﺔ ‪ select‬داﺧﻞ ﺑﻠﻮك ‪pl/sql‬‬
‫*ﻋﻤﻠﻴﺔ اﺣﻀﺎر اﻟﺒﻴﺎﺗﺎت ﻣﻦ "‪fetching data from "cursor‬‬
‫ﺻﻴﻐﺔ اﺣﻀﺎر اﻟﺒﻴﺎﻧﺎت ‪:‬‬

‫وﻳﺘﻢ ﻓﻴﻬﺎ اﺳﺘﺮﺟﺎع اﻟﺒﻴﺎﻧﺎت اﻟﺤﻠﻴﻪ ﻣﻦ "‪ " cursor‬اﻟﻰ اﻟﻤﺘﻐﻴﺮات‬ ‫‪-‬‬
‫ﻳﻴﺠﺐ ﻣﺮاﻋﺎة ﻋﺪد اﻟﻤﺘﻐﻴﺮات و ﻃﺒﻴﻌﺔ ﺑﻴﺎﻧﺘﻬﻢ داﺧﻞ "‪"cursor‬‬ ‫‪-‬‬
‫واﻟﻤﺘﻐﻴﺮات اﻟﺘﻰ ﺳﻮف ﺗﺴﺘﻘﺒﻠﻬﻢ ﺑﺎﺳﺘﺨﺪام ﺟﻤﻠﺔ ‪fetch ---- into ----‬‬
‫وﺗﻘﻮم ﺟﻤﻠﺔ ‪ fetch‬ﺑﺎﻻﺗﻰ ‪:‬‬
‫‪ - 1‬اﺣﻀﺎر اﻟﺒﻴﺎﻧﺎت ﻣﻦ داﺧﻞ "‪ "cursor‬اﻟﻰ ﻣﺘﻐﻴﺮات اﻻﺧﺮاج‬
‫‪ - 2‬ﺗﻌﺪﻳﻞ ﻣﺆﺷﺮ "‪ "cursor‬ﻟﻴﺸﻴﺮ ﻋﻠﻰ اﻟﺼﻒ اﻟﺠﺪﻳﺪ ) اﻟﺘﺎﻟﻰ ( داﺧﻞ "‪"cursor‬‬
‫وﻧﺴﺘﻌﻤﻞ ﺟﻤﻞ "‪ "Loop‬ﻟﻴﺘﻢ اﺳﺘﺮﺟﺎع اﻟﺒﻴﺎﻧﺎت اﻟﺘﻰ داﺧﻞ "‪ "cursor‬واﻟﺘﻌﺎﻣﻞ ﻣﻌﻬﺎ آﻤﺎ‬
‫ﻓﻰ اﻟﻤﺜﺎل اﻟﺘﺎﻟﻰ‬

‫ﻓﻰ اﻟﻤﺜﺎل ﻳﺘﻢ ﻋﻤﻞ ﻋﺸﺮة ﻟﻔﺎت آﻞ ﻟﻔﻪ ﻳﺘﻢ ﺧﻼﻟﻬﺎ اﺣﻀﺎر اﻟﺒﻴﺎﻧﺎت اﻟﺘﻰ ﻓﻰ "‪ 'cursor‬و‬
‫ﻋﺮﺿﻬﺎ‬
‫ﻻﺣﻆ ان ‪:‬‬
‫اذا آﺎن "‪ "cursor‬ﻳﺤﺘﻮى ﻋﻠﻰ اآﺜﺮ ﻣﻦ ﻋﺸﺮﻩ ﺻﻔﻮف ﻓﺎﻧﻪ ﺳﻴﺘﻢ ﻋﺮض ‪ 10‬ﺻﻔﻮف‬
‫ﻓﻘﻂ هﻢ اﻟﻌﺸﺮ ﺻﻘﻮف اﻷول ﻓﻘﻂ‬
‫اذا آﺎن "‪ "cursor‬ﻳﺤﺘﻮى ﻋﻠﻰ اﻗﻞ ﻣﻦ ﻋﺸﺮهﺔ ﺻﻔﻮف ﻓﺎﻧﻪ ﻳﻌﺮض اﻟﺼﻔﻮف آﻠﻬﺎ‬
‫اﻟﺘﻰ ﻓﻰ ‪ cursor‬وﻳﺴﺘﻤﺮ ﻓﻰ ﻋﺮض اﺧﺮ ﺻﻒ ﺣﺘﻰ ﻳﻜﻤﻞ "‪ "Loop‬اﻟﻰ ﻋﺸﺮة ﻟﻔﺎت‬

‫*ﻋﻤﻠﻴﺔ اﻟﻐﻠﻖ ‪closing cursor‬‬

‫اﻟﺼﻴﻐﺔ ‪:‬‬
‫ةهﺬﻩ اﻟﻌﻤﻠﻴﻪ ﺗﺠﻌﻞ "‪ "cursor‬ﻏﻴﺮ ﻧﺸﻂ وﻳﺼﺒﺢ ﻏﻴﺮ ﻣﻤﻜﻦ اﻟﺘﻌﺎﻣﻞ ﻣﻌﻪ ىﺎﻻ اذا ﺗﻢ‬
‫ﻓﺘﺤﻪ ﻣﺮﻩ اﺧﺮى واذا ﺗﻢ ﻃﻠﺐ اﺳﺘﺮﺟﺎع ﺑﻴﺎﻧﺎت ﻣﻠﻒ "‪ "cursor‬وهﻮ ﻣﻐﻠﻖ ﻳﻈﻬﺮ ﺧﻄﺄ‬
‫‪ invalid-cursor-exception‬وﻃﺒﻌﺎ ﻳﺘﻢ ﺗﺤﺮﻳﺮ اﻟﺬاآﺮﻩ اﻟﺘﻰ ﺗﻢ ﺣﺠﺰهﺎ ﻟﻬﺬا "‪"cursor‬‬
‫وﻋﻤﻠﻴﺔ ﻏﻠﻖ "‪ "cursor‬ﺗﺘﻢ ﻓﻰ ﻧﻬﺎﻳﺔ اﻟﺒﻠﻮك او اﻟﺒﺮﻧﺎﻣﺞ اﻟﺬى ﻳﺤﺘﻮى هﺬا "‪"cursor‬‬
‫ﻟﻜﻦ ﻋﻤﻠﻴﺔ ﻏﻠﻘﻪ ﻳﺪوﻳﺎ ﺗﻔﻴﺪ ﻓﻰ اﺳﺘﻌﻤﺎل ﻣﺼﺎدر اﻟﺠﻬﺎز و اﻟﻨﻈﺎم ﺑﻄﺮﻳﻘﻪ اﻓﻀﻞ‬
‫وهﻨﺎك ﺣﺪ ﻟﻠﻤﺴﺘﺨﺪم ﻟﻔﺘﺢ ﻋﺪد ﻣﻦ "‪ "cursor‬وﻳﺘﻢ ﺗﺤﺪﻳﺪ هﺬا اﻟﻌﺪد داﺧﻞ ﻗﺎﻋﺪة‬
‫اﻟﺒﻴﺎﻧﺎت ﻟﻠﻤﺴﺘﺨﺪﻣﻴﻦ وهﻮ ﻳﺴﺎوى ‪ 50‬ﻟﺬﻟﻚ ﻳﺠﺐ ﻏﻠﻖ "‪ "cursor‬ﻋﻨﺪ ﻋﺪم اﻟﺤﺎﺟﻪ‬
‫ﻟﻪ ﺛﺎﻧﻴﺔ‬
‫واﻟﻤﻌﺎﻣﻞ اﻟﻤﺴﺌﻮل ﻋﻦ "‪ "cursor‬اﻟﺘىﻴﺘﻢ ﻓﺘﺨﻬﺎ ﻓﻰ وﻗﺖ واﺣﺪ هﻮ‬
‫‪Open cursor parameter‬‬
‫*ﺧﺼﺎﺋﺺ )‪ (cursor‬اﻟﺼﺮﻳﺢ ‪:‬‬
‫‪ - 1‬اﻟﺨﺎﺻﻴﻪ ‪ : %is open‬ﻟﺘﺤﺪد ﻣﺎ اذا آﺎن )‪ (cursor‬ﻣﻔﺘﻮح ام ﻻ وهﻰ ﻣﻦ اﻟﻨﻮع‬
‫‪Boolean‬‬
‫‪ - 2‬اﻟﺨﺎﺻﻴﻪ ‪ : %not found‬ﻣﻦ اﻟﻨﻮع ‪ Boolean‬ﻟﺘﺤﺪد ﻣﺎ اذا آﺎن ‪ cursor‬ﻟﻪ‬
‫ﺻﻔﻮف ام ﻻ‬
‫‪:‬ﻣﻦ اﻟﻨﻮع ‪ Boolean‬ﻟﺘﺤﺪد ﻣﺎ اذا آﺎن ‪cursor‬‬ ‫‪ - 3‬اﻟﺨﺎﺻﻴﻪ ‪%found‬‬
‫ﻟﻪ ﺻﻔﻮف ام ﻻ وهﻰ ﻋﻜﺲ اﻟﺨﺎﺻﻴﻪ اﻟﺴﺎﺑﻘﻪ‬
‫‪: % ROW COUNT- 4‬ﻟﺘﺮﺟﻊ ﺑﻌﺪد اﻟﺼﻔﻮف داﺧﻞ ‪CURSOR‬‬

‫ﻣﺜﺎل ﻋﻠﻰ اﺳﺘﺨﺪام اﻟﺨﺎﺻﻴﺔ ‪% ISOPEN‬‬

‫وهﺬا اﻟﻜﻮد اذا آﺎن )‪(CURSOR‬ﻏﻴﺮ ﻣﻔﺘﻮح ﻳﻔﺘﺤﻪ و اذا آﺎن ﻣﻔﺘﻮح ﻳﺒﺪأ ﻋﻠﻰ اﻟﻔﻮر‬
‫ﻓﻰ اﺳﺘﺨﺪاﻣﻪ ﺑﺪون ﻓﺘﺢ‪.‬‬
‫• ﻣﺜﺎل ﻋﻠﻰ اﺳﺘﺨﺪام اﻟﺨﺎﺻﻴﻪ ‪% NOT FOUND‬‬

‫واﻟﻤﺜﺎل ﻳﻮﺿﺢ آﻴﻔﻴﺔ اﻟﺨﺮوج ﻣﻦ )‪ (LOOP‬اذا ﻟﻢ ﻳﻮﺟﺪ ﺻﻔﻮف داﺧﻞ "‪"CURSOR‬‬

‫ﻣﺜﺎل ﻋﻠﻰ اﺳﺘﺨﺪام اﻟﺨﺎﺻﻴﻪ ‪%ROWCOUNT‬‬ ‫•‬

 ‫اﻟﻤﺜﺎل ﻳﻮﺿﺢ اﺳﺘﺨﺪام اﻟﺨﺎﺻﻴﺔ ﻓﻰ ﺟﻤﻠﺔ ‪IF‬‬
‫• ﻣﺜﺎل ﻋﻠﻰ اﺳﺘﺨﺪام ‪ CURSOR‬ﻣﻊ اﻟﺴﺠﻞ "‪"RECORD‬‬

‫______________________‬

‫اﺳﺘﺨﺪام ) ‪ (FOR LOOP‬ﻣﻊ ‪CURSOR‬‬

‫ﻳﻤﻜﻦ اﺳﺘﺨﺪام ‪ FOR LOOP‬ﻣﻊ ‪CURSOR‬‬ ‫‪-‬‬

‫ﺑﺤﻴﺚ ان اﻟﺠﻤﻠﺔ ﺗﻔﻌﻞ اﻻﺗﻰ ‪-:‬‬ ‫‪-‬‬
‫‪ -1‬ﺗﻔﺘﺢ ‪ CURSOR‬ﻓﻰ ﺑﺪاﻳﺘﻬﺎ وﻳﺤﺼﻞ ﻋﻤﻠﻴﺔ ‪ FETCH‬داﺧﻠﻬﺎ وﻳﻐﻠﻖ‬
‫اوﺗﻮﻣﺎﺗﻴﻜﻴﺎ ﻣﻊ ﻧﻬﺎﻳﺔ ﺟﻤﻠﺔ ‪FOR LOOP‬‬
‫ﻻ ﻳﺴﻤﺢ داﺧﻠﻬﺎ ﺑﺘﻌﺮﻳﻒ ﻋﺪاد او ﻏﺘﺢ وﻏﻠﻖ ‪ CURSOR‬اﻟﺘﻰ ﺗﻌﻤﻞ ‪ FOR‬ﻓﻴﻪ‬ ‫‪-‬‬
‫ﻳﻤﻜﻦ ارﺳﺎل ﻣﻌﺎﻣﻼت ﻟﻠـ ‪) CURSOR‬ﻳﺘﻢ ﺷﺮﺣﻪ ﻻﺣﻘﺎ (‬ ‫‪-‬‬

‫ﻣﺜﺎل ﻋﻠﻰ اﺳﺘﺨﺪام ‪ FOR LOOP‬ﻣﻊ ‪-: CURSOR‬‬

 ‫ﻻﺣﻆ‬
‫ﻋﺪم وﺟﻮد ﺟﻤﻞ ‪FETCH \ CLOSE \ OPEN‬‬
‫ﻳﺴﺘﺨﺪم ﻋﺪاد ‪ FOR‬ﻓﻰ اﺳﺘﺤﻀﺎر اﻟﺒﻴﺎﻧﺎت ﻣﻦ داﺧﻞ ‪CURSOR‬‬

‫اﻣﺜﻠﺔ ﻋﻠﻰ اﻟﻔﺼﻞ‬

‫ﻣﺜﺎل ‪ : 1‬ﻋﻠﻰ اﺳﺘﺨﺪام ‪ cursor‬اﻟﻀﻤﻨﻰ‪:‬‬

‫ﻣﺜﺎل ‪ : 2‬اﺳﺘﺨﺪام ‪ cursor‬ﻟﻌﺮض ﺑﻴﺎﻧﺎت اﻻدارات وﻋﺪد اﻟﻠﻤﻮﻇﻔﻴﻦ ﺑﻜﻞ ادارة‪.‬‬
 ‫اﻟﻔﺼﻞ اﻟﺴﺎﺑﻊ‬
‫اﻟﺘﻌﺎﻣﻞ اﻟﻤﺘﻘﺪم ﻣﻊ ‪cursor‬‬

‫ادﺧﺎل اﻟﻤﻌﺎﻣﻼت ﻣﻊ ‪cursor‬‬ ‫‪-‬‬

‫‪ o‬اﻟﺼﻴﻐﻪ اﻟﻌﺎﻣﺔ ‪:‬‬

‫ﺗﻮﺿﺢ اﻟﺼﻴﻐﺔ آﻴﻔﻴﺔ ﺗﻌﺮﻳﻒ ﻣﻌﺎﻣﻞ ﻟﻞ ‪ cursor‬وآﻴﻔﻴﺔ ﻓﺘﺢ )‪(cursor‬‬

‫وﺗﺴﺘﺨﺪم اﻟﻤﻌﺎﻣﻼت‬
‫ﺗﺠﻌﻞ )‪ (cursor‬اآﺜﺮ ﻣﺮوﻧﻪ اﺳﻬﻞ ﻓﻰ اﻟﺒﺮﻣﺠﻪ ﺑﺤﻴﺚ اﻟﺒﺮﻧﺎﻣﺞ ﻳﺴﺘﻘﺒﻞ‬ ‫‪-‬‬
‫هﺬﻩ اﻟﻤﻌﺎﻣﻼت وﻋﻠﻰ اﺳﺎﺳﻬﺎ ﻳﺒﺪأ ﻓﻰ ﻋﻤﻠﻴﺔ اﻻﺧﺘﻴﺎر وﻗﺼﺮ اﻟﺼﻔﻮف‬
‫داﺧﻞ )‪ (cursor‬ﻋﻠﻰ اﻟﺼﻔﻮف اﻟﻤﺮادة ﻓﻘﻂ‬
‫ﻣﺜﺎل ‪:‬‬

‫ﻳﻮﺿﺢ اﻟﻤﺜﺎل آﻴﻔﻴﺔ ﺗﻌﺮﻳﻒ )‪ (cursor‬ﺑﻤﻌﺎﻣﻼت وآﻴﻔﻴﺔ ﻣﻨﺎداﺗﻪ ﻣﻦ داﺧﻞ‬

‫آﻮد ‪PL \ SQL‬‬

‫• ﻣﺜﺎل ﻋﻠﻰ اﺳﺘﺨﺪام اﻟﻤﻌﺎﻣﻼت ﻓﻰ ‪:cursor‬‬

‫ﻳﻘﻮم اﻟﻤﺜﺎل ﺑﻌﺮض ﺑﻴﺎﻧﺎت آﻞ ﻣﻮﻇﻔﻲ ادارة ﻣﻌﻴﻨﺔ ﻣﻦ ﺟﺪول اﻟﻤﻮﻇﻔﻴﻴﻦ‪.‬‬
‫ﻣﺜﺎل ‪ :2‬ﻳﻘﻮم ﺑﺎدﺧﺎل رﻗﻢ اﻻدارة وﻳﻘﻮم ﺑﻌﺮض ﺑﻴﺎﻧﺎت اﻻدارة وآﺬﻟﻚ ﻋﺪد‬
‫ﻣﻮﻇﻔﻬﺎ‪:‬‬

‫اﺳﺘﺨﺪام ﺟﻤﻠﺔ ‪for update‬‬

 ‫وﺗﻀﺎف هﺬة اﻟﺠﻤﻠﻪ ﻓﻰ ﻧﻬﺎﻳﻪ ﺗﻌﺮﻳﻒ ‪ cursor‬وذﻟﻚ ﻟﻌﻤﻞ ﺣﺠﺰ‬
‫ﻟﺼﻔﻮف اﻟﺠﺪول اﻟﺬى ﺳﻴﺘﻢ ﻓﻴﻪ اﻟﺘﻌﺪﻳﻞ أو اﻟﺤﺰف‬
‫ﻓﺎذا ﻗﺎم اﻟﻤﺴﺘﺨﺪم ﺑﺎﺳﺘﺨﺪام هﺬا ‪ cursor‬ﻓﺄﻧﻪ ﻳﺤﺪث ﻋﻤﻠﻴﺔ‬
‫ﺣﺠﺰ)‪(Luck‬ﻟﻠﺠﺪول ﻟﺤﻤﺎﻳﺘﻬﻤﻦ اﻟﻤﺴﺘﺨﺪﻣﻴﻦ اﻻﺧﺮﻳﻴﻦ‪.‬‬

‫اﻟﺼﻴﻐﺔ ‪:‬‬ ‫•‬

‫وﺗﻀﺎف آﻠﻤﺔ )‪ (nowait‬ﻟﻠﺮﺟﻮع ﺑﺨﻄﺄ اذا آﺎﻧﺖ هﺬﻩ اﻟﺼﻔﻮف ‪lock‬‬

‫ﻣﺤﺠﻮزة ﻣﻦ ﻗﺒﻞ ﻣﺴﺘﺨﺪم ﺁﺧﺮ‬
‫ﻣﺜﺎل ‪:‬‬

‫*****************‬
‫اﺳﺘﺨﺪام ﺟﻤﻠﻪ ‪where current of‬‬
‫‪ o‬اﻟﺼﻴﻐﺔ ‪:‬‬

‫ﻣﺜﺎل ‪:‬‬

‫وﺗﺴﺘﺨﺪم هﺬﻩ اﻟﺠﻤﻠﺔ ﻣﻜﺎن ﺟﻤﻠﺔ ‪ where‬اﻟﻌﺎدﻳﺔ ﻓﻰ ‪ update‬او‬

‫‪ select‬او ‪ delete‬وﻣﻌﻨﺎهﺎ اذا آﺎن اﻟﺼﻒ اﻟﺬى ﻓﻰ ‪ cursor‬هﻮ ﻧﻔﺴﻪ اﻟﺬى‬
‫ﻳﺘﻢ اﻟﻌﻤﻞ ﻋﻠﻴﻪ ﻓﻰ ﺟﻤﻠﻪ ‪ DML‬ﻋﻠﻴﻪ وهﻰ ﺗﺒﺴﻴﻂ ﺑﺪﻻ ﻣﻦ اﺳﺘﺨﺪام‬
‫ﺷﺮط ﻣﺴﺎواة ‪ primary key‬ﻓﻰ ‪ cursor‬و ‪. table‬‬
‫ﻓﻔﻰ اﻟﻤﺜﺎل اﻟﺴﺎﺑﻖ ﻳﻤﻜﻦ اﺳﺘﺒﺪاﻟﻬﺎ ﺑــ ‪:‬‬
‫‪where emp_record.employee_id = employee_id‬‬
 ‫اﻟﻔﺼﻞ اﻟﺜﺎﻣﻦ‬

‫ااﻟﺘﻌﺎﻣﻞ ﻣﻊ اﻻﺳﺘﺜﻨﺎءات واﻻﺧﻄﺎء‬

‫‪HANDLING EXCEPTION‬‬

‫س ‪ :‬ﻣﺎ هﻮ " ‪ " EXCEPTION‬؟‬

‫ج ‪ :‬هﻮ ﺧﻄﺄ داﺧﻞ ‪ PL \ SPL‬ﻳﻈﻬﺮ ﻋﻦ ﺣﺪوث ﻋﻤﻠﻴـﺔ ﺧﻈـﺄ او ﺑﻨـﺎء ﻋﻠـﻰ ﻃﻠـﺐ‬
‫اﻟﻤﺴﺘﺨﺪم وﻳﻨﺘﺞ ﻋﻨﻪ ﻋﺪم اﺳﺘﻜﻤﺎل اﻟﺒﺮﻧﺎﻣﺞ وﺧﺮوﺟﻪ اﻟﻰ ﺑﻴﺌﻪ اﻟﺘﻨﻔﻴﺬ ‪ISQLPLUS‬‬
‫س ‪ :‬آﻴﻔﻴﺔ ﻧﺸﻮء اﻻﺳﺘﺜﻨﺎء ‪ EXCEPTION‬؟‬
‫ج ‪ :‬أ ‪ -‬داﺧﻠﻰ ‪ :‬ﺑﻮاﺳﻄﺔ اﻻوراآﻞ ﺗﻘﺎﻋﺪﻩ ﺑﻴﺎﻧﺎت ‪ :‬ﻣﺜﻞ ﻋﻨﺪﻣﺎ ﺟﻤﻠﺔ ‪ SELECT‬ﻻ‬
‫ﺗﺮﺟﻊ ﺑﻴﺎﻧﺎت ﻳﻨﺘﺞ ﺧﻄﺄ)اﺳﺘﺜﻨﺎء(‬
‫ب – ﺧﺎرﺟﻰ ‪ :‬ﺑﻮاﺳﻄﺔ اﻟﻤﺴﺘﺨﺪم ‪ :‬ﻣﺜﻞ ادﺧﺎل اﻟﻤﺴﺘﺨﺪم ﻟﺒﻴﺎﻧﺎت ﻏﻴﺮ ﻣﻘﺒﻮﻟﻪ‬
‫وﻗﺘﻬﺎ ﻳﻨﺘﺞ هﺬا اﻟﺨﻄﺄ‬
‫س ‪ :‬آﻴﻔﻴﺔ ﻣﻌﺎﻟﺠﺔ اﻻﺳﺘﺜﻨﺎء ‪ EXCEPYION‬؟‬
‫ج ‪ - :‬اﺳﺘﻘﺒﺎل اﻟﺨﻄﺄ )اﺻﻄﻴﺎدﻩ( واﻟﺘﻌﺎﻣﻞ ﻣﻌﻪ‬
‫‪ -‬ﺗﺮآﻪ ﻟﻠﺨﺮوج ﺑﺎﻟﺒﺮﻧﺎﻣﺞ اﻟﻰ ﺑﻴﺌﺔ اﻟﺘﻨﻔﻴﺬ ‪ SQLPLUS‬او ‪ISQLPLUS‬‬
‫س ‪ :‬ﻣﻌﺎﻟﺠﺔ اﻻﺳﺘﺜﻨﺎءات " ‪ " HANDLING EXCEPTION‬؟‬
‫ج‪:‬‬

‫ﻓﻰ اﻟﺸﻜﻞ ‪:‬‬

‫• اﻟﺠﺰء اﻻﻳﻤﻦ ﻳﻮﺿﺢ آﻴﻔﻴﺔ ﻧﺸﻮء اﺳﺘﺜﻨﺎء و ﻻ ﻳﻮﺟﺪ ﻟﻪ ﻣﻌﺎﻟﺠﻪ ﻟﺬﻟﻚ ﻳﺘﻮﻗﻒ‬
‫ﺑﻠﻮك )‪ (PL / SPL‬ﻋﻨﺪ ﻧﻘﻄﺔ ﻧﺸﻮء اﻻﺳﺘﺜﻨﺎء ﻳﺨﺮج اﻟﻰ ﺑﻴﺌﺔ ‪ISQLPLUS‬‬
‫• اﻟﺠﺰء اﻻﻳﺴﺮ ‪ :‬ﻳﻮﺿﺢ آﻴﻔﻴﺔ ﻧﺸﻮء اﻻﺳﺘﺜﻨﺎء وﻟﻜﻨﻪ ﻳﺨﺮج ﺧﺎرج اﻟﺒﻠﻮك‬
‫وﻳﺴﺘﻜﻤﻞ اﻟﺒﺮﻧﺎﻣﺞ داﺧﻞ ﺟﺰء )‪ (EXCEPTION‬وﻳﻨﻔﺬ ﻣﻌﺎﻟﺠﺔ اﻻﺳﺘﺜﻨﺎء‪.‬‬

‫اﻧﻮاع اﻻﺳﺘﺜﻨﺎءات ‪EXCEPTION TYPES‬‬

‫ﺁ ‪ -‬داﺧﻠﻰ ﺑﻮاﺳﻄﺔ اﻻوراآﻞ هﻮ ﻧﻮﻋﺎن ‪- :‬‬
‫‪ - 1‬أﺧﻄﺎء ﻣﻌﺮﻓﺔ ﻣﺴﺒﻘﺎ‬
‫‪ - 2‬أﺧﻄﺎء ﻏﻴﺮ ﻣﻌﺮﻓﺔ ﻣﺴﺒﻘﺎ‬
‫ب ‪ -‬ﺧﺎرﺟﻰ وﻳﻌﺘﻤﺪ ﻋﻠﻰ ﺗﻌﺮﻳﻒ اﻟﻤﺴﺘﺨﺪم )اﻟﻤﺒﺮﻣﺞ( ﻟﻪ‪.‬‬
 ‫ﻃــــــــــﺮﻳﻘــــﺔ‬ ‫ﺷــــــــــــﺮﺣـــﻪ‬ ‫ﻧــــــــــــــﻮع‬ ‫م‬
‫اﻟﻌـــــــــﻼج‬ ‫اﻟﺨــــــﻄــﺄ‬
‫ﻻ ﻳﺘﻢ ﺗﻌﺮﻳﻔﻬﻢ وﻳﺘﻢ‬ ‫هﻢ ‪ 20‬ﺧﻄﺄ‬ ‫‪ -1‬اﺧﻄﺄ ﻣﻌﺮﻓﺔ ﻣﺴﺒﻘﺎ‬
‫ﻧﺸﻮْهﻢ ﺗﻠﻘﺎﺋﻴﺎ‬ ‫ﻣﻌﺮوف ﺣﺪوﺛﻬﻢ‬
‫داﺧﻞ ‪PLSQ‬‬

‫ﻳﺘﻢ ﺗﻌﺮﻳﻔﻬﻢ اوﻻ وﻧﺸﻮْهﻢ‬ ‫هﻢ ﺑﺎﻗﻰ‬ ‫‪ -2‬اﺧﻄﺄ ﻣﻦ ﻏﻴﺮ ﻣﻌﺮﻓﺔ‬

‫ﺗﻠﻘﺎﺋﻴﺎ‬ ‫اﻻﺧﻄﺎء‬ ‫ﻣﺴﺒﻘﺎ‬
‫اﻟﻘﻴﺎﺳﻴﺔ داﺧﻞ‬
‫اﻻوراآﻞ‬

‫ﻳﺘﻢ ﺗﻌﺮﻳﻔﻬﻢ اوﻻ وﻳﺘﻢ‬ ‫ﻇﺮف او ﺣﺎﻟﺔ‬ ‫‪ -3‬اﺧﻄﺎء ﻣﻌﺘﻤﺪة ﻋﻠﻰ‬

‫ﺣﺪوﺛﻬﻢ ﺧﺎرﺟﻴﺎ ﺑﻮاﺳﻄﺔ‬ ‫ﻳﻌﺘﺒﺮهﺎ اﻟﻤﺒﺮﻣﺞ‬ ‫ﺗﻌﺮﻳﻒ اﻟﻤﺴﺘﺨﺪم‬
‫اﻟﻜﻮد‬ ‫ﺣﺎﻟﺔ ﻏﻴﺮ ﻋﺎدﻳﺔ‬
‫ﺗﺴﺘﻮﺟﺐ ﺗﻮﻗﻒ‬
‫اﻟﺒﺮﻧﺎﻣﺞ‬

‫• اﺻﻄﻴﺎد اﻻﺧﻄﺎء ‪- :‬‬

‫اﻟﺼﻴﻐﺔ اﻟﻌﺎﻣﺔ ‪:‬‬

‫ﻳﻤﻜﻦ اﺻﻄﻴﺎد اى اﺧﻄﺎء وذﻟﻚ ﻋﻦ ﻃﺮﻳﻖ اﺳﺘﻘﺒﺎﻟﻪ ﻳﻜﻮن ﻣﻨﺎﺳﺐ ﻟﻪ ﻟﻤﻌﺎﻟﺠﺘﻪ وﻳﺘﻢ‬
‫ذﻟﻚ ﻓﻰ ﺟﺰء اﻻﺳﺘﺜﻨﺎءات آﻤﺎ ﻓﻰ اﻟﺸﻜﻞ اﻟﺴﺎﺑﻖ ‪.‬‬
‫آﻞ ﻣﻌﺎﻟﺠﺔ ﺗﺒﺪأ ﺑﻜﻠﻤﺔ )‪ ( when‬واﻟﺘﻰ ﺗﺤﺪد ﺑﻌﺪهﺎ ﻣﺎ هﻮ اﻻﺳﺘﺜﻨﺎء اﻟﺬى ﻳﺘﻢ‬
‫ﺗﻨﻔﻴﺬﻩ ﻋﻦ ﺣﺪوث هﺬا اﻻﺳﺘﺜﻨﺎء‪.‬‬
‫ﻓﻰ اﻟﺸﻜﻞ اﻟﺴﺎﺑﻖ ‪:‬‬
‫‪ :‬هﻮ اﻻﺳﻢ اﻟﻘﻴﺎﺳﻰ ﻟﻼﺧﻄﺎء اﻟﻤﻌﺮﻓﻪ ﻣﺴﺒﻘﺎ أو اﻻﺳﻢ‬ ‫• ‪Exception‬‬
‫اﻟﺬى ﺗﻢ ﺗﻌﺮﻳﻔﻪ ﻓﻰ اﻟﺠﺰء اﻟﺘﻌﺮﻳﻔﻰ ‪.‬‬
‫‪ :‬وهﻰ اﻟﺠﻤﻞ اﻟﺘﻰ ﺳﺘﻨﻔﺬ ﺑﻌﺪ ﺣﺪوث اﻻﺳﺘﺜﻨﺎء ‪0‬‬ ‫• ‪Statement‬‬
‫‪ :‬وهﻮ ﺟﺰء اﺧﺘﻴﺎرى وهﻮ ﻳﻌﺎﻟﺞ آﻞ اﻻﺳﺘﺜﻨﺎءات وﻳﺘﻢ وﺿﻌﻪ‬ ‫• ‪Others‬‬
‫ﻓﻰ ﺁﺧﺮ اﻻﺳﺘﺜﻨﺎءات ﻟﻤﻌﺎﻟﺠﺔ اى اﺳﺘﺜﻨﺎء ﻟﻢ ﻳﺘﻢ ﻣﻌﺎﻟﺠﺘﻪ ‪.‬‬
 ‫اﻟﻤﻌﺎﻟﺠﻪ ﺑﺎﺳﺘﺨﺪام " ‪:" when others‬‬
‫آﻤﺎ ﻋﺮﻓﻨﺎ ﻣﻦ ﻗﺒﻞ ﻋﻨﺪ ﺣﺪوث اى ﺧﻄﺄ او اﺳﺘﺜﻨﺎء ﻓﺎن اﻻوراآﻞ ﻳﺬهﺐ اﻟﻰ ﺟﺰء‬
‫اﻻﺳﺘﺜﻨﺎءات ﻓﺎذا وﺟﺪ ﻟﻪ ﻣﻌﺎﻟﺠﺔ ﻳﺨﺮج اﻟﻰ ﺑﻴﺌﻪ ﺗﻨﻔﻴﺬ اﻟﺒﻠﻮك‬
‫ﻟﺬﻟﻚ ﺗﻢ ﻋﻤﻞ اﻟﻤﻌﺎﻟﺠﻪ " ‪ "when others‬ﻟﺘﻘﻮم ﺑﻤﻌﺎﻟﺠﺔ ﺟﻤﻴﻊ اﻻﺧﻄﺎء وﺗﻮﺿﻊ ﺑﻌﺪ‬
‫آﻞ اﻟﻤﻌﺎﻟﺠﺎت ﺑﺤﻴﺚ ﻟﻢ ﻳﺠﺪ اﻻوراآﻞ اﻟﻤﻌﺎﻟﺠﺔ اﻟﻤﻨﺎﺳﺒﺔ ﻟﻼﺳﺘﺜﻨﺎء ﻳﺬهﺐ اﻟﻴﻬﺎ آﺤﻞ‬
‫اﺧﻴﺮ ﻟﻜﻰ ﻻ ﻳﺘﻮﻗﻒ اﻟﺒﺮﻧﺎﻣﺞ وﻳﺨﺮج اﻟﻰ ﺑﻴﺌﺔ اﻟﺘﻨﻔﻴﺬ‬
‫ﻻﺣﻆ ان ﺟﻤﻠﺔ )‪ (when others‬ﺗﻮﺿﻊ اخ ﻣﻌﺎﻟﺠﺔ ﻓﻰ ﺟﺰء اﻻﺳﺘﺜﻨﺎءات ﻓﺎذا‬
‫وﺿﻌﻨﺎ ﺑﻌﺪ اى ﻣﻌﺎﻟﺠﺔ ﻳﻨﺘﺞ ﺧﻄﺄ ﻓﻰ ‪syntax‬‬

‫* ﺧﻄﻮط ﻋﺎﻣﺔ ﻓﻰ اﺻﻄﻴﺎد اﻻﺧﻄﺎء ‪-:‬‬

‫‪ - 1‬ﻳﺒﺪأ ﻗﺴﻢ اﻻﺳﺘﺜﻨﺎءات ﺑﻜﻠﻤﺔ ‪EXCEPTION‬‬
‫‪ - 2‬ﻳﻤﻜﻦ ﻣﻌﺎﻟﺠﺔ آﻞ اﻻﺧﻄﺎء‬
‫‪ - 3‬ﻣﻌﺎﻟﺠﺔ واﺣﺪة ﻓﻘﻂ ﺗﺘﻢ ﻗﺒﻞ اﻟﺨﺮوج ﻣﻦ اﻟﺒﻠﻮك‬
‫‪ - 4‬اﻟﻤﻌﺎﻟﺠﺔ ‪ WHEN OTHERS‬هﻰ اﺧﺮ ﻣﻌﺎﻟﺠﺔ ﻓﻰ ﻗﺴﻢ اﻻﺳﺘﺜﻨﺎءات ‪.‬‬

‫اﻟﺘﻌﺎﻣﻞ ﻣﻊ اﻻﺧﻄﺎءاﻟﻤﻌﺮﻓﻪ ﻣﺴﺒﻘﺎ‬

‫وهﻰ ﻟﻬﺎ اﺳﻤﺎء ﻗﻴﺎﺳﻴﻪ ﺗﻨﺎدى ﺑﻬﺎ وهﻢ ﺣﻮاﻟﻰ ‪ 20‬ﺧﻄﺎء ﻓﻘﻂ ﻣﺜﻞ‬
‫• ‪: No data found‬ﻋﻨﺪ ﻋﺪم رﺟﻮع ﺟﻤﻠﺔ ‪ select‬ﺑﺄى ﺑﻴﺎﻧﺎت‬
‫• ‪ : Too-many-rows‬ﻋﻨﺪ رﺟﻮع ﺟﻤﻠﺔ ‪ select‬ﺑﺎآﺜﺮ ﻣﻦ ﺻﻒ‬
‫واﺳﺘﻘﺒﺎﻟﻪ ﻓﻰ ﻣﺘﻐﻴﺮ ﻣﻨﻔﺮد‬
‫• ‪ : Invalid-cursor‬ﺧﻄﺄ ﻓﻰ اﺳﺘﺨﺪام " ‪" cursor‬ﺳﻮاء‬
‫ﻓﺘﺤﻪ وهﻮ ﻣﻔﺘﻮح أو ﻏﻠﻘﻪ وهﻮ ﻣﻐﻠﻖ‬
‫• ‪ : Zero-divide‬اﻟﻘﺴﻤﻪ ﻋﻠﻰ ﺻﻔﺮ‬

‫@ ﻣﺜﺎل ﻋﻠﻰ اﺳﺘﺨﺪام اﻻﺧﻄﺎء اﻟﻤﻌﺮﻓﻪ ﻣﺴﺒﻘﺎ ‪-:‬‬

‫ﻓﻰ اﻟﺸﻜﻞ ﻋﻨﺪ ﺣﺪوث اﻟﺨﻄﺄ ‪ too-many-rows‬ﻳﻨﻔﺬ اﻟﻜﻮد اﻟﺬى ﺑﻌﺪﻩ واذا ﺣﺪث‬
‫اﻟﺨﻄﺄ ‪ data-not-found‬ﻳﻨﻔﺬ اﻟﻜﻮد اﻟﺬى ﺑﻌﺪﻩ اﻳﻀﺎ‪.‬‬
‫ﻻﺣﻆ ان اﻟﺨﻄﺄﻳﻦ ﻻ ﻳﻤﻜﻦ ان ﻳﺤﺪﺛﻮا ﻣﻌﺎ ‪ .‬ﻟﻤﺎذا ؟‬
 ‫ﻻﺣﻆ ان هﺬﻩ اﻻﺧﻄﺄء ﻻ ﻳﺘﻢ ﺗﻌﺮﻳﻔﻬﺎ ﻓﻬﻰ ﻣﻌﺮﻓﻪ ﻣﺴﺒﻘﺎ‪.‬‬

‫اﻷﺧﻄﺎء ﻏﻴﺮ ﻣﻌﺮوﻓﺔ ﻣﺴﺒﻘﺎً ‪nonpredefined error‬‬

‫آﻞ ﺧﻄﺄ أو اﺳﺘﺜﻨﺎء ﻓﻰ أوراآﻞ ﻟﻪ رﻗﻢ ) ﻻﺣﻆ أﻧﻪ ﺳﺎﻟﺐ ( ﻳﻌﺮف ﺑﻬﺬا اﻟﺮﻗﻢ ﻟﺬﻟﻚ‬
‫ﻧﺴﺘﺨﺪ م هﺬﻩ اﻻرﻗﺎم ﻟﻤﻌﺮﻓﺔ اﻷﺧﻄﺎء اﻟﻐﻴﺮ ﻣﻌﺮوﻓﻪ ﻣﺴﺒﻘﺎً ‪.‬‬

‫ﻟﻜﻰ ﻳﺘﻢ ﻣﻌﺎﻟﺠﺔ هﺬﻩ اﻻﺧﻄﺎء ﻧﻘﻮم ﺑﺎﻵﺗﻰ ‪-:‬‬

‫أوﻻً ‪ :‬ﺗﻌﺮﻳﻒ ﻣﺘﻐﻴﺮ ﻣﻦ اﻟﻨﻮع ‪ EXCEPTION‬ﻓﻰ اﻟﺠﺰء اﻟﺘﻌﺮﻳﻔﻰ ‪.‬‬
‫ﺛﺎﻧﻴﺎ ‪ :‬ﻳﺘﻢ اﺳﺘﺨﺪام ﺟﻤﻠﺔ ‪ PRAGMA EXCEPTION_INIT‬ﻟﻮﺿﻊ رﻗﻢ اﻹﺳﺘﺜﻨﺎء‬
‫ﻟﻠﻤﺘﻐﻴﺮ اﻟﺬى ﺗﻢ ﺗﻌﺮﻳﻔﺔ ﻓﻰ أوﻻً آﻤﺎ ﻓﻰ اﻟﻤﺜﺎل ‪.‬‬
‫ﺛﺎﻟﺜﺎ ‪ :‬ﻳﺘﻢ ﻣﻌﺎﻟﺠﺔ اﻹﺳﺘﺜﻨﺎء ﻓﻰ ﺟﺰء اﻹﺳﺘﺜﻨﺎءات ﺑﺈﺳﺘﺨﺪام اﺳﻢ اﻟﻤﺘﻐﻴﺮ ﻓﻰ ﺟﻤﻠﺔ‬
‫‪ WNEN-TNEN‬آﺎل ﻓﻰ اﻟﻤﺜﺎل ﻋﻨﺪ ﺣﺪوث هﻨﺎ اﻟﺨﻄﺄ ﻳﺘﻢ اﺳﺘﺪراﺟﻪ وﻣﻌﺎﻟﺠﺔ‬
‫ﺑﺈﺳﺘﺨﺪام اﻟﻤﺘﻐﻴﺮ اﻟﺬى أﺧﺬ رﻗﻢ اﻟﺨﻄﺄ آﻤﺎ ﻓﻰ اﻟﻤﺜﺎل ‪.‬‬
‫ﻻﺣﻆ أن ‪ :‬اﻟﺨﻄﺄ هﺬا ﻏﻴﺮ ﻣﻌﺮف ﻣﺴﺒﻘﺎً ﻟﻜﻨﻪ ﻳﻨﺸﺄ ﺗﻠﻘﺎﺋﻴﺎ ﻋﻨﺪ ﺣﺪوﺛﻪ وﻳﻌﺮﻓﻪ‬
‫اﻷوراآﻞ ‪.‬‬
‫اﻟﻤﺜﺎل اﻟﺘﺎﻟﻰ ﻳﻮﺿﺢ آﻴﻔﻴﺔ اﺳﺘﺨﺪام ﺟﻤﻠﺔ ‪: PRAGMA EXCEPTION_INIT‬‬

‫اﻟﺪوال ﻹﺻﻄﻴﺎد وﻣﻌﺮﻓﺔ اﻷﺳﺘﺜﻨﺎءات ‪:‬‬

 ‫‪ -1‬اﻟﺪاﻟﺔ )‪: (SQLCODE‬‬
‫وهﻰ داﻟﺔ ﺗﺮﺟﻊ ﺑﺮﻗﻢ اﻟﺨﻄﺄ أو اﻷﺳﺘﺜﻨﺎء ‪.‬‬
‫‪ -2‬اﻟﺪاﻟﺔ )‪: (SQLERRM‬‬
‫وهﻰ داﻟﺔ ﺗﺮﺟﻊ ﺑﺎﻟﺮﺳﺎﻟﺔ اﻟﻨﺼﻴﺔ اﻟﺘﻰ ﺗﺸﺮح ﻣﺘﻰ ﻳﺤﺪث اﻟﺨﻄﺄ وﺑﻌﺾ‬
‫اﻟﻤﻌﻠﻮﻣﺎت ﻋﻨﻪ ‪.‬‬
‫اﻟﻤﺜﺎل اﻟﺜﺎﻧﻰ ﻳﻮﺿﻊ آﻴﻔﻴﺔ اﺳﺘﺨﺪام هﺬﻩ اﻟﺪوال ﻟﻤﻌﺮﻓﺔ رق ﻣﺎﻟﺨﻄﺄ واﻟﺮﺳﺎﻟﺔ‬
‫اﻟﺨﺎﺻﺔ ﺑﻬﺎ ‪.‬‬

‫اﻟﻤﺜﺎل اﻟﺘﺎﻟﻰ ﻳﻮﺿﺢ اﺳﺘﺨﺪام هﺬﻩ اﻟﺪوال‪:‬‬

‫‪USER_DEPINED EXCEPTIONS‬‬ ‫اﻷﺧﻄﺎء اﻟﻤﻌﺮف ﻣﻦ اﻟﻤﺴﺘﺨﺪم‬

 ‫وهﻰ اﻷﺧﻄﺎء اﻟﺘﻰ ﻳﺘﻢ ﺗﻌﺮﻳﻔﻬﺎ وﻧﺸﺆهﺎ ﻣﻦ ﺧﻼل اﻟﻤﺴﺘﺨﺪم )اﻟﻤﺒﺮﻣﺞ( وذﻟﻚ ﻣﻦ‬
‫ﺧﻼل ‪:‬‬
‫أوﻻ ‪ :‬ﺗﻌﺮﻳﻒ ﻣﺘﻐﻴﺮ ﻣﻦ اﻟﻨﻮع ‪ EXCPTION‬ﻓﻰ اﻟﺠﺰء اﻟﺘﻌﺮﻳﻔﻰ ‪.‬‬
‫‪DECLARE‬‬
‫‪EXCEPTION_NAME‬‬ ‫;‪EXCEPTION‬‬
‫‪BEGIN‬‬
‫ﺛﺎﻧﻴﺎً ‪ :‬ﻧﺴﺘﺨﺪم ﺟﻤﻠﺔ ‪ RAISE‬ﻹﻧﺘﺎج )ﻧﺸﻮء( ﺧﻄﺄ أو اﺳﺘﺜﻨﺎء ﻳﺪوﻳﺎً وذﻟﻚ ﻓﻰ اﻟﺠﺰء‬
‫اﻟﺘﻨﻔﻴﺬى ) ﻻﺣﻆ أن هﺬا اﻟﺨﻄﺄ ﺗﻢ ﺗﻌﺮﻳﻔﺔ ﻣﺴﺒﻘﺎً ﻓﻰ اﻟﺠﺰء اﻟﺘﻌﺮﻳﻔﻰ ( ‪.‬‬
‫‪BEGIN‬‬
‫‪RAISE‬‬ ‫;‪EXCEPTION_NAME‬‬
‫;‪END‬‬
‫ﺛﺎﻟﺜﺎً ‪ :‬ﻋﻤﻞ ﻣﻌﺎﻟﺠﺔ واﺳﺘﺪراج ﻟﻪ ﻓﻰ اﻟﺠﺰء اﻷﺳﺘﺜﻨﺎءات ‪.‬‬
‫‪EXCEPTION‬‬
‫‪WHEN‬‬ ‫‪EXCEPTION_NAME‬‬ ‫‪THEN‬‬
‫‪CODES‬‬
‫;‪END‬‬
‫ﻣﺜﺎل ‪:‬‬

‫اﻟﻤﺜﺎل ﻳﻮﺿﺢ آﻴﻔﻴﺔ ﺗﻌﺮﻳﻒ وإﻧﺸﺎء وﻣﻌﺎﻟﺠﺔ ﺧﻄﺄ ﻣﻌﺮف ﻣﻦ اﻟﻤﺴﺘﺨﺪم ‪.‬‬
‫اﻟﺸﺮح ‪ :‬هﺬا اﻟﺒﻠﻮك ﻳﻘﻮم ﺑﺘﻌﺪﻳﻞ وﺻﻒ اﻷدارة وذﻟﻚ ﻣﻦ ﺧﻼل ﺟﻤﻠﺔ ‪UPDATE‬‬
‫وﻳﻄﻠﺐ ﻣﻦ اﻟﻤﺴﺘﺨﺪم اﻟﻮﺻﻒ اﻟﺠﺪﻳﺪ ورﻗﻢ اﻹدارة اﻟﻤﺮاد ﺗﻐﻴﺮ وﺻﻔﻬﺎ ﻓﺈذا أدﺧﻞ‬
‫اﻟﻤﺴﺘﺨﺪم رﻗﻢ ﻻ ﺗﻮﺟﺪ ﻟﻪ إدارة ﻳﻨﺸﺄ اﺳﺘﺜﻨﺎء اﺳﻤﻪ‬
‫) ‪ (W_INVALID_DEPARTEMENT‬وﻳﻢ اﺳﺘﺪراﺟﻪ وﻣﻌﺎﻟﺠﺘﻪ ﻓﻰ اﻟﺠﺰء اﻹﺳﺘﺜﻨﺎءات‬
‫آﻤﺎ ﻓﻰ اﻟﻤﺜﺎل ‪.‬‬
‫س ‪ :‬ﻣﺎذا ﻳﺤﺪث إذا ﻟﻢ ﻳﺘﻢ ﻣﻌﺎﻟﺠﺔ اﻹﺳﺘﺜﻨﺎء أو اﻟﺨﻄﺄ ؟‬
‫ج ‪ :‬ﻳﺨﺮج اﻟﺒﻠﻮك إﻟﻰ اﻟﺠﻬﺔ أو اﻟﺒﻠﻮك أو اﻟﺒﻴﺌﺔ اﻟﺘﻰ ﺗﺤﺘﻮﻳﻪ ﻓﺈذا آﺎن ﻣﻮﺟﻮد ﻓﻰ ﺑﻴﺌﺔ‬
‫‪ ISGLPLUS‬ﻳﺨﺮج ﻟﻬﺎ ﻣﺒﺎﺷﺮة ‪.‬‬
‫ﻓﺈذا آﺎن ﻣﻮﺟﻮد داﺧﻞ ﺑﻠﻮك ﺁﺧﺮ ﻳﺨﺮج إﻟﻰ هﺬا اﻟﺒﻠﻮك اﻟﺬى ﻳﺤﺘﻮﻳﻪ ﻓﺈذا آﺎن ﻓﻰ ﺑﻴﺌﺔ‬
‫‪ SGLPLUS‬ﻳﺨﺮج ﻟﻬﺎ ﻣﺒﺎﺷﺮة‬

‫اﺳﺘﺨﺪام ‪RAISE_APPLICATIONERROR‬‬
‫اﻟﺼﻴﻐﺔ اﻟﻌﺎﻣﺔ ‪:‬‬
 ‫ﻳﻤﻜﻦ اﺳﺘﺨﺪاﻣﻬﺎ ﻓﻰ اﻵﺗﻰ ‪:‬‬
‫‪ -‬ﺗﻌﺮﻳﻒ ﺧﻄﺄ أو اﺳﺘﺜﻨﺎء ﻣﻌﺮف ﻣﻦ اﻟﻤﺴﺘﺨﺪم وآﺬﻟﻚ وﺿﻊ رﺳﺎﻟﺔ اﻟﺨﻄﺄ اﻟﺨﺎﺻﺔ ﺑﻪ‬
‫‪.‬‬
‫ﻓﻰ ﺻﻴﻐﺔ اﻟﺠﻤﻠﺔ ‪:‬‬
‫‪ : ERROR_NUMBER‬اﻟﻤﺴﺘﺨﺪم ﻳﻀﻊ رﻗﻢ ﻣﻌﻴﻦ ﻟﻠﺨﻜﺄ اﻟﺬى ﻳﺮﻳﺪﻩ وﻳﺠﺐ أن ﻳﻜﻮن‬
‫ﻣﻦ ‪ 20000‬إﻟﻰ ‪. 20999‬‬
‫‪ : MESSAGE‬وهﻰ رﺳﺎﻟﺔ اﻟﺨﻄﺄ اﻟﻤﺮاد إﻇﻬﺎرﻩ ﻋﻨﺪ ﺣﺪوث اﻟﺨﻄﺄ وهﻰ ﻧﺺ أﻗﺼﻰ‬
‫ﻃﻮل ﻟﻪ ‪ 2048‬ﺑﺎﻳﺖ ‪.‬‬
‫‪ : TRUE/FALSE‬وهﻮ ﺟﺰء إﺧﺘﻴﺎرى وﻳﺤﺪد أﻣﺎ إذا آﺎن اﻟﺨﻄﺄ ﻳﺴﺘﺒﺪل ﻣﺎ ﺳﺒﻘﺔ ﻣﻦ‬
‫ﺧﻄﺄ أم ﻻ واﻟﻘﻴﻤﺔ ‪ DEFAELT‬ﻟﻪ ‪ FALSE‬أى ﻳﺴﺘﺒﺪل ﻣﺎ ﺳﺒﻘﺔ ﻣﻦ أﺧﻄﺎء ‪,‬‬
‫ﻣﻼﺣﻈﺎت ‪:‬‬
‫‪ -‬ﻳﻤﻜﻦ اﺳﺘﺨﺪاﻣﻬﺎ ﻓﻰ آﻼ ﻣﻦ اﻟﺠﺰء اﻟﺘﻨﻔﻴﺬى وﺟﺰء اﻷﺳﺘﺜﻨﺎءات ‪.‬‬
‫‪ -‬ﺗﻈﻬﺮ اﻟﺨﻄﺄ ﻣﺜﻞ أﺧﻄﺎء أوراآﻞ ﺗﻤﺎﻣﺎً ‪.‬‬
‫ﻣﺜﺎل ‪:‬‬

‫ﻓﻰ اﻟﻤﺜﺎل إذا ﻟﻢ ﻳﺠﺪ ﻣﺎ ﻳﺤﺬﻓﺔ ﺑﺠﻤﻠﺔ ‪ DELETE‬ﻳﻘﻮم ﺑﺈﻇﻬﺎر ﺧﻄﺄ رﻗﻢ ‪20202‬‬
‫ورﺳﺎﻟﺘﺔ هﺬا ﻣﺪﻳﺮ ﺧﻄﺄ وآﺬﻟﻚ ﻓﻰ اﻟﺠﺰء اﻷﺳﺘﺜﻨﺎءات ﻳﻘﻮم ﺑﻮﺿﻊ رﺳﺎﻟﺔ ورﻗﻢ اﻟﺨﻄﺄ‬
‫آﻤﺎ ﻓﻰ ﺟﻤﻠﺔ‬
‫‪RAISE_APPLICATION_ERROR‬‬

‫اﻣﺜﻠﺔ ﻋﻠﻰ اﻟﻔﺼﻞ‪:‬‬

‫اﻟﻤﺜﺎل اﻟﺘﺎﻟﻰ ﺗﻄﺒﻴﻖ ﻋﻠﻰ ﺟﻤﻠﺔ ‪ Pragma‬ودوال اﺻﻄﻴﺎد اﻻﺧﻄﺎء‪:‬‬
 ‫اﻟﻔﺼﻞ اﻟﺘﺎﺳﻊ‬

‫اﻹﺟﺮاءات ‪PROCEDVRES‬‬

‫اﻟﻮﺣﺪات اﻟﺒﺮﻣﺠﻴﺔ ‪SUP PROGRAMS‬‬

‫وهﻰ ﺗﺸﻤﻞ وﺣﺪات أو ﺑﺮاﻣﺞ ﻣﺤﻔﻮﻇﺔ داﺧﻞ اﻷوراآﻞ ﺗﻢ إﻧﺸﺄهﺎ ﻗﺒﻞ ذﻟﻚ ﻣﺜﻞ‬
‫اﻹﺟﺮاءات ‪ PROCEDURES‬واﻟﺪوال ‪ FUNCTIONS‬واﻹﺟﺮاء هﻰ ﻟﻌﻤﻞ ﻣﺠﻤﻮﻋﺔ ﻣﻦ‬
‫اﻟﻌﻤﻠﻴﺎت واﻹﺟﺮاءات ‪.‬‬
‫واﻟﺪاﻟﺔ هﻰ ﻟﺤﺴﺎب ﻗﻴﻤﺔ أو ﻋﻤﻠﻴﺔ ﺣﺴﺎﺑﻴﺔ ‪.‬‬
‫آﻤﺎ رأﻳﻨﺎ ﻣﺴﺒﻘﺎً ان اﻟﺒﻠﻮك ﻳﺘﻜﻮن ﻣﻦ ﻋﺪة أﺟﺰاء آﻤﺎ ﻓﻰ اﻟﺸﻜﻞ اﻟﺘﺎﻟﻰ‬

‫‪ o‬ﻣﻜﻮﻧﺎت اﻻﺟﺮاء ‪:‬‬

‫ﻓﻰ ‪ SUBPROGRAM‬ﻳﻘﻮم ﺑﺈﺳﺘﺒﺪال اﻟﺠﺰء ‪ DECLARE‬ﺑﺠﺰء ﺁﺧﺮ ﻣﻜﺎﻧﻪ هﻮ )‪(HEADER‬‬

‫أو )‪ (SPECIFICATION‬وهﻰ اﻟﺮأس او ﺗﻌﺮﻳﻒ اﻟﺒﺮﻧﺎﻣﺞ وﺑﻘﻴﺔ اﻟﺒﻠﻮك ﺗﺴﻤﻰ ‪. BODY‬‬
‫ﻳﺘﻢ ﻓﻰ اﻟﺠﺰء ‪ Header‬اﻷﺗﻰ ‪:‬‬
‫‪ -‬ﺗﺤﺪﻳﺪ ﻧﻮع اﻟﺒﺮﻧﺎﻣﺞ داﻟﺔ أم اﺟﺮاء ‪.‬‬
 ‫‪ -‬اﺳﻢ اﻟﺒﺮﻧﺎﻣﺞ ‪.‬‬
‫‪ -‬اﻟﻌﻮاﻣﻞ واﻟﻤﻌﺎﻣﻼت ﻟﻠﺮﺑﺮﻧﺎﻣﺞ ﻟﻮوﺟﺪت ‪.‬‬
‫‪ -‬ﻗﻴﻤﺔ اﻟﺮﺟﻮع )‪ (RETURN‬وذﻟﻚ ﻓﻰ اﻟﺪوال ﻓﻘﻂ ‪.‬‬
‫‪ -‬آﻠﻤﺔ ‪ AS / IS‬اﺳﺎﺳﻴﺔ وهﻰ ﺗﻔﺼﻞ ﺑﻴﻦ ﺗﻌﺮﻳﻒ اﻟﺒﺮﻧﺎﻣﺞ وآﻠﻤﺔ ‪BEGIN‬‬
‫اﻣﺎ ‪ BODY‬ﻓﻬﻮاﻟﺠﺰء اﻟﺘﻨﻔﻴﺬى هﻮ ﻣﺎﺑﻴﻦ ‪ BEGIN-END‬وﻳﺤﺘﻮى ﻋﻠﻰ اﻷآﻮاد اﻟﻤﺮاد‬
‫ﺗﻨﻔﻴﺬهﺎ اﻣﺎ ﺟﺰء اﻷﺳﺘﺜﻨﺎءات وﻳﺘﻢ ﻓﻴﻪ اﺳﺘﺪراج وﻣﻌﺎﻟﺠﺔ اﻷﺧﻄﺎء ‪.‬‬
‫س‪ :‬ﻣﺎ هﻮ اﻹﺟﺮاء ‪: What Is PROCEDURE‬‬
‫هﻮ ﻧﻮع ﻣﻦ ‪ Subprogram‬ﻳﻘﻮم ﺑﺘﻨﻔﻴﺬ ﻋﻤﻠﻴﺔ ﻣﻌﻴﻨﺔ وﻳﻤﻜﻦ ﺗﺨﺰﻳﻨﻪ ﻓﻰ ﻗﺎﻋﺪة اﻟﺒﻴﺎﻧﺎت‬
‫آﺠﺰء ﻣﻦ اﻟﻘﺎﻋﺪة ‪ SCHEMA objects‬ﻟﻜﻰ ﻳﺘﻢ اﺳﺘﺪﻋﺎﺋﻪ ﻋﻨﺪ اﻟﺘﻨﻔﻴﺬ اﻟﻤﺘﻜﺮر‪.‬‬

‫اﻟﺼﻴﻐﻴﺔ اﻟﻌﺎﻣﺔ ﻟﻺﺟﺮاء ‪:‬‬

‫ﻣﺴﺘﺨﺪم آﻠﻤﺔ ‪ OR REPLACE‬ﻹﺳﺘﺒﺪال اﻟﻘﺪﻳﻢ إذا آﺎن ﻣﻮﺟﻮداً ﻗﺒﻞ ذﻟﻚ ‪.‬‬
‫‪ -‬آﻮد ‪ PL/SQL‬ﻳﺒﺪأ ﻣﻦ آﻠﻤﺔ ‪ BEGIN‬أو ﻳﺘﻢ ﺗﻌﺮﻳﻒ ﻣﺘﻐﻴﺮات داﺧﻞ اﻹﺟﺮاء وذﻟﻚ‬
‫ﻓﻰ اﻟﺠﺰء ﺑﻴﻦ ‪ IS/AS‬وآﻠﻤﺔ ‪ BEGIN‬وﻳﺘﻢ اﺳﺘﺨﺪاﻣﻬﺎ ﻓﻘﻂ داﺧﻞ اﻹﺟﺮاء ﻗﺒﻞ‬
‫آﻠﻤﺔ ‪ END‬اﻟﺨﺎﺻﺔ ﺑﺎﻹﺟﺮاء ‪.‬‬
‫‪ -‬ﻳﻤﻜﻦ ﻟﻺﺟﺮاء أﺧﺬ ﻣﻌﺎﻣﻞ)‪ (Parameter‬أو ﻋﺎﻣﻞ ﻣﻦ ﺧﺎرج اﻷﺟﺮاء وأﻧﻮاع‬
‫اﻟﻤﻌﺎﻣﻼت ﺛﻼﺛﺔ ) ‪( IN OUT , OUT , IN‬‬
‫‪ -‬ﻋﺪم ﺗﺤﺪﻳﺪ ﻣﺴﺎﺣﺔ أو ﺳﻌﺔ ﻧﻮع اﻟﺒﻴﺎﻧﺎت ﻓﻰ اﻟﻤﻌﺎﻣﻼت ﻳﺬآﺮ ﻓﻘﻂ ﻧﻮع اﻟﺒﻴﺎﻧﺎت‬
‫ﺳﻮاء ‪ Number‬او ‪ Varchar2‬ﻓﻘﻂ ﺑﺪون ﻣﺴﺎﺣﺔ ‪.‬‬
‫أﻧﻮاع اﻟﻤﻌﺎﻣﻼت ‪:‬‬
‫‪ -1‬اﻟﻨﻮع ‪ : IN‬وهﻮ اﻟﻨﻮع اﻻﻓﺘﺮاﺿﻰ‪ DEFAULT‬ﻟﻠﻤﻌﺎﻣﻞ وﻳﺘﻢ ﻣﻦ ﺧﻼل ﺗﻤﺮﻳﺮ ﻗﻴﻤـﺔ‬
‫ﻣــﻦ ﺧــﺎرج اﻹﺟــﺮاء إﻟــﻰ اﻹﺟــﺮاء ﻷﺳــﺘﺨﺪام هــﺬﻩ اﻟﻘﻴﻤــﺔ ‪ .‬ﻻﺣــﻆ ﻻ ﻳﻤﻜــﻦ ﺗﻐﻴﻴــﺮ‬
‫اﻟﻤﻌﺎﻣﻞ ﻣﻦ اﻟﻨـﻮع ‪ IN‬أى ﻻ ﻳﻤﻜـﻦ اﺳـﺘﺨﺪاﻣﻪ آﻬـﺪف ﻣﺜـﻞ ﻋـﺪا د ﺟﻤﻠـﺔ ‪(FOR-‬‬
‫)‪ LOOP‬ﺗﻤﺎﻣﺎً ‪.‬‬
‫‪ -2‬اﻟﻨﻮع ‪ : OUT‬وﻳﺘﻢ ﻣﻦ ﺧﻼﻟﻪ ﺗﻤﺮﻳﺮ اﻟﻘﻴﻢ ﻟﻠﻤﺘﻐﻴﺮ ﻣﻦ داﺧﻞ اﻹﺟﺮاء إﻟﻰ ﺧﺎرج‬
‫اﻹﺟﺮاء وﻻ ﻳﺄﺧﺬ ﻗﻴﻤﺔ ﻗﺒﻞ أﺳﺘﺨﺪام اﻹﺟﺮاء وﻻ ﻳﺄﺧﺬ ﻗﻴﻤﺔ ﻗﺒﻞ اﺳﺘﺨﺪام اﻹﺟﺮاء‬
‫وإﻻ ﻳﻨﺘﺞ ﺧﻄﺄ وﻳﺴﺘﺨﺪم ﻓﻰ أرﺟﺎع ﻗﻴﻤﺔ ﻳﺤﺴﺒﻬﺎ اﻹﺟﺮاء داﺧﻠﻴﺎً ‪.‬‬
‫‪ -3‬اﻟﻨﻮع ‪ IN OUT‬وهﻮ ﻳﻤﺮر اﻟﻘﻴﻢ ﻣﻦ داﺧﻞ وﺧﺎرج اﻹﺟﺮاء واﻟﻌﻜﺲ ﻳﻤﻜﻦ أن ﻳﺄﺧﺬ‬
‫ﻗﻴﻤﺔ ﻗﺒﻞ اﺳﺘﺨﺪام اﻹﺟﺮاء ‪.‬‬

‫ﻣﻘﺎرﻧﻪ ﺑﻴﻦ اﻷﻧﻮاع اﻟﺜﻼﺛﺔ ‪:‬‬ ‫•‬

 ‫ﻣﺜﺎل ﻋﻠﻰ اﻧﺸﺎء اﻻﺟﺮاء ﺑﺪون ﻣﻌﺎﻣﻼت‪:‬‬

‫واﻟﻜﻮد اﻟﺘﺎﻟﻰ ﻳﻮﺿﺢ آﻴﻔﻴﺔ ﻧﺪاء واﺳﺘﺨﺪام اﻻﺟﺮاء داﺧﻞ آﻮد ‪PL/SQL‬‬
 ‫أﻣﺜﻠﺔ ‪ :‬ﻋﻠﻰ اﻟﻤﻌﺎﻣﻞ ﻣﻦ اﻟﻨﻮع ‪IN‬‬
‫ﻣﺜﺎل)‪:(1‬‬
‫ﻳﻘﻮم ﺑﺄﺧﺬ ﻗﻴﻤﺔ ﻣﻦ اﻟﻤﺴﺘﺨﺪم ﻓﻰ ﻣﺘﻐﻴﺮ ﻣﻦ اﻟﻨﻮع‪ IN‬وﻋﺮﺿﻬﺎ ﻋﻠﻰ اﻟﺸﺎﺷﺔ ‪:‬‬

‫ﻣﺜﺎل)‪:(2‬‬

‫ﻓﻰ اﻟﻤﺜﺎل اﻟﺴﺎﺑﻖ ﻳﺘﻢ ﺗﻌﺮﻳﻒ ﻣﻌﺎﻣﻞ ‪ P_ID‬ﻳﺄﺧﺬ ﻧﻔﺲ ﺑﻨﻴﺔ وهﻴﻜﻞ اﻟﻌﻤﻮد‬
‫‪ Employee_id‬ﻓﻰ ﺟﺪول ‪ EMPLOYEES‬ﻣﻦ اﻟﻨﻮع ‪. IN‬‬
‫ﻓﻰ اﻟﺠﺰء اﻟﺘﻨﻔﻴﺬى ﻳﻘﻮم ﺑﻌﻤﻠﻴﺔ ﺗﻌﺪﻳﻞ )‪ (UPDATE‬ﻓﻰ ﺟﺪول ‪ EMPLOYEES‬وﻳﻀﻊ‬
‫اﻟﻤﺮﺗﺐ )‪ (SALAY‬ﺑﺰﻳﺎدة ‪ %10‬ﻋﻠﻰ اﻟﻤﺮﺗﺐ اﻟﻘﺪﻳﻢ وذﻟﻚ ﻟﻠﻤﻮﻇﻒ رﻗﻤﻪ ﻳﺴﺎوى‬
‫اﻟﻤﻌﺎﻣﻞ ‪ P_ID‬اﻟﺬى ﺳﻮف ﻳﺘﻢ إدﺧﺎﻟﻪ ﻋﻨﺪ اﺳﺘﺨﺪام هﺬا اﻹﺟﺮاء ‪.‬‬

‫* ﻣﺜﺎل ﻹﺳﺘﺪﻋﺎء اﻹﺟﺮاء اﻟﺴﺎﺑﻖ ‪.‬‬

‫; )‪RAISE_SALARY (176‬‬ ‫ﺳﻴﻘﻮم ﺑﺈﺳﺘﺪﻋﺎء هﺬ‬
‫اﻹﺟﺮاء وﻳﺪﺧﻞ ﻗﻴﻤﺔ ‪ P_ID‬ﺗﺴﺎوى ‪ 176‬ﻟﻴﻌﻤﻞ ﺑﻬﺎ هﺬا اﻹﺟﺮاء ‪.‬‬
‫* ﻳﻤﻜﻦ أن ﻧﺴﺘﺪﻋﻰ اﻹﺟﺮاء ﻣﻦ ﺧﺎرج آﻮد ‪ PL/SQL‬ﺑﺠﻤﻠﺔ ‪. EXECUTE‬‬
‫; )‪EXECUTE RAISE_SALARY (176‬‬

‫ﻣﺜﺎل ﻋﻠﻰ اﻟﻤﻌﺎﻣﻞ ﻣﻦ اﻟﻨﻮع ‪: OUT‬‬

 ‫ﻓﻰ اﻟﻤﺜﺎل واﻟﺸﻜﻞ ﻳﻘﻮم ﺑﺄﺧﺬ رﻗﻢ اﻟﻤﻮﻇﻒ ) ﻣﻌﺎﻣﻞ ﻣﻦ اﻟﻨﻮع ‪ ( IN‬وﻳﺮﺟﻊ ﺑﺎﺳﻢ‬
‫اﻟﻤﻮﻇﻒ ) ﻣﻌﺎﻣﻞ ﻣﻦ اﻟﻨﻮع ‪ ( OUT‬وﻣﺮﺗﺐ اﻟﻤﻮﻇﻒ ) ﻣﻌﺎﻣﻞ ﻣﻦ اﻟﻨﻮع ‪ ( OUT‬وﻋﻤﻮﻟﺔ‬
‫اﻟﻤﻮﻇﻒ ﻓﻰ ) ﻣﻌﺎﻣﻞ ﻣﻦ اﻟﻨﻮع ‪. ( OUT‬‬
‫اﻟﻜﻮد آﻤﺎ ﻳﻠﻰ ‪:‬‬

‫ﻻﺣﻆ هﻨﺎ اﻟﻜﻮد ﻳﺴﺘﺨﺪ اﻟﻤﻌﺎﻣﻞ ﻣﻦ اﻟﻨﻮع ‪ IN‬آﺄﻧﻪ ﻟﻪ ﻗﻴﻤﺔ ﻳﻤﻜﻦ أن ﺗﺴﺘﺨﺪم ﻓﻰ‬
‫اﻟﻤﻘﺎرﻧﺔ ﻣﺜﻼ وﻻﺣﻆ ﻻ ﻳﻤﻜﻦ ان ﻳﻀﻊ ﻓﻰ اﻟﻤﻌﺎﻣﻞ ﻣﻦ اﻟﻨﻮع ‪ IN‬أى ﻗﻴﻢ ‪.‬‬
‫وذﻟﻚ ﻋﻜﺲ اﻟﻤﻌﺎﻣﻞ ﻣﻦ اﻟﻨﻮع ‪ OUT‬ﻳﺴﺘﺨﺪم ﻓﻰ اﺳﺘﻘﺒﺎل اﻟﻘﻴﻢ وﻋﺮﺿﻬﺎ وآﻤﺎ ﻓﻰ‬
‫اﻟﻤﺜﺎل ‪.‬‬
 ‫آﻴﻔﻴﺔ إﺳﺘﺪﻋﺎء إﺟﺮاء ﻳﺤﺘﻮى ﻋﻠﻰ ﻣﻌﺎﻣﻼت ‪: OUT‬‬
‫داﺧﻞ آﻮد ‪PL/SQL‬‬
‫‪ -‬ﻳﺘﻢ ﺗﻌﺮﻳﻒ ﻣﺘﻐﻴﺮات ﻟﻬﺎ ﻧﻔﺲ ﻧﻮع اﻟﺒﻴﺎﻧﺎت ﻟﻠﻤﻌﺎﻣﻼت ‪ OUT‬ﻓﻰ اﻟﺠﺰء اﻟﺘﻌﺮﻳﻔﻰ ‪.‬‬
‫‪ -‬ﺛﻢ ﻳﺘﻢ اﺳﺘﺪﻋﺎء اﻹﺟﺮاء ﻣﺘﻀﻤﻨﺎً هﺬﻩ اﻟﻤﻌﺎﻣﻼت ‪.‬‬
‫‪Declare‬‬
‫‪V_NAME‬‬ ‫; )‪VARCHAR2(30‬‬
‫‪V_SAL‬‬ ‫; ‪NUMBER‬‬
‫‪V_CEMN‬‬ ‫; ‪NUMBER‬‬
‫‪BEGIN‬‬
‫;)‪QUERY_EMP(171,V_name,V_sal,V_comm‬‬
‫;)‪DBMS_OUTPUT.PUT_LINE(V_NAME‬‬
‫;)‪DBMS_OUTPUT.PUT_LINE(V_SAL‬‬
‫;)‪DBMS_OUTPUT.PUT_LINE(V_COMM‬‬
‫;‪END‬‬
‫ﺧﺎرج اﻟﻜﻮد ‪: PL/SQL‬‬
‫‪ -‬ﻳﺘﻢ ﺗﻌﺮﻳﻒ ﻣﺘﻐﻴﺮ ﻣﻦ اﻟﻨﻮع ‪ BIND‬ﻟﻜﻞ ﻣﻌﺎﻣﻞ ﻋﻠﻰ ﺣﺪى ‪.‬‬
‫‪ -‬ﻳﺘﻢ اﺳﺘﺪﻋﺎء اﻹﺟﺮاء آﻤﺎ ﻳﻠﻰ ‪:‬‬
‫‪VARIALE‬‬ ‫‪G_NAME‬‬ ‫)‪VARCHAR2 (30‬‬
‫‪VARIALE G_SAL‬‬ ‫‪NUMBER‬‬
‫‪VARIALE G_COMM NUMBER‬‬
‫‪EXECUTE‬‬ ‫;)‪QUERY_EMP(171,:G_NAME,:G_SAL, :G_COMM‬‬
‫;‪PRINT G_NAME‬‬
‫‪PRINT G_SAL‬‬
‫‪PRINT G_COMM‬‬
‫ﻻﺣﻆ هﻨﺎ ﻋﺪم وﺟﻮد ﻗﻴﻢ إﺑﺘﺪاﺋﻴﺔ)اﻓﺘﺮاﺿﻴﺔ( ﻓﻰ ﺗﻌﺮﻳﻒ هﺬﻩ اﻟﻤﺘﻐﻴﺮات اﻟﺘﻰ اﺳﺘﺨﺪم‬
‫ﻓﻰ اﻟﻤﻌﺎﻣﻼت ‪. OUT‬‬

‫ﻣﺜﺎل ﻋﻠﻰ اﺳﺘﺨﺪام اﻟﻤﻌﺎﻣﻞ ‪: IN OUT‬‬

‫وﻳﺘﻢ ﻓﻴﻪ إرﺳﺎل وإﺳﺘﻘﺒﺎل اﻟﻘﻴﻢ ﻣﻦ داﺧﻞ وﺧﺎرج اﻹﺟﺮاء ﻓﻰ اﻟﻤﺜﺎل اﻟﺴﺎﺑﻖ ﻳﺘﻢ‬
‫اﺳﺘﻘﺒﺎل اﻟﻘﻴﻢ ﻟﻠﻤﻌﺎﻣﻞ آﺄﻧﻪ ﻣﻌﺎﻣﻞ ‪ IN‬وﺑﻌﺪ اﻟﻌﻤﻠﻴﺎت ﻳﺮﺟﻊ اﻟﻘﻴﻢ اﻟﺠﺪﻳﺪة ﻣﻦ داﺧﻞ‬
‫اﻹﺟﺮاء ﻓﻰ ﻧﻔﺲ اﻟﻤﻌﺎﻣﻞ آﺄﻧﻪ ‪. OUT‬‬
‫اﺳﺘﺪﻋﺎء إﺟﺮاء ﺑﻪ ﻣﻌﺎﻣﻞ ‪. IN OUT‬‬
‫اﻟﻤﺜﺎل ﻳﻮﺿﺢ ﻣﺘﻐﻴﺮ ﻳﺘﻢ وﺿﻊ ﻗﻴﻤﺔ ﻟﺘﺮﺳﻞ إﻟﻰ داﺧﻞ اﻹﺟﺮاء آﺄﻧﻪ ﻣﻌﺎﻣﻞ ﻣﻦ اﻟﻨﻮع ‪IN‬‬
‫وﻳﺘﻢ ﺑﻌﺪ إﺳﺘﺪﻋﺎء اﻹﺟﺮاء ﻋﺮض اﻟﻤﺘﻐﻴﺮ ﺛﺎﻧﻴﺔ ﻟﻴﻌﺮض هﺬﻩ اﻟﻘﻴﻤﺔ اﻟﺠﺪﻳﺪة آﺄﻧﻪ ﻣﻌﺎﻣﻞ‬
‫ﻣﻦ اﻟﻨﻮع ‪. OUT‬‬

‫ﻃﺮق ﺗﻤﺮﻳﺮ اﻟﻤﻌﺎﻣﻼت‬

‫‪ -‬ﺣﺴﺐ اﻟﻤﻮﻗﻊ ‪ :‬وﻳﺘﻢ ﻋﺮض وﺗﺮﺗﻴﺐ ﻗﻴﻢ اﻟﻤﻌﺎﻣﻼت ﺣﺴﺐ ﺗﺮﺗﻴﺒﻬﺎ ﻓﻰ ﺟﻤﻠﺔ إﻧﺸﺎء‬
‫اﻹﺟﺮاء )‪. (CREATE‬‬
‫‪ -‬ﺣﺴﺐ اﻷﺳﻢ ‪ :‬وﻳﺘﻢ ذآﺮ اﺳﻢ اﻟﻤﻌﺎﻣﻞ وﺑﻌﺪﻩ اﻟﻘﻴﻤﺔ اﻟﺘﻰ ﺳﻮف ﻳﺄﺧﺬهﺎ ‪.‬‬
‫‪ -‬اﻹﺛﻨﻴﻦ ﻣﻌﺎً ‪ :‬ﻋﺮض ﺑﻌﺾ اﻟﻘﻴﻢ ﺣﺴﺐ اﻟﻤﻮﻗﻊ واﻟﺒﻌﺾ اﻵﺧﺮ ﺣﺴﺐ اﻷﺳﻢ ‪.‬‬
‫ﻣﺜﺎل ‪ :‬ﻋﻠﻰ إﺳﺘﺨﺪام ﺧﺎﺻﻴﺔ ‪. DELAUT‬‬

‫ﻣﻦ اﻟﻤﻤﻜﻦ وﺿﻊ ﻗﻴﻤﺔ إﺑﺘﺪاﺋﻴﺔ ﻟﻠﻤﺘﻐﻴﺮات ﻣﻦ اﻟﻨﻮع ‪ IN‬ﺑﺈﺳﺘﺨﺪام ‪ DEFAULT‬أو وﺿﻊ‬
‫ﻗﻴﻢ ﻟﻠﻤﻌﺎﻣﻼت ﺑﺎﻟﺮﻗﻢ ﻣﻦ أﻧﻬﺎ ﻟﻬﺎ ﻗﻴﻢ إﺑﺘﺪاﺋﻴﺔ ﻟﺬﻟﻚ ﻳﻤﻜﻦ إﺳﺘﺪﻋﺎء اﻹﺟﺮاء ﻧﻔﺴﻪ ﺑﻌﺪة‬
‫أﺷﻜﺎل ﻟﻠﻤﻌﺎﻣﻼت ‪.‬‬
‫ﻓﻰ اﻟﻤﺜﺎل اﻟﺴﺎﺑﻖ ﻳﻤﻜﻦ أن ﻳﻨﺎدى ﻣﺜﻞ ‪.‬‬
‫ﻓﻰ اﻟﻄﺮﻳﻘﺔ اﻷوﻟﻰ ﻟﻺﺳﺘﺪﻋﺎء ﻳﺘﻢ ﻧﺪاء اﻹﺟﺮاء ﺑﺪون ﻣﻌﺎﻣﻼت ﻟﻮﺟﻮد ﻗﻴﻢ إﺑﺘﺪاﺋﻴﺔ‬ ‫‪-‬‬
‫‪. DEFAULT‬‬
‫ﻓﻰ اﻟﻄﺮﻳﻘﺔ اﻟﺜﺎﻧﻴﺔ ﻳﺘﻢ ﻧﺪاء اﻹﺟﺮاء ﺣﺴﺐ اﻟﻤﻮﻗﻊ ﻟﻠﻤﻌﺎﻣﻼت ‪.‬‬ ‫‪-‬‬
‫اﻟﻄﺮﻳﻘﺔ اﻟﺜﺎﻟﺜﺔ ﻳﺴﺘﺪﻋﻰ اﻹﺟﺮاء ﺣﺴﺐ اﻻﺳﻢ ‪.‬‬ ‫‪-‬‬
‫اﻟﻄﺮﻳﻘﺔ اﻟﺮاﺑﻌﺔ ﻳﺴﺘﺪﻋﻰ اﻹﺟﺮاء ﻣﻌﺎً ﺗﺠﻤﻴﻌﺔ ﻟﻼﺳﻢ واﻟﻤﻮﻗﻊ ﻣﻌﺎً ‪.‬‬ ‫‪-‬‬
 ‫‪DECLARE SUSBPROGRAM‬‬ ‫ﺗﻌﺮﻳﻒ ﺑﺮﻧﺎﻣﺞ داﺧﻞ إﺟﺮاء‬

‫ﻣﻦ اﻟﻤﺜﺎل ﻳﻤﻜﻦ أن ﻳﺘﻢ ﻋﻤﻞ إﺟﺮاء داﺧﻠﻰ داﺧﻞ إﺟﺮاء وﻳﺘﻢ إﺳﺘﺪﻋﺎﺋﻪ داﺧﻞ اﻹﺟﺮاء‬
‫اﻟﺨﺎرﺟﻰ ﻓﻘﻂ ﻓﻔﻰ اﻟﻤﺜﺎل ﺗﻢ ﻋﻤﻞ إﺟﺮاء ﺧﺎرﺟﻰ ‪ leave_emp2‬وﺗﻢ ﻋﻤﻞ داﺧﻞ ﺟﺰء‬
‫اﻟﺘﻌﺮﻳﻒ اﻟﺨﺎص ﺑﻪ ) ﺑﻴﻦ ‪ ، is‬آﻠﻤﺔ ‪ ( BEGIN‬إﺟﺮاء داﺧﻠﻰ ﻳﺴﻤﻰ ‪ LOG_EXEC‬واﻟﺬى‬
‫ﺗﻢ إﺳﺘﺪﻋﺎﺋﻪ داﺧﻞ اﻹﺟﺮاء اﻟﺨﺎرﺟﻰ ‪ LEAVE_EMP2‬آﻤﺎ ﻓﻰ اﻟﻤﺜﺎل ‪.‬‬
‫ﻻﺣﻆ ‪ :‬ﻻ ﻳﻤﻜﻦ إﺳﺘﺪﻋﺎء اﻹﺟﺮاء اﻟﺪاﺧﻠﻰ ﺳﻮى داﺧﻞ اﻹﺟﺮاء اﻟﺨﺎرﺟﻰ اﻟﺬى ﺗﻢ ﻓﻴﻪ‬
‫اﻟﺘﻌﺮﻳﻒ وآﺘﺎﺑﺔ اﻹﺟﺮاء اﻟﺪاﺧﻠﻰ داﺧﻠﺔ ﻟﺬﻟﻚ ﻻ ﻳﻤﻜﻦ أن ﺗﺴﺘﺪﻋﻰ اﻹﺟﺮاء ‪LOG_EXEC‬‬
‫ﻓﻰ إﺟﺮاء ﺁﺧﺮ أو أى ﺑﻠﻮك ﺁﺧﺮ ﻏﻴﺮ اﻹﺟﺮاء ‪. LEAVE_EMP2‬‬
‫إﺳﺘﺪﻋﺎء إﺟﺮاء ﻣﻦ إﺟﺮاء ﺁﺧﺮ ‪:‬‬

‫ﻓﻰ اﻟﻤﺜﺎل ﻳﺘﻢ ﻧﺪاء اﻹﺟﺮاء ‪ RAISA_SALARY‬وذﻟﻚ داﺧﻞ اﻹﺟﺮاء ‪. PROCESS_EMPS‬‬

‫س ‪ :‬ﻣﺎذا ﻳﺤﺪث إذا ﺣﺪث ﺧﻄﺄ أو ‪ EXCEPTION‬ﻓﻰ اﻹﺟﺮاء اﻟﺪاﺧﻠﻰ ؟‬
‫ج ‪ :‬إذا آﺎن ﻟﻪ ﻣﻌﺎﻟﺠﺔ ﻓﻰ اﻹﺟﺮاء اﻟﺪاﺧﻠﻰ ﻳﺘﻢ ﻣﻌﺎﻟﺠﺘﻪ واﻟﺨﺮوج إﻟﻰ اﻹﺟﺮاء اﻟﺨﺎرﺟﻰ‬
‫وإذا آﺎن ﻟﻴﺲ ﻟﻪ ﻣﻌﺎﻟﺠﺔ ﻳﺘﻮﻗﻒ اﻟﻜﻮد ﻋﻨﺪ هﺬﻩ اﻟﻨﻘﻄﺔ ﻓﻰ اﻹﺟﺮاء اﻟﺪاﺧﻠﻰ وﻳﺨﺮج‬
‫إﻟﻰ اﻹﺟﺮاء اﻟﺨﺎرﺟﻰ وذﻟﻚ آﻤﺎ ﻓﻰ اﻟﺸﻜﻞ اﻟﺘﺎﻟﻰ ‪.‬‬
 ‫ﺣﺬف إﺟﺮاء ‪:‬‬
‫;‪DROP PROCEDURE PROCEDUR_NAME‬‬ ‫اﻟﺼﻴﻐﺔ اﻟﻌﺎﻣﺔ ‪:‬‬
‫;‪DROP PROCEDURE RAIS_SALARY‬‬ ‫ﻣﺜﺎل ‪:‬‬
‫اﻣﺜﻠﺔ ﻋﻠﻰ اﻻﺟﺮاءات‪:‬‬

‫ﻣﺜﺎل‪ :‬ﻳﻘﻮم اﻻﺟﺮاء اﻟﺘﺎﻟﻰ ﺑﻌﺮض اﺳﻤﺎء اﻟﻤﻮﻇﻔﻴﻦ ﻓﻰ ادارة ﻣﻦ ﻋﻴﻨﺔ ﺗﺪﺧﻞ ﻣﻦ‬
‫اﻟﻤﺴﺘﺨﺪم‪:‬‬

‫اﺳﺘﺨﺪام اﻻﺟﺮاء اﻟﺴﺎﺑﻖ‪:‬‬

‫ﻣﺜﺎل ‪ :‬اﺟﺮاء ﻳﻮﺿﺢ اﺳﺘﺨﺪام ﻣﻌﺎﻣﻼت ﻣﻦ اﻟﻨﻮع ‪ IN‬واﻟﻨﻮع ‪:OUT‬‬

‫آﻴﻔﻴﺔ اﺳﺘﺪﻋﺎﺋﻪ ‪:‬‬

 ‫اﻟﻔﺼﻞ اﻟﻌﺎﺷﺮ‬

‫إﻧﺸﺎء اﻟﺪوال ‪CREATING FUNCETION‬‬

‫س ‪ :‬ﻣﺎ هﻰ اﻟﺪوال ﻓﻰ ‪ PL/SQL‬؟‬

‫ج ‪ :‬هﻰ ﺑﺮﻧﺎﻣﺞ ‪ SUPPROGRAM‬ﻟﻪ اﺳﻢ وﻳﺮﺟﻊ ﺑﻘﻴﻤﺔ ‪.‬‬
‫‪ -‬واﻟﺪاﻟﺔ ﻳﺘﻢ ﺣﻔﻈﻬﺎ ﻓﻰ ﻗﺎﻋﺪة اﻟﺒﻴﺎﻧﺎت ﻣﺜﻞ )‪ (SCHEMA OBJECT‬ﻻﺳﺘﺪﻋﺎﺋﻪ ﻋﻨﺪ‬
‫اﻟﻄﻠﺐ ‪.‬‬
‫‪ -‬وﺗﻄﻠﺐ آﺠﺰء ﻣﻦ ﺗﻌﺒﻴﺮ أو ﻋﻤﻠﻴﺔ ”‪. “expression‬‬
‫‪ -‬وﻳﻤﻜﻦ ﻟﻬﺎ أن ﺗﺄﺧﺪ ﻣﻌﺎﻣﻼت ”‪. “parameters‬‬
‫ﻋﺎﻣﺔ ﻳﺘﻢ إﺳﺘﺨﺪام اﻟﺪوال ﻟﺤﺴﺎب ﻗﻴﻤﺔ وهﻰ ﻗﺮﻳﺒﺔ ﻓﻰ اﻟﻬﻴﻜﻞ وﻃﺮﻳﻘﺔ اﻟﺘﺤﺮﻳﺮ‬
‫ﻣﻦ آﻮد ﺷﻜﻞ اﻹﺟﺮاء )‪ (procedure‬وﻳﺠﺐ أن ﺗﺮﺟﻊ اﻟﺪاﻟﺔ ﺑﻘﻴﻤﺔ واﺣﺪة وﺑﻌﻜﺲ‬
‫اﻹﺟﺮاء ﻣﻤﻜﻦ أن ﻳﺮﺟﻊ أآﺜﺮ ﻣﻦ ﻗﻴﻤﺔ أوﻻ‪ .‬ﻟﻠﺪاﻟﺔ ﺟﺰء رأس ”‪ “header‬وﺟﺰء ﺗﻌﺮﻳﻔﻰ‬
‫وﺟﺰء ﺗﻨﻔﻴﺬى وﺟﺰء ﺗﻨﻔﻴﺬى وهﻮ إﺧﺘﻴﺎرى وﻳﺘﻢ وﺿﻊ آﻠﻤﺔ ‪ return‬ﻓﻰ ﺟﺰء اﻟﺮأس‬
‫‪ header‬وآﺬﻟﻚ ﻓﻰ اﻟﺠﺰء اﻟﺘﻨﻔﻴﺬى ﻣﺮة واﺣﺪة ﻋﻠﻰ اﻷﻗﻞ ‪.‬‬
‫واﻟﺪوال اﻟﻤﺤﻔﻮﻇﺔ ﻓﻰ ﻗﺎﻋﺪة اﻟﺒﻴﺎﻧﺎت ﺗﺴﻤﻰ ‪. stored function‬‬
‫ﻳﻤﻜﻦ ﻧﺪاء اﻟﺪوال ﻣﻦ ﺟﻤﻠﺔ ‪ SQL‬وآﺬﻟﻚ ﻣﻦ ‪ PL/SQL‬ﺑﺎﻟﻄﺒﻊ ﺑﻌﻜﺲ اﻹﺟﺮاءات اﻟﺘﻰ‬
‫ﻳﺘﻢ اﻟﻨﺪاء ﻟﻬﺎ ﻣﻦ داﺧﻞ ‪ PL/SQL‬ﻓﻘﻂ ‪.‬‬
‫اﻟﺼﻴﻐﺔ اﻟﻌﺎﻣﺔ ﻟﺒﻨﺎء اﻟﺪوال ‪:‬‬

‫ﻻﺣﻆ أن آﻮد اﻟﺪاﻟﺔ ﻳﺠﺐ أن ﻳﺤﺘﻮى ﻓﻰ اﻟﺠﺰء اﻟﺘﻨﻔﻴﺬى ﻋﻠﻰ ﺟﻤﻠﺔ ‪ RETURN‬واﺣﺪة‬
‫ﻋﻠﻰ اﻷﻗﻞ ﻣﻦ ﺧﻼل اﻟﺼﻴﻐﺔ ﻧﻼﺣﻆ أن ‪:‬‬
‫‪ -‬ﺟﻤﻠﺔ ‪ CREATE FUNCTION‬وهﻰ اﻟﺘﻰ ﺗﻨﺸﺄ اﻟﺪاﻟﺔ ‪.‬‬
‫‪ FUNCTION_NAME -‬اﺳﻢ اﻟﺪاﻟﺔ اﻟﺘﻰ ﺳﻮف ﻳﺘﻢ ﺑﻪ اﻟﻨﺪاء ﻋﻠﻴﻬﺎ ) ﻻﺣﻆ أن‬
‫هﺬا اﻻﺳﻢ ﻳﺠﺐ أن ﻳﻜﻮن ‪. ( UNIQUE‬‬
‫‪ :PARAMETERS -‬اﻟﻤﻌﺎﻣﻼت اﻟﺘﻰ ﺳﻮف ﺗﺮﺳﻞ أو ﺗﻤﺮر إﻟﻰ اﻟﺪاﻟﺔ وهﺬﻩ‬
‫اﻟﺪاﻟﺔ ﺗﺄﺧﺪ ]‪ [MODE‬ﻓﻘﻂ ﻣﻌﺎﻣﻼت ﻣﻦ اﻟﻨﻮع ‪ IN‬ﻓﻘﻂ وﻻ ﻳﺴﻤﺢ ﺑﻐﻴﺮ هﺬا‬
‫اﻟﻨﻮع ﻟﺬا ﻻ ﺗﻜﺘﺐ آﻠﻤﺔ ‪ IN‬ﻓﻰ ﺗﻌﺮﻳﻒ اﻟﻤﻌﺎﻣﻞ ‪.‬‬
‫‪ RETURN DATATYPE -‬وهﻰ ﺗﺤﺮر ﻣﺎذا ﺳﺘﺮﺟﻊ اﻟﺪاﻟﺔ ﻣﻦ ﺣﻴﺚ ﻧﻮع‬
‫اﻟﺒﻴﺎﻧﺎت ﻻﺣﻆ ﻋﺪم وﺟﻮد ﺳﻌﺔ أو ﻣﺴﺎﺣﺔ ﻧﻮع اﻟﺒﻴﺎﻧﺎت ‪.‬‬
‫‪ : PL/SQL BLOCK -‬آﻮد ‪ PL/SQL‬اﻟﺬى ﺳﻮف ﻳﺘﻢ ﺗﻨﻔﻴﺬﻩ ‪.‬‬

‫* ﻣﺮاﺣﻞ إ ﻧﺸﺎء اﻟﺪاﻟﺔ ‪:‬‬

 ‫اﻟﺸﻜﻞ ﻳﻮﺿﺢ ﻣﺮاﺣﻞ إﻧﺸﺎء وﻋﻤﻞ اﻟﺪاﻟﺔ وهﻰ ‪:‬‬
‫‪ -1‬آﺘﺎﺑﺔ اﻟﻜﻮد أو )‪(SYNTAX‬‬
‫‪ -2‬ﺗﺮﺟﻤﺔ ‪ COMPILE‬اﻟﻜﻮد‬
‫‪ -3‬اﺳﺘﺨﺪام اﻟﺪاﻟﺔ واﻟﻌﻤﻞ ﺑﻬﺎ ‪.‬‬
‫‪ -4‬ﻋﻤﻠﻴﺔ إرﺟﺎع ﻗﻴﻤﺔ ﻓﻰ اﻟﺪاﻟﺔ ”‪. “RETURN‬‬
‫ﻳﺠﺐ إدﺧﺎل آﻠﻤﺔ ‪ RETURN‬ﻓﻰ اﻟﺮأس )‪ (HEADER‬ﻟﻠﺪاﻟﺔ أﺛﻨﺎء آﺘﺎﺑﺘﻬﺎ وآﺬﻟﻚ ﻓﻰ‬
‫اﻟﻜﻮد ﻓﻰ اﻟﺠﺰء اﻟﺘﻨﻔﻴﺬى ‪.‬‬
‫وﻳﺴﻤﺢ ﺑﻌﺪة آﻠﻤﺎت ﻣﻦ ‪ RETURN‬وﻟﻜﻦ ﻋﺎدة ﻣﻊ ﺟﻤﻠﺔ ‪ IF‬وﻟﻜﻦ آﻠﻤﺔ ‪RETURN‬‬
‫واﺣﺪة هﻰ اﻟﺘﻰ ﺗﻨﻔﺬ ‪.‬‬

‫* إﻧﺸﺎء داﻟﺔ ﻓﻰ ﺑﻴﺌﺔ ‪: ISQLPLUS‬‬

‫‪ -1‬آﺘﺎﺑﺔ اﻟﻜﻮد اﻟﺨﺎص ﺑﺎﻟﺪاﻟﺔ وﺣﻔﻈﻪ آﻤﻠﻒ ‪. SCRIPT‬‬
‫‪ -2‬ﺗﻨﻔﻴﺬ اﻟﻤﻠﻒ ‪ SCRIPT‬وﻋﻤﻠﻴﺔ ‪ COMPILE‬ﻟﻠﺪاﻟﺔ ‪.‬‬
‫‪ -3‬إﺳﺘﺨﺪام ‪ SHOW ERRER‬ﻟﻤﻌﺮﻓﺔ أﺧﻄﺎء ‪. Compilation‬‬
‫‪ -4‬ﻋﻨﺪ ﻧﺠﺎح ﻋﻤﻠﻴﺔ ‪ COMPILATION‬ﻟﻠﺪاﻟﺔ ﻳﺘﻢ إﺳﺘﺨﺪام اﻟﺪاﻟﺔ ‪.‬‬

‫* ﻣﺜﺎل ﻋﻠﻰ إﻧﺸﺎء اﻟﺪاﻟﺔ ﻓﻰ ﺑﻴﺌﺔ ‪ISQLPLUS‬‬

 ‫ﻓﻰ اﻟﺸﻜﻞ ﻳﻘﻮم ﺑﺈﻧﺸﺎء داﻟﺔ اﺳﻤﻬﺎ ‪ get_sal‬وﺗﺄﺧﺬ ﻣﻌﺎﻣﻞ )‪ (parameter‬اﺳﻤﻪ‬
‫‪ p_id‬هﻮ ﻣﻦ اﻟﻨﻮع ‪ IN‬وﻳﺄﺧﺬ ﻧﻔﺲ هﻴﻜﻞ اﻟﻌﻤﻮد )‪ (EMPLOYEE_id‬ﻓﻰ اﻟﺠﺪول‬
‫)‪ (EMPBYEE‬ﻳﻠﻰ ذﻟﻚ آﻠﻤﺔ ‪ RETURN‬اﻟﺘﻰ ﺗﺤﺪد ﻧﻮع اﻟﺒﻴﺎﻧﺎت اﻟﺘﻰ ﺳﻮف ﺗﺮﺟﻌﻬﺎ‬
‫هﺬﻩ اﻟﺪاﻟﺔ ﺑﻴﻦ ‪ ، IS‬آﻠﻤﺔ ‪ BEGIN‬ﺗﻌﺮف ﺑﺎﻟﻤﺘﻐﻴﺮات اﻟﻤﺤﻠﻴﺔ ﻟﻠﺪاﻟﺔ ‪..‬‬
‫‪ -‬ﻓﻰ داﺧﻞ اﻟﺠﺰء اﻟﺘﻨﻔﻴﺬى اﻟﺬى ﻳﺒﺪأ ﺑﻜﻠﻤﺔ ‪ BEGIN‬وﻳﻨﺘﻬﻰ ﺑﻜﻠﻤﺔ ;‪ END‬ﻧﺮى اﻵﺗﻰ‬
‫‪ ،‬ﻳﺨﺘﺎر ﻣﺮﺗﺐ اﻟﻤﻮﻇﻒ اﻟﺬى رﻗﻤﻪ ﻳﺴﺎوى ‪ P_ID‬وﻳﻀﻌﻪ ﻓﻰ اﻟﻤﺘﻐﻴﺮ ‪ V_SALARY‬ﺛﻢ‬
‫ﻳﻌﻤﻞ ‪ RETURN‬ﻳﺮﺟﻊ هﺬا اﻟﻤﺘﻐﻴﺮ وﺗﻨﺘﻬﻰ اﻟﺪاﻟﺔ ‪.‬‬
‫اﻟﻐﺮض ﻣﻦ اﻟﺪاﻟﺔ إدﺧﺎل رﻗﻢ اﻟﻤﻮﻇﻒ ﺗﺄﺗﻰ ﺑﻤﺮﺗﺐ هﺬا اﻟﻤﻮﻇﻒ ‪.‬‬

‫* ﺗﻨﻔﻴﺬ وإﺳﺘﺪﻋﺎء اﻟﺪاﻟﺔ ‪:‬‬

‫‪ -‬ﻳﺠﺐ أن ﺗﻮﺿﻊ اﻟﺪاﻟﺔ وﺗﺮﻣﻰ ﻓﻰ ﻣﺘﻐﻴﺮ ﺳﻮاء ﻓﻰ ﺑﻠﻮك ‪ PL/SQL‬أو ﻣﺘﻐﻴﺮ ﻣﻦ اﻟﻨﻮع‬
‫‪ BIND‬إذا آﺎﻧﺖ ﺧﺎرج ‪. PL/SQL‬‬
‫اﻟﺸﻜﻞ اﻟﺘﺎﻟﻰ ﻳﻮﺿﺢ آﻴﻔﻴﺔ اﺳﺘﺨﺪام داﻟﺔ ﺧﺎرج آﻮد ‪. PL/SQL‬‬

‫اﻟﺴﻄﺮ اﻷول ‪ :‬ﻳﺘﻢ ﺗﻌﺮﻳﻒ ﻣﺘﻐﻴﺮ اﺳﻤﻪ ‪ G_SALARY‬ﻣﻦ اﻟﻨﻮع ﻋﺪد )‪(NUMBER‬‬
‫اﻟﺴﻄﺮ اﻟﺜﺎﻧﻰ ‪ :‬ﻳﻨﻔﺬ اﻟﺪاﻟﺔ وﻳﺮﻣﻰ اﻟﻘﻴﻤﺔ اﻟﺘﻰ ﺗﺮﺟﻊ ﺑﻬﺎ ﻓﻰ اﻟﻤﺘﻐﻴﺮ اﻟﻤﻌﺮف ﻓﻰ‬
‫اﻟﺴﻄﺮ اﻷول ‪.‬‬
‫اﻟﺴﻄﺮ اﻟﺜﺎﻟﺚ ‪ :‬ﻳﻄﺒﻊ ﻗﻴﻤﺔ اﻟﻤﺘﻐﻴﺮ ﺑﺈﺳﺘﺨﺪام آﻠﻤﺔ ‪. PRINT‬‬

‫* ﻣﺰاﻳﺎ اﺳﺘﺨﺪام اﻟﺪوال ‪:‬‬

‫‪ -1‬ﻗﻠﻨﺎ ﺳﺎﺑﻘﺎً ان ‪ PL/SQL‬ﻳﻌﺘﻤﺪ ﻋﻠﻰ ﺗﻔﺘﻴﺖ اﻟﻤﺸﻜﻠﺔ ﺛﻢ ﺗﺤﻞ آﻞ ﺟﺰﺋﻴﺔ ﻣﻦ‬
‫اﻟﻤﺸﻜﻠﺔ ﻋﻠﻰ ﺣﺪى وﺑﻌﺪهﺎ ﻳﺘﻢ ﺗﺠﻤﻴﻊ هﺬﻩ اﻟﺤﻠﻮل ﻹﻧﺘﺎج اﻟﺤﻞ اﻟﻨﻬﺎﺋﻰ ﻟﻠﻤﺸﻜﻠﺔ‬
‫اﻷم ‪ .‬وﻳﺘﻢ ذﻟﻚ ﻣﻦ ﺧﻼل اﻟﺪوال آﻤﺎ رأﻳﻨﺎ ‪.‬‬
‫‪ -2‬زﻳﺎدة ﻣﻌﺪل ﻓﻌﺎﻟﻴﺔ وآﻔﺎءة اﻷآﻮاد ﺑﺈﺳﺘﺨﺪام اﻟﺪوال ‪.‬‬
‫‪ -3‬إﻣﻜﺎﻧﻴﺔ ﺗﻨﺎول اﻟﻌﺪﻳﺪ ﻣﻦ أﻧﻮاع اﻟﺒﻴﺎﻧﺎت ‪.‬‬
‫‪ -4‬ﺗﺒﺴﻴﻂ اﻟﻌﻤﻠﻴﺎت اﻟﺤﺴﺎﺑﻴﺔ اﻟﻤﻌﻘﺪة ‪.‬‬

‫* آﻴﻔﻴﺔ اﺳﺘﺨﺪام داﻟﺔ ﻓﻰ ‪: SQL‬‬

‫اﻟﺸﻜﻞ اﻟﺴﺎﺑﻖ ﻳﻮﺿﺢ آﻴﻔﻴﺔ اﺳﺘﺨﺪام داﻟﺔ ﺗﻢ إﻧﺸﺎءهﺎ ﻓﻰ ‪ PLISQL‬ﻓﻰ ﺟﻤﻞ ﺑﻴﺌﺔ‬
‫‪ SQL‬وﻳﻤﻜﻦ أن ﺗﻨﺎدى ﻓﻰ ‪ SQL‬ﻓﻰ اﻷﻣﺎآﻦ اﻟﺘﺎﻟﻴﺔ ‪:‬‬
‫‪ -1‬ﻓﻰ اﻷﻋﻤﺪة اﻟﻤﺮﺳﺪة ﻓﻰ ﺟﻤﻠﺔ ‪. SELECT‬‬
‫‪ -2‬اﻟﺸﺮط ﻓﻰ ﺟﻤﻞ ‪. HAVING , WHERE‬‬
‫‪ -3‬ﺟﻤﻞ ‪. GROUP BY , STARE WITH , ORDER BY‬‬
‫‪ -4‬ﺟﻤﻠﺔ ‪ VALUES‬ﻓﻰ ﺟﻤﻠﺔ ‪. INSERT‬‬
‫‪ -5‬ﺟﻤﻠﺔ ‪ SET‬ﻓﻰ ﺟﻤﻠﺔ ‪. UPDATE‬‬
 ‫ﺷﺮوط إﺳﺘﺨﺪام اﻟﺪوال ﻓﻰ ﺗﻌﺒﻴﺮات ‪: SQL‬‬
‫‪ -1‬أن ﺗﻜﻮن داﻟﺔ ﺗﻢ ﺣﻔﻈﻬﺎ ﻓﻰ اﻷوراآﻞ ‪.‬‬
‫‪ -2‬ﺗﻘﺒﻞ ﻣﻌﺎﻣﻼت ﻣﻦ اﻟﻨﻮع ‪ IN‬ﻓﻘﻂ ‪.‬‬
‫‪ -3‬ﺗﻘﺒﻞ ﺑﻴﺎﻧﺎت ﻣﻦ أﻧﻮاع ‪ SQL‬وﻟﻴﺴﺖ ﻣﻦ أﻧﻮاع ﺑﻴﺎﻧﺎت ‪ PL/SQL‬آﻤﻌﺎﻣﻼت ‪.‬‬
‫‪ -4‬ﺗﺮﺟﻊ ﺑﺄﻧﻮاع ﺑﻴﺎﻧﺎت اﻟﺼﺎﻟﺤﺔ )اﻟﺨﺎﺻﺔ ( ﻷﻧﻮاع ﺑﻴﺎﻧﺎت ‪ SQL‬وﻟﻴﺴﺖ أﻧﻮاع ﺑﻴﺎﻧﺎت‬
‫‪ PL/SQL‬ﻓﻬﻰ ﺗﺮﺟﻊ ﺑﻴﺎﻧﺎت ﻣﺜﻞ ‪ ... DATE , VARCHAR2 , NUMBER‬وﻟﻴﺴﺖ‬
‫ﻣﺜﻞ ‪. TABEL , BOOLEAN , RECORD‬‬
‫‪ -5‬ﻻ ﻳﺠﺐ أﻻ ﺗﺤﺘﻮى ﻋﻠﻰ ﺟﻤﻞ ‪. DML‬‬
‫‪ -6‬ﻻ ﻳﺴﻤﺢ أن ﺗﺤﺘﻮى اﻟﺪاﻟﺔ ﻋﻠﻰ ﺟﻤﻞ ﺗﺤﻤﻞ إﺳﺘﻌﻼم ﻋﻠﻰ ﻧﻔﺲ اﻟﺠﺪول ‪.‬‬
‫‪ -7‬اﻟﺪوال اﻟﺘﻰ ﺗﻨﺎدى ﻣﻦ ‪ SQL‬ﻻ ﻳﺴﻤﺢ أن ﺗﺤﺘﻮى ﻋﻠﻰ ﺟﻤﻞ ﺗﻨﻬﻰ ﻋﻤﻠﻴﺎت‬
‫‪ TRANSACTIONS‬ﻣﺜﻞ )‪. (ROLPBACK) or (COMNIT‬‬

‫ﻣﺜﺎل‪ :1‬اﻟﺸﻜﻞ اﻟﺘﺎﻟﻰ ﻳﻮﺿﺢ اﻧﺸﺎء داﻟﺔ ﺗﻘﻮم ﺑﺎﺧﺬ رﻗﻤﻴﻦ وﺗﺮﺟﻊ ﺑﻤﺠﻤﻮﻋﻬﻤﺎ‪:‬‬

‫اﻟﺸﻜﻞ اﻟﺘﺎﻟﻰ ﻳﻮﺿﺢ آﻴﻔﻴﺔ اﺳﺘﺨﺪاهﺎ ﻓﻰ ﺑﻴﺌﺔ ‪: SQL‬‬

‫ﻣﺜﺎل‪ :2‬ﻳﻮﺿﺢ داﻟﺔ ﻣﻦ اﻟﻨﻮع ‪ Boolean‬ﺗﻘﻮم ﺑﺎدﺧﺎل رﻗﻢ وﺗﺨﺘﻴﺮ هﺬا اﻟﺮﻗﻢ اذاآﺎن‬
‫اآﺒﺮ ﻣﻦ اﻟﺼﻔﺮ ﺗﺮﺟﻊ ﺑـ ‪ True‬اذا آﺎن اآﺒﺮ ﻣﻦ اﻟﺼﻔﺮ وﺑـ ‪ False‬اذا آﺎن اﻟﺮﻗﻢ ﻏﻴﺮ‬
‫ذﻟﻚ‪.‬‬

‫ﻻﺣﻆ ان ‪ :‬ﻻ ﻳﻤﻜﻦ اﺳﺘﺨﺪاﻣﻬﺎ ﻓﻰ ﺑﻴﺌﺔ ‪ SQL‬ﻷﻧﻬﺎ ﺗﺮﺟﻊ ﻗﻴﻤﺔ ‪ Boolean‬وهﻰ ﻧﻮع‬
‫ﻣﻮﺟﻮد ﻓﻘﻂ ﻓﻰ ﺑﻴﺌﺔ ‪.PL/SQL‬‬
‫ﻳﺸﺮح داﻟﺔ ﺗﺤﺘﻮى ﻋﻠﻰ ‪ DML‬ﺗﺴﺘﺪﻋﻰ ﻣﻦ داﺧﻞ ‪ SQL‬وآﺬﻟﻚ ﺷﻜﻞ اﻟﺨﻄﺄ‬
‫اﻟﻤﺼﺎﺣﺐ ﻟﻬﺎ ‪.‬‬

‫* آﻴﻔﻴﺔ ﺣﺬف داﻟﺔ ‪:‬‬

‫;‪DROP FUNCTION FANVTION_NAME‬‬ ‫اﻟﺼﻴﻐﻴﺔ اﻟﻌﺎﻣﺔ ‪:‬‬
‫;‪DROP FUNCTION GET_SAL‬‬ ‫ﻣﺜﺎل ‪:‬‬
‫ﻋﻨﺪ ﺣﺬف داﻟﺔ آﻞ اﻟﻤﻨﺢ واﻟﺼﻼﺣﻴﺎت اﻟﻤﻤﻨﻮﺣﺔ ﻋﻠﻴﻬﺎ ﻳﺘﻢ اﺳﻘﺎﻃﻬﺎ ‪.‬‬
 ‫اﻟﻔﺼﻞ اﻟﺤﺎدى ﻋﺸﺮ‬
‫إدارة اﻟﺒﺮاﻣﺞ‬

‫ﻣﻨﺢ اﻟﻨﻈﺎم وﻣﻨﺢ اﻟﻜﺎﺋﻨﺎت ”‪“SYSTEM & OBJECTPRIVLLEGES‬‬

‫هﻨﺎك اآﺜﺮ ﻣﻦ ‪ 80‬ﻣﻨﺤﺔ ﻣﻦ ﻣﻨﺢ اﻟﻨﻈﺎم ﻣﺜﻞ ﻓﺘﺤﺔ إﻧﺸﺎء أى ﺟﺪول ‪CREATE ANY TABLE‬‬
‫ﻋﻠﻰ ﺳﺒﻴﻞ اﻟﻤﺜﺎل‬
‫;‪GRANT CREATE ANY TABLE TO GREEN‬‬
‫وهﺬﻩ اﻟﻤﻨﺢ واﻟﺼﻼﺣﻴﺎت ﻳﺘﻢ ﻣﻨﺤﻬﺎ ﻣﻦ ﻗﺒﻞ ﻣﺴﺘﺨﺪم ‪ SYSTEM‬أو ‪. ' SYS‬‬
‫ﻣﻨﺢ اﻟﻜﺎﺋﻨﺎت " ‪: “ OBJECTPRINLEGE‬‬
‫وهﻰ اﻟﺤﻘﻮق ﻋﻠﻰ إﺳﺘﺨﺪام ﻟﻜﺎﺋﻦ ﻣﻌﻴﻦ داﺧﻞ )‪ (SCHEMA‬وداﺋﻤﺎً ﻳﺤﺘﻮى ﺟﻤﻠﺔ ﻣﻨﺢ‬
‫اﻟﺼﻼﺣﻴﺔ ﻋﻠﻰ إﺳﻢ اﻟﻜﺎﺋﻦ ‪.‬‬
‫ﻋﻠﻰ ﺳﺒﻴﻞ اﻟﻤﺜﺎل ‪ :‬ﻳﻤﻨﺢ اﻟﻤﺴﺘﺨﺪم ‪ SCOTT‬ﺻﻼﺣﻴﺔ ﺗﻌﺪﻳﻞ ﺟﺪول ﻣﻮﻇﻔﻴﻪ‬
‫‪ EMPLOYEES‬آﻶﺗﻰ ‪:‬‬
‫;‪GRANT ALTER ON EMPLOYEES TO GREEN‬‬
‫ﻟﻜﻰ ﺗﻨﺸﺄ داﻟﺔ أو إﺟﺮاء أو ﺑﻠﻮك ‪ PL/SQL‬ﻳﻠﺰم أن ﻳﻜﻮن ﻟﺪﻳﻚ ﺻﻼﺣﻴﺔ ‪CREATE‬‬
‫‪ PROCEDURE‬وﺑﺮاﺳﻄﺔ هﺬﻩ اﻟﺼﻼﺣﻴﺔ ﻳﻤﻜﻨﻚ اﻳﻀﺎً ﺗﻌﺪﻳﻞ )‪ (ALTER‬أو ﺣﺬف )‪ (DROP‬أو‬
‫ﺗﻨﻔﻴﺬ هﺬا اﻟﻜﻮد )ﺑﻠﻮك( ‪.‬‬
‫وإذا آﺎن هﺬا اﻟﺒﻠﻮك أو اﻟﻜﻮد ﻳﻌﺘﻤﺪ أو ﻳﺴﺘﺨﺪم آﺎﺋﻦ ﺧﺎرج ‪ SCHEMA‬اﻟﺨﺎﺻﺔ ﺑﻪ أو ﺧﺎرج‬
‫ﻧﻔﺲ ‪ SCHEMA‬ﻳﺠﺐ أن ﻳﺘﻢ ﻣﻨﺤﻪ اﻟﻮﺻﻮل إﻟﻰ هﺬا اﻟﻜﺎﺋﻦ ﺑﺼﺮاﺣﺔ وﺑﺪون أن ﻳﻜﻮن ﻋﻦ‬
‫ﻃﺮﻳﻖ ‪. ROLL‬‬
‫‪ -‬اﺳﺘﺨﺪم آﻠﻤﺔ ‪ ANY‬ﺗﺴﺘﺨﺪم ﻓﻰ ﻹﻧﺸﺎء أو ﺗﻌﺪﻳﻞ أو ﺣﺬف أو ﺗﻨﻔﻴﺬ أى آﻮد ﻣﻠﻜﻚ‬
‫ﺣﺘﻰ ﻟﻮ ﺧﺎرج ‪ SCHEMA‬اﻟﺨﺎﺻﺔ ﺑﻚ ‪ .‬ﻻﺣﻆ أن آﻠﻤﺔ ‪ ANY‬هﻰ إﺧﺘﻴﺎرﻳﺔ ‪.‬‬
‫‪ -‬ﻳﺠﺐ أن ﻳﻜﻮن ﻟﺪﻳﻚ ﺻﻼﺣﻴﺔ ‪ EXECUTE ANY‬أو ﺗﻜﻮن ﺻﺎﺣﺐ هﺬا اﻟﻜﺎﺋﻦ إذا أردت ﺗﻨﻔﻴﺬ‬
‫هﺬا اﻟﻜﺎﺋﻦ ‪.‬‬
‫‪ -‬ﻻﺣﻆ أن ‪ :‬آﻠﻤﺔ ‪ PROCEDURE‬ﻟﻠﺪﻻﻟﻪ ﻋﻠﻰ ‪ PROCEDURE‬أو ‪ FUNCTION‬أو‬
‫‪. PACKEGE‬‬

‫اﻟﻄﺮﻳﻘﺔ اﻟﻤﺒﺎﺷﺮة ﻟﻤﻨﺢ اﻟﺼﻼﺣﻴﺎت واﻟﻄﺮﻳﻘﺔ ﻏﻴﺮ اﻟﻤﺒﺎﺷﺮة ‪:‬‬

‫اﻟﻄﺮﻳﻘﺔ اﻟﻤﺒﺎﺷﺮة ‪ :‬وذﻟﻚ ﺑﻤﻨﺢ ﻣﺴﺘﺨﺪم ﺁﺧﺮ ﺻﻼﺣﻴﺔ اﺳﺘﺨﺪام اﻟﻜﺎﺋﻦ ﻣﺜﻞ اﻟﺠﺪول‬ ‫‪-‬‬
‫ﻣﺜﻼً ‪.‬‬
‫اﻟﻄﺮﻳﻘﺔ ﻏﻴﺮ اﻟﻤﺒﺎﺷﺮ ‪ :‬وذﻟﻚ ﺑﻤﻨﺢ ﻣﺴﺘﺨﺪم ﺁﺧﺮ ﺻﻼﺣﻴﺔ ﺗﻨﻔﻴﺬ اﻟﻜﺎﺋﻦ ﻓﻘﻂ ﻣﺜﻞ‬ ‫‪-‬‬
‫اﻟﺪاﻟﺔ)وهﺬﻩ اﻟﺪاﻟﺔ ﺗﻘﻮم ﺑﻤﻨﺎدة هﺬا اﻟﺠﺪول ﺑﺬﻟﻚ هﺬا اﻟﻤﺴﺘﺨﺪم ﻟﺪﻳﻪ ﺻﻼﺣﻴﺔ ﺗﻨﻔﻴﺬ‬
‫اﻟﺪاﻟﺔ ﻟﻜﻦ ﻻ ﻳﻘﺪر ان ﻳﺘﻌﺎﻣﻞ ﻣﻊ اﻟﺠﺪول ﻣﺒﺎﺷﺮةً ( ‪.‬‬
‫إﺳﺘﺨﺪام ﺟﻤﻠﺔ ‪. AUTHIDCURRENT_USER‬‬ ‫‪-‬‬
‫اﻟﺸﻜﻞ ﻳﻮﺿﺢ اﺳﺘﺨﺪام هﺬﻩ اﻟﺠﻤﻠﺔ ﻓﻰ إﺟﺒﺎر اﻷورآﻞ أن ﻳﻌﻤﻞ اﻷﺟﺰاء أو اﻟﺪاﻟﺔ ﻓﻰ‬
‫ﺣﺪود اﻟﺼﻼﺣﻴﺔ اﻟﺨﺎﺻﺔ ﺑﺎﻟﻤﺴﺘﺨﺪم وإﻻ ﻳﻌﻤﻞ ﻧﻬﺎﺋﻴﺎ ‪.‬‬
 ‫* إﺳﺘﺨﺪام ‪: USER_OBJECTS‬‬
‫وﺗﺴﺘﺨﺪم هﺬﻩ اﻟـ‪ VIEW‬ﻟﻤﻌﺮﻓﺔ ﺟﻤﻴﻊ أﻧﻮاع وﺑﻴﺎﻧﺎت اﻟﻜﺎﺋﻨﺎت ﻓﻰ ‪ . SCHEMA‬ﻣﺜﻞ‬
‫‪SELECT‬‬
‫‪FROM‬‬ ‫;‪USER_OBJECTS‬‬
‫وﺗﺤﺘﻮى ﻋﻠﻰ ‪ : OBJECT_NAME; :‬اﺳﻢ اﻟﻜﺎﺋﻦ‬
‫‪ : OBJECT_ID -‬وهﻮ اﻟﺮﻗﻢ اﻟﺘﻌﺮﻳﻔﻰ ﻟﻠﻜﺎﺋﻦ داﺧﻠﻴﺎ ‪.‬‬
‫‪ :OBEJECT_TYPE -‬ﻧﻮع اﻟﻜﺎﺋﻦ )إﺟﺮاء ‪ ،‬داﻟﺔ ‪. ( … ،‬‬
‫‪ : CREATED -‬ﺗﺎرﻳﺦ اﻹﻧﺸﺎء ‪.‬‬
‫‪ : LAST_DLL_TIME -‬ﺁﺧﺮ ﺗﺎرﻳﺦ ﺗﻢ ﺗﻌﺪﻳﻞ ﻓﻰ اﻟﻜﺎﺋﻦ ‪.‬‬
‫‪ : TIMESTAMP -‬ﺗﺎرﻳﺦ ووﻗﺖ إﻋﺎدة ﺗﺮﺟﻤﺔ ‪ COMPILE‬ﻟﻠﻜﺎﺋﻦ ‪.‬‬
‫‪ : STATUS -‬ﺣﺎﻟﺔ اﻟﻜﺎﺋﻦ ﺻﺎﻟﺢ ﻟﻠﻌﻤﻞ أم ﻣﻌﻄﻞ ‪.‬‬
‫ﻳﻤﻜﻦ اﺳﺘﺨﺪام ‪ VIEWS‬ﻟﻤﻌﺮﻓﺔ اﻟﻜﺎﺋﻨﺎت ﻣﺜﻞ ‪ DBA_OBJECTS‬أو ‪. ALL_OBJECTS‬‬

‫* اﺳﺘﺨﺪام ‪: USER_SOURCE‬‬
‫ﻟﻠﺤﺼﻮل ﻋﻠىﻨﺺ أو آﻮد ﺑﻨﺎء اﻟﻜﺎﺋﻦ ﻓﻰ ﻗﺎﻋﺪة اﻟﺒﻴﺎﻧﺎت وذﻟﻚ ﻟﻠﻜﺎﺋﻨﺎت اﻟﻤﺤﻔﻮﻇﺔ‬
‫ﻧﺴﺘﺨﺪم )‪ USER_SOURCE (VIEW‬وآﺬﻟﻚ ‪ ALL_SOURCE‬وأﻳﻀﺎً ‪. DBA_SOURCE‬‬
‫ﺗﺤﺘﻮى ﻋﻠﻰ اﻵﺗﻰ ‪:‬‬
‫‪ : NAME -‬اﺳﻢ اﻟﻜﺎﺋﻦ‬
‫‪ : TYPE -‬ﻧﻮع اﻟﻜﺎﺋﻦ ﺳﻮاء آﺎن إﺟﺮاء ‪ ،‬داﻟﺔ ‪ ،‬ﺣﺰﻣﺔ …‬
‫‪ : LINE -‬رﻗﻢ اﻟﺴﻄﺮ ﻓىﺒﻴﺌﺔ أو ﻧﺺ آﻮد اﻟﻜﺎﺋﻦ ‪.‬‬
‫‪ : TEXT -‬اﻟﻨﺺ اﻟﺨﺎص ﺑﺎﻟﻜﻮد آﻤﺎ آﺘﺒﻪ اﻟﻤﺒﺮﻣﺞ ‪.‬‬

‫* اﺳﺘﺨﺪام ‪USER_ERRORS :‬‬

‫وﺗﺴﺘﺨﺪم ﻟﻠﺤﺼﻮل ﻋﻠﻰ ﻧﺼﻮص اﻷﺧﻄﺎء وﺗﺤﺘﻮى ﻋﻠﻰ ‪:‬‬
‫‪ : NAME -‬اﺳﻢ اﻟﻜﺎﺋﻦ ‪.‬‬
‫‪ : TYPE -‬ﻧﻮع اﻟﻜﺎﺋﻦ ‪.‬‬
‫‪ : SEQUENCE -‬رﻗﻢ ﺗﺴﻠﺴﻠﻰ أو ﺗﺮﺗﻴﺐ ﻟﻠﺨﻄﺄ ‪.‬‬
‫‪ : LINE -‬رﻗﻢ اﻟﺴﻄﺮ اﻟﺬى ﺑﻪ اﻟﺨﻄﺄ ‪.‬‬
‫‪ : POSITION -‬ﻣﻜﺎن أو ﻣﻮﻗﻊ اﻟﺨﻄﺄ ﻓﻰ اﻟﺴﻄﺮ ‪.‬‬
‫‪ : TEXT -‬ﻧﺺ رﺳﺎﻟﺔ اﻟﺨﻄﺄ ‪.‬‬
‫ﻣﺜﺎل‪ :‬ﻓﻰ ﺣﺎﻟﺔ ﺣﺪوث ﺧﻄﺄ ﻓﻰ اﻟﻜﻮد آﺎﻻﺗﻰ‪:‬‬

‫ﻳﻤﻜﻦ ﻣﻌﺮﻓﺔ اﻟﺨﻄﺄ آﺎﻻﺗﻰ‪:‬‬

‫اﺳﺘﺨﺪام اﻷﻣﺮ ‪SHOW ERRORE‬‬

 : ‫اﻟﺼﻴﻐﺔ‬
SHOW ERRORS OBJECT_TYPE OBJECT_NAME
: ‫ﻣﺜﺎل‬
SHOW ERROR PROCEDURE LOG-EXECATION