فهرست مطالب

عنوان صفحه

فصل اول: بررسي بانك اطلاعاتي SQL. .. 11

الف ـ آشنايي و استفاده از دستور SELECT .. 12

دستور SELECT .. .. 13

پرس و جو با استفاده از DISTINCT... . 14

عبارات ... 15

شرايط... 15

عملگرها.. . 16

عملگردهاي رياضي .. 16

عملگردهاي مقايسه‌اي.... 16

عملگرهاي كاراكتري.. . 17

عملگرهاي منطقي... . 19

عملگرهاي مجموعه‌اي. . 20

عملگرهاي ديگر.... . 21

توابع . .. 23

توابع جمعي..... 23

توابع تاريخ و زمان .. 24

توابع رياضي..... 26

توابع كاراكتري...................................................................................................... 26

توابع تبديلي............................................................................................................ 29

ب ـ آشنايي و استفاده از دستورات پردازش‌ها.................................................... 29

جملات پردازش داده‌ها.......................................................................................... 29

درج داده‌ها با استفاده از جمله INSERT .......................................................... 31

درج يك ركورد با استفاده از INSERT … VALUES ................................... 31

درج چندين ركورد با استفاده از INSERT … SELECT ............................... 32

تغيير نوع داده‌هاي موجود با استفاده از جمله DELETE ................................. 34

ورود و صدور داده‌ها از منابع خارجي................................................................ 36

شبه جملات در پرس و جوهاي SQL ................................................................. 38

تعيين معياري با شبه جمله WHERE ................................................................ 38

شبه جمله STARTING WITH ....................................................................... 38

شبه جمله ORDER BY .................................................................................... 39

شبه جمله GROUP BY .................................................................................... 40

شبه جمله HAVING ......................................................................................... 40

فصل ج ـ آشنايي و استفاده از دستورات تعريف داده‌ها...................................... 42

ايجاد و نگهداري جداول........................................................................................ 42

شروع كار با جمله ايجاد پايگاه داده‌اي (CREATE DATABASE)............... 42

راه‌هاي ايجاد پايگاه داده....................................................................................... 42

طراحي پايگاه داده‌اي............................................................................................. 43

ايجاد يك فرهنگ داده‌اي (كاتالوگ سيستم)........................................................... 45

ايجاد فيلد كليد........................................................................................................ 46

جمله CREATE TABLE ................................................................................ 46

جمله ALTER TABLE .................................................................................... 48

جمله DROP TABLE ...................................................................................... 50

جمله DROP DATABASE ............................................................................ 51

ايجاد شاخص‌ها بر روي جداول جهت بهبود اجرا................................................ 51

استفاده از شاخص‌ها............................................................................................. 51

شاخص‌ها چه هستند؟........................................................................................... 52

نكات شاخص بندي................................................................................................ 54

شاخص‌بندي روي بيشتر از يك فيلد..................................................................... 55

استفاده از كلمه كليدي UNIQUE به همراه CREATE INDEX .................. 55

شاخص‌ها و اتصال‌ها............................................................................................ 55

ايجاد ديدها........................................................................................................... 57

معرفي ديد............................................................................................................. 57

كاربرد ديدها......................................................................................................... 57

تغيير نام ستون‌ها.................................................................................................. 58

پردازش ديد در SQL .......................................................................................... 58

محدوديت‌هاي استفاده از SELECT .................................................................. 59

تغيير داده‌ها در يك ديد ........................................................................................ 59

مشكلات تغيير داده‌ها با استفاده از ديدها ............................................................ 59

كاربردهاي مشترك ديدها .................................................................................... 60

استفاده از ديدها براي تبديل واحدها ................................................................... 61

ساده‌سازي پرس و جوهاي پيچيده با استفاده از ديدها ...................................... 62

حذف ديدها با استفاده از جمله DROP VIEW ................................................ 62

د ـ اتصال جداول ................................................................................................. 64

اتصال جدول‌ها به شرط تساوي .......................................................................... 64

اتصال جدول‌ها به شرط عدم تساوي .................................................................. 65

اتصال جدول‌ها با استفاده از كلمه كليدي JOIN ................................................ 66

اتصال دروني (INNER JOIN) ......................................................................... 66

اتصال بيروني (OUTER JOIN) ....................................................................... 66

ه ـ كنترل جامعيت داده‌ها ................................................................................... 68

معرفي محدوديت‌ها .............................................................................................. 68

جامعيت داده‌ها ..................................................................................................... 68

چرا از محدوديت‌ها استفاده مي‌كنيم؟ ................................................................... 69

مروري بر انواع محدوديت‌ها ............................................................................... 70

محدوديت‌هاي NOT NULL .............................................................................. 71

محدوديت‌هاي كليد اصلي ..................................................................................... 72

محدوديت‌هاي يكتايي ............................................................................................ 72

محدوديت‌هاي كليد خارجي .................................................................................. 72

محدوديت‌هاي كنترل ............................................................................................ 74

محدوديت‌هاي مديريتي ......................................................................................... 74

استفاده از ترتيب صحيح ...................................................................................... 75

روشهاي مختلف در ايجاد محدوديت‌ها ................................................................ 76

و ـ نرمال سازي پايگاه داده‌ها ............................................................................ 77

پايگاه داده‌اي خام ................................................................................................. 77

طراحي پايگاه داده‌اي منطقي ................................................................................ 77

نيازهاي كاربر نهايي چيست؟ ............................................................................... 78

افزونگي داده‌ها ..................................................................................................... 79

فرم‌هاي نرمال ...................................................................................................... 80

فرم اول نرمال ...................................................................................................... 81

فرم دوم نرمال ..................................................................................................... 81

فرم سوم نرمال .................................................................................................... 81

مزاياي نرمال سازي ............................................................................................ 81

معايب نرمال سازي .............................................................................................. 83

از نرمال درآوردن يك پايگاه اطلاعاتي................................................................. 83

فصل دوم: بررسي بانك اطلاعاتي اكسس........................................................... 85

مقدمه..................................................................................................................... 85

آشنايي با اكسس .................................................................................................. 86

تعريف كلي از ACCESS ................................................................................... 88

تكنيك كار در اكسس............................................................................................. 89

طراحي جدول (TABLE) .................................................................................... 90

آشنايي با خصوصيات فيلدها در محيط طراحي.................................................... 91

انواع عملگرها ....................................................................................................... 102

آشنايي با تنظيم خصوصيات محيط ورود داده‌ها (DataSheet View) ............ 103

انواع فيلترها .......................................................................................................... 108

طرز ايجاد Relationship .................................................................................. 109

آشنايي با طراحي Query .................................................................................... 113

ايجاد Query از طريق Design View ............................................................... 114

كاربرد Total در Select Query ....................................................................... 116

آشنايي با Action Query .................................................................................. 117

آشنايي با طراحي فرم (From) ............................................................................ 118

فرم چيست؟ .......................................................................................................... 119

طرز كار Form Wizard .................................................................................... 120

طرز كار AutoForm ......................................................................................... 121

تفاوت فرم و گزارش............................................................................................. 122

آشنايي با طراحي Report ................................................................................... 123

طرز كار Report Wizard ................................................................................. 124

منابع ..................................................................................................................... 125

 

 

مروري بر SQL

تاريخچه SQL از لابراتوار IBM در سان خوزه كاليفرنيا شروع مي‌شود. جايي كه SQL در اواخر دهه 1970 ميلادي شكل گرفت.

كلمه SQL برگرفته از حروف اول كلمات Structuted Query Language ساخته شده و اغلب اوقات اشاره به sequel مي‌‍‌كند.

اين زبان ابتدا براي محصول DB2 شركت IBM (يك سيستم مديريت پايگاه داده‌اي رابطه‌اي يا RDBMS كه امروزه نيز براي بعضي محيط‌ها فروخته مي‌شود، طراحي شد.)

در واقع SQL امكان RDBMS را فراهم مي‌آورد. SQL يك زبان غير روالمند مي‌باشد، بر خلاف زبان‌هاي روانمند يا زبان‌هاي نسل سوم (3 GLs) مثل كوبول و C كه در آن زمانها ايجاد شده بودند.

تذكر ـ غير روانمند يعني چه به جاي چگونه، بطور مثــال SQL مي‌گويد كه داده‌ها بايد ذخيره، حذف، اضافه يا بازيابي شوند بدون آنكه به چگونگي انجام آنها كاري داشته باشد.

ويژگي مهمي كه باعث تفاوت بين DBMS و RDBMS مي‌گردد، آن است كه يك RDBMS از يك زبان مبتني بر مجموعه‌ها استفاده مي‌كند. در اكثر RDBMS ها اين زبان، زبان SQL است. در نتيجه SQL زبان مبتني بر مجموعه‌ها است.

SQL، يك زبان كامپيوتري مبتني بر استاندارد (American National Standards Institute) ANSI براي بازيابي و بروز رساني داده‌ها در يك پايگاه داده‌اي مي‌باشد و با برنامه‌هاي پايگاه داده‌هايي مانند MS Access ، DB2 ، MS SQL Server ، Oracle، Sybase و ... كار مي‌كند.

از طريق SQL، يك برنامه نويس يا گرداننده داده‌ها مي‌تواند كارهاي زير را انجام دهد:

! تغيير ساختار يك پايگاه داده‌اي

! تغيير مشخصات امنيتي سيستم

! امكان اعطاي اجازه دسترسي كاربران به پايگاه داده‌اي يا جداول

! پرس و جو از يك پايگاه داده‌اي

استفاده از SQL و پايگاه داده‌اي رابطه‌اي نيز از مهمترين اقدامات انجام شده در جهت توسعه كاربرد Client/Server مي‌باشد.

SQL بطور كلي شامل دو گروه از جملات مي‌باشد:

1- جملات پردازش داده‌ها (DML)

2- جملات تعريف داده‌ها (DDL)

جملات پردازش داده‌ها (DML) شامل عبارات زير مي‌باشند:

¶INSERT

¶DELETE

¶UPDATE

 

مهمترين عبارات DDL در SQL نيز عبارتند از:

¶CREATE TABLE

¶ALTER TABLE

¶DROP TABLE

¶CREATE INDEX

¶DROP INDEX

¶CREATE VIEW

¶DROP VIEW

در بخش‌هاي بعد بطور كامل‌تر اين دستورات توضيح داده خواهند شد.

 

دستور SELECT

قاعده نگارش را با دستور SELECT شروع مي‌كنيم زيرا اكثر جملات با SELECT شروع مي‌شوند. اين دستور كه دستوري مستقل نيست و حتما بايد با اجزايي بكار رود، جهت ساخت پرس و جو بر روي بانك اطلاعاتي بكار مي‌رود و ركوردهايي را كه با شرايط اين دستور همخوان باشد، به عنوان نتيجه پرس و جو برمي‌گرداند.

توجه ـ هرگاه SELECT استفاده مي‌‍شود حتما بايد از شبه جملات FROM نيز استفاده شود.

انتخاب تمام ستون‌ها:

SELECT * FROM table_name

 

انتخاب ستون‌هاي خاص:

SELECT column_name(s)

FROM table_name

تذكر ـ در بعضي از نرم‌افزارهاي SQL علامت سميكولن (;) در انتهاي جمله به مفسر مي‌گويد كه پرس و جو تمام شده است. به عنوان مثــال SQL*plus اوراكل، پرس و جويي را اجرا نمي‌كند تا زمانيكه يك سميكلون (يا يك اسلش (/)) را پيدا نكند. در حالي كه بعضي ديگر از نرم افزارهاي SQL از سميكلون به عنوان انتهاي يك جمله SQL استفاده نمي‌كنند. به عنوان مثــال پرس و جو در مايكروسافت نيازي به تمام كننده ندارد زيرا پرس و جو در جعبه ويرايش تايپ مي‌شود و وقتي دكمه‌اي را فشار دهيم اجرا مي‌گردد.

پرس و جو با استفاده از DISTINCT

برخي اوقات در جداول بعضي از اقلام داده‌اي تكرار مي‌شون. اگر آنچه نياز داريم آن است كه بدانيم چه مقادير متفاوتي در يك ستون وجود دارند، از دستور زير استفاده مي‌كنيم:

SELECT DISTINCT column_name(s)

FROM table_name

اين جمله اقلام داده‌اي تكراري در ستون مورد نظر را حذف مي‌كند. به عبارت ديگر DISTINC باعث محدود شدن نتايج خروجي مي‌شود به شكلي كه داده‌هاي تكراري در جواب ظاهر نمي‌شوند.

عبارات

يك عبارت يك مقدار را برمي‌گرداند. از نقطه نظر نوع داده، عبارت انواع متفاوتي دارد مثل رشته، عدد و بولين. در واقع هر چيزي پس از شبه جمله (بطور مثــال SELECT يا FROM) بيانگر يك عبارت است. در مثــال زير amount يك عبارت است كه مقدار ستون omount را بر مي‌گرداند:

SELECT amount FROM checks

شرايط

اگر بخشي از اقلام يا گروهي از اقلام را در پايگاه اطلاعاتي بخواهيم، به يك يا چند شرط احتياج دارد. شرايط در داخل شبه جمله WHEREمي‌آيند.

شرايط امكان پرس و جوهاي انتخابي‌تر را مي‌دهند. در متداول‌ترين فرم آنها، شرايط از يك متغير، يك مقدار ثابت و يك عملگر مقايسه‌اي تشكيل مي‌‍شوند.

قاعده نگارش شبه جمله WHERE :

SELECT column_name(s)

FROM table_name

WHERE condition

عملگرها

عملگرها عناصري هستند كه براي بيان چگونگي شرايط مورد نظر جهت استخراج داده‌ها در داخل يك عبارت استفاده مي‌شوند. عملگردها به 6 گروه تقسيم مي‌شوند: رياضي، مقايسه‌اي، كاراكتري، منطقي، مجموعه‌اي و متفرقه.

¨ عملگرهاي رياضي

عملگردهاي رياضي عبارتند از: جمع (+)، تفريق (-)، ضرب (*)، تقسيم (/) و باقيمانده صحيح (% يا MOD).

¨ عملگردهاي مقايسه‌اي

عملگرهاي مقايسه‌اي، عبارات را مقايسه نموده و يكي از اين سه مقدار را بر مي‌گردانند: صحيح (True)، غلط (False) يا ناشناخته (Unknown).

در فرهنگ اصطلاحات پايگاه داده‌ها، هيچ (NULL) به معناي عدم حضور داده در يك فيلد است. اما بدين مفهوم نيست كه فيلد داراي مقدار صفر يا بلانك (blank) است. صفر يا بلانك يك مقدار است در حاليكه هيچ يعني آن فيلد چيزي ندارد.

اگر مقايسه‌اي مثل field=9 را انجام دهيم و بدانيم تنها مقدار قابل قبول براي آن فيلد هيچ است، آنگاه نتيجه مقايسه ناشناخته است. چون ناشناخته يك شرط نامناسب است، نسخه‌هاي مختلف SQL ، مقدار ناشناخته را با مقدار غلط جايگزين مي‌نمايند و عملگر خاص IS NULL را براي آزمايش شرط NULL ارائه مي‌دهند.

عملگرهاي مقايسه‌اي عبارتند از: مساوي (=)، بزرگتر از (> ) ، بزرگتر يا مساوي با (=>)، كوچكتر از (<)، كوچكتر يا مساوي با (=<) و نامساوي (= ! يا < >).

توجه ـ براي پيدا كردن مقادير فيلدهاي كاراكتري بايد از علامت كوتيشن در طرفين مقدار مورد نظر استفاده شود. فيلدهاي عددي نيازي به استفاده از علامت كوتيشن ندارند.

تذكرـ گرچه قاعده نگارش SQL به حروف بزرگ و كوچك حساس نيست، اما داده‌ها آن حساس مي‌باشند. اكثر شركت‌ها ترجيح مي‌دهند كه اطلاعات را به شكل حروف كوچك ذخيره كنند تا بدين وسيله جامعيت داده‌ها را تأمين نمايند. پيشنهاد مي‌شود كه همه داده‌ها يا بصورت حروف بزرگ و يا بصورت حروف كوچك ذخيره شوند. تركيب حروف بزرگ و كوچك احتمالا موجب بروز مشكلاتي در بازاريابي دقيق داده‌ها خواهد شد.

توجه ـ حروف بزرگ معمولا قبل از حروف كوچك ذخيره مي‌شوند (ارزش كاراكتري حروف بزرگ كمتر از حروف كوچك است).

¨ عملگردهاي كاركتري

از عملگردهاي كاراكتري براي پردازش رشته‌هاي كاراكتري استفاده مي‌شود (هم در خروجي داده‌ها و هم به منظور گذاشتن شرطي روي داده‌هايي كه بايد بازيابي گردند.)

! عملگر LIKE

گاهي اوقات مي‌خواهيم بخشي از اطلاعات پايگاه داده‌ها را كه داراي الگوي خاصي است ولي كاملا يك داده خاص را نمي‌پوشاند، انتخاب و بازيابي نماييم. يك روش طولاني و خسته كننده آن است كه الگوي مورد نظر را در حالات مختلف ممكن در سرتاسر پايگاه داده‌ها به همراه علامت = استفاده كنيم. راه حل بعدي استفاده از LIKE است.

SELECT coumn_name FROM table_name

WHERE column_name LIKE pattern

مثــال/

SELECT * FROM customers

WHERE LastName LIKE S%

با استفاده از عبارت فوق، ركورد تمام مشترياني كه نام خانوادگي آنها با حرف S شروع مي‌شود به عنوان خروجي، برگردانده خواهد شد.

تذكر ـ از علامت % مي‌توان در ابتدا، انتها و يا در هر دو طرف الگو (pattern) استفاده كرد.

اگر بخواهيم داده‌هايي را پيدا كنيم كه يك يا چند كاراكتر از آن را در اختيار داريم، بايد از نوع ديگري از wildcard، يعني underscore (_ ) استفاده كنيم.

مثــال/

SELECT * FROM friends

Where phone LIKE 223_5_8_

همچنين مي‌توان از تركيب اين دو Wildcard نيز استفاده كرد.

 

مثــال/

SELECT * FROM customers

WHERE LastName LIKE _b%

با استفاده از اين مثــال تمام ركوردهايي كه دومين كاراكتر نام خانوادگي آنها b است، پيدا مي‌شوند.

عملگر «: عملگر» (لوله مضاعف) دو رشته را به هم متصل مي‌كنند.

تذكر ـ بعضي از نسخه‌هاي SQL جهت اتصال از علامت جمع استفاده مي‌كنند.

¨ عملگرهاي منطقي

عملگرهاي منطقي، دو يا چند شرط را در شبه جمله WHERE از يك جمله SQL جدا مي‌كنند.

!عمگر AND : دو عبارت منطقي را تركيب مي‌كند. بايد هر دو شرط داده شده در طرفين AND صحيح باشند تا نتيجه AND صحيح گردد. اگر يكي از شروط در طرفين AND غلط باشد، نتيجه AND غلط مي‌گردد.

SELECT column_name(s)

FROM table_name

WHERE conditionl AND condition

! عملگر OR : از OR براي ارتباط شروط استفاده مي‌شود. كافي است كه يكي از شرط‌هاي دو سمت OR صحيح باشد تا نتيجه OR صحيح گردد و در صورتي نتيجه OR غلط است كه هر دو شرط دو سمت OR غلط باشند.

SELECT column_name(s)

FROM table_name

WHERE conditionl OR condition2

!عملگر NOT : شرط داده شده را منفي مي‌كند. به عبارتديگر اگر شرط داده شده قبل از NOT غلط باشد، بعد از اعمال NOT صحيح مي‌شود و بالعكس.

NOT همچنين مي‌تواند با عملگر IS زمانيكه از NULL استفاده مي‌كنيم، همراه شود.

¨ عملگرهاي مجموعه‌اي

! عملگرهاي UNION و UNION ALL :

UNION، اجتماع دو مجموعه پرس و جو را بدون تكرار برمي‌گرداند.

UNION ALL نيز شبيه UNION مي‌باشد بجز آنكه تكراري‌ها را حذف نمي‌كند.

SQL STATEMENT 1

UNION/UNION ALL

SQL STATEMENT 2

! عملگر INTERSECT : ركوردهايي را برمي‌گرداند كه در هر دو پرس و جو وجود داشته باشند (مشترك باشند).

SQL STATEMENT 1

INTERSECT

SQL STATEMENT 2

! عملگر MINUS : كليه رديف‌هايي را ه در پرس و جوي اول هستند ولي در پرس و جوي دوم نيستند، برمي‌گرداند.

SQL STATEMENT 1

MINUS

SQL STATEMENT 2

¨ عملگرهاي ديگر

! عملگر IN : از عملگر IN هنگامي استفاده مي‌شود كه مقدار دقيق آنچه را كه مي‌خواهيم برگردانده شود، را بدانيم.

SELECT column_name(s)

FROM table_name

WHERE column_name IN (value 1, value 2, …)

 

 

مثــال/

SELECTB * FROM customers

WHERE LastName IN (¢Hansen ¢ / ¢ Pettersen¢)

در مثــال فوق مشخصات مشترياني كه نام خانوادگي آنها Hansen و يا Pettersen مي‌باشد، برگردانده مي‌شود.

s عملگر BETWEEN … AND : عملگر BETWEEN … AND، بازده‌اي از داده‌ها را كه بين د و مقدار موردنظر قرار دارند را برمي‌گرداند. (مقادير موردنظر مي‌توانند عدد، متن و يا تاريخ باشند).

تذكر ـ نتيجه عملگر BETWEEN … AND در پايگاه داده‌هاي مختلف متفاوت است. در بعضي از پايگاه‌ داده‌ها، BETWEEN … AND تنها مقاديري را كه بين دو مقدار موردنظر قرار دارند، برمي‌گرداند. در بعضي از پايگاه داده‌ها مقاديري كه بين دو مقدار موردنظر قرار دارند و شامل آن مقادير نيز مي‌باشند، برگردانده مي‌شوند و در برخي ديگر مقادير بين دو مقدار موردنظر به همراه يكي از مقادير سمت چپ و يا سمت راست به عنوان نتيجه برگردانده مي‌شوند.

توابع

استفاده از توابع SQL اين امكان را مي‌دهد تا كارهاي خارق‌العاده‌اي مثل جمع يك ستون يا تغيير تمام كاراكترهاي يك رشته به حروف بزرگ را انجام دهيم.

توابع، بطور قابل ملاحظه‌اي توانايي‌ ما را در پردازش اطلاعاتي كه بازيابي مي‌كنيم، با استفاده از توابع اوليه SQL بالا مي‌برد.

SELECT function (column)

FROM table – name

WHERE condition

s توابع جمعي

اين توابع گاهي اوقات تحت عنوان توابع گروهي ناميده مي‌شوند. نتيجه اين توابع مقداري است كه از مقادير يك ستون حاصل مي‌شود.

توجه ـ نمي‌توان از توابع جمعي (گروهي) در شبه جمله WHERE استفاده كرد.

sCOUNT : اين تابع تعداد رديف‌هايي را برمي‌گرداند كه شرايط موجود در جلوي شبه جمله WHERE را تامين مي‌كنند.

sSUN : اين تابع مجموع مقادير يك ستون عددي را برمي‌گرداند.

sAVG: تابع AVG ميانگين يك ستون را محاسبه مي‌كند.

AVG نيز مانند تابع SUN فقط براي فيلدهاي عددي بكار مي‌رود.

sMAX: اين تابع بزرگترين مقدار يك ستون را پيدا مي‌كند.

تابع MAX هم با اعداد كار مي‌كند و هم با رشته‌هاي كاراكتري.

sMIN : تابع MIN شبيه تابع MAX است با اين تفاوت كه كوچكترين مقدار يك ستون را برمي‌گرداند. اين تابع نيز هم با اعداد كار مي‌كند و هم با رشته‌هاي كاراكتري.

sVARIANCE : مربع انحراف استاندارد را نشان مي‌دهد كه عددي حياتي براي بيشتر محاسبات آماري است. اين تابع از توابعي است كه فقط با فيلدهاي عددي كار مي‌كند.

sSTDDEV : اين تابع مقدار انحراف استاندارد يك ستون از اعداد را پيدا مي‌كند.

اين تابع نيز تنها با فيلدهاي عددي كار مي‌كند و وقتي با رشته كاركتري مواجه مي‌شود، يك پيغام اشتباه مي‌فرستد.

s توابع تاريخ و زمان

ما در تمدني زندگي مي‌كنيم كه توسط زمان و تاريخ اداره مي‌شود و بيشتر كاربردهاي SQL داراي توابعي براي فايق آمدن بر اين مفاهيم هستند.

تذكر ـ اين توابع از نوع داده Date استفاده مي‌كنند.

sADD – MONTHS: اين تابع تعدادي ماه به تاريخ مشخصي اضافه مي‌كند. بطور مثــال ممكن است مطلب فوق‌العاده‌اي اتفاق افتاده باشد و پروژه‌اي براي مدت دو ماه متوقف شده باشد و حالا اگر بخواهيم برنامه‌ريزي جديدي ارائه دهيم، از اين تابع استفاده مي‌كنيم.

sLAST – DAY: اين تابع، آخرين روز يك ماه بخصوص را پيدا مي‌كند.

sMONTHS – BETWEEN : اگر بخواهيم بدانيم كه چند ماه بين ماههاي x و y قرار مي‌گيرد، از اين تابع استفاده مي‌كنيم. اين تابع به ترتيب قرار دادن ماهها حساس است بنابراين بطور مثــال مي‌توان از يك نتيجه منفي براي تعيين اينكه آيا تاريخي قبل از تاريخ ديگري اتفاق افتاده است يا نه، استفاده كرد.

sNEW – TIME : اگر بخواهيم زمان را براساس زمان منطقه‌اي تطبيق دهيم، بايد از اين تابع استفاده كنيم. در جدول صفحه بعد، زمان مناطق موردنظر كه با اين تابع قابل استفاده هستند، آورده شده است:

s NEXT – DAY : اين تابع نام اولين روز هفته كه مساوي با تاريخ بخصوصي است و يا بعد از تاريخ معيني مي‌آيد را بدست مي‌آورد.

sSYSDATE : اين تابع تاريخ و زمان سيستم را برمي‌گرداند.

s توابع رياضي

بسياري از اطلاعات كه از پايگاه داده‌ها بازيابي مي‌كنيم نياز به محاسبات رياضي دارند. نمونه‌هايي از توابع رياضي عبارتند از: ABS, CEIL, DLOOR, SIN, COS, TAN, SINH, COSH, EXP, LN, LOG, MOD, POWER, SIGN, SQRT, و ...

s توابع كاراكتري

بسياري از نسخه‌هاي SQL امكان استفاده از توابع كاراكتري و رشته‌اي را فراهم مي‌آورند.

sCHR: اين تابع، كاراكتر معادل عدد داده شده در آرگومان را برمي‌گرداند. كاراكتري كه برگردانده مي‌شود بستگي به مجموعه كاراكترهاي پايگاه داده مورد استفاده (مثلاً ASCII و ...) دارد.

sCONCAT : اين تابع همان عمل عملگر || را انجام مي‌دهد. (دو رشته را به هم متصل مي‌كند).

sINITCAR : اين تابع اولين حرف يك كلمه را به حرف بزرگ و ساير حروف كلمه را به حروف كوچك تبديل مي‌كند.

sLOWER : اين تابع تمام كاراكترها را به حروف كوچك تبديل مي‌كند.

sUPPER : اين تابع عكس تابع LOWER عمل مي‌كند. (تمام كاراكترها را به حروف بزرگ تبديل مي‌كند).

sRPAD , LPAD : حداقل 2 و حداكثر 3 آرگومان رشته كاراكتري است كه عمليات روي آن انجام مي‌شود. آرگومان دوم، تعداد كاراكتري است كه بايد اضافه شود و آرگومان سوم كه اختياري نيز مي‌باشد، نشان دهنده كاراكتري است كه بايد اضافه شود. پيش فرض سومين آرگومان بلانك (blank) يا مي‌تواند يك كاراكتر تنها و يا رشته‌اي از كاراكترها باشد.

sRTRIM , LTRIM : حداقل يك و حداكثر دو آرگومان دارند. اولين آرگومان يك رشته كاراكتري است و دومين آرگومان كه اختياري نيز مي‌باشد يا يك كاراكتر است يا يك رشته كاراكتري و يا پيش فرض‌اش يك بلانك (blank) است. اگر از آرگومان دوم استفاده كنيم و بلانك نيز نباشد، توابع TRIM كاراكترها را مي‌اندازند. (حذف مي‌كنند)

sREPLACE : كاراكتري را به جاي كاركتر ديگري در يك رشته كاراكتري جايگزين مي‌كند. اين تابع سه آرگومان دارد. اولين آرگومان، رشته مورد جستجو را مشخص مي‌كند. دومين آرگومان كليد جستجو است و آخرين آرگومان، رشته جايگزين اختياري است. اگر سومين آرگومان نوشته نشود و يا بلانك (blank) درنظر گرفته شود، هر نمونه از كليد جستجو كه در داخل رشته جستجو مي‌شود، برداشته شده و به جاي آن چيزي جايگزين نمي‌گردد. اگر آرگومان سوم را داشته باشيم، اين آرگومان به جاي هر نمونه از كليد جستجو در رشته موردنظر جايگزين خواهد شد. اگر دومين آرگومان خالي باشد، رشته موردنظر بدون تغيير باقي خواهد ماند.

sSUBSTR : اين تابع سه آرگومان اين امكان را مي‌دهد كه قطعه‌اي از يك رشته را بتوان انتخاب نمود. اولين آرگومان، رشته موردنظر است. دومين آرگومان امكان اولين كاراكتر رشته را مشخص مي‌كند. سومين آرگومان تعداد كاراكتري را كه بايد انتخاب شود را نشان مي‌دهد. اگر در دومين آرگومان از عدد منفي استفاده كنيم، نقطه شروع با شمردن از انتها شروع مي‌شود. اگر آرگومان سوم را نداشته باشيم، باقيمانده رشته برگردانده مي‌شود.

sTRANSLATE : اين تابع سه آرگومان دارد: رشته موردنظر، رشته FROM و رشته TO. عناصر رشته موردنظر كه در رشته FROM رخ مي‌دهد، به عناصر وابسته در رشته TO تبديل مي‌شود.

sINSTR : با استفاده از اين تابع، محل وجود يك رشته كاراكتري در داخل رشته‌اي ديگر مشخص مي‌شود. اولين آرگومان، رشته موردنظر مي‌باشد. آرگومان دوم، الگوي موردنظر است. سومين و چهارمين آرگومان اعدادي هستند كه شروع جستجو و تعداد كاراكتر مورد جستجو را نشان مي‌دهد.

تذكر ـ پيش فرض سومين و چهارمين آرگومان يك است. اگر سومين آرگومان منفي باشد، شروع جستجو از انتهاي رشته انجام خواهد شد.

sLENGTH : اين تابع طول يك رشته كاراكتري را برمي‌گرداند.

s توابع تبديلي

اين توابع، راه‌هاي ساده‌اي براي تبديل يك نوع داده به نوع ديگري از داده را ارائه مي‌دهند.

sTO – CHAR : اين تابع، يك عدد را به كاراكتر تبديل مي‌كند.

توجه ـ ممكن است برخي از نسخه‌هاي SQL از اين تابع جهت تبديل ساير انواع داده به نوع كاراكتري استفاده كنند (مثل Date به كاراكتر) و يا از فرمت ديگري براي اين تابع و آرگومان‌هاي آن استفاده نمايند.

sTO – NUMBER : اين تابع يك رشته عددي را به يك عدد تبديل مي‌كند.

جملات پردازش داده‌ها

تا اين مرحله ياد گرفتيم كه چگونه داده‌ها را از پايگاه داده‌اي با استفاده از دستور SELECT بازيابي كنيم. بعد از اينكه داده‌ها بازيابي شد، آن را مي‌توانيم در يك برنامه كاربردي بكار برده و يا آن را تصحيح كنيم. جملات زير اين امكان را به ما مي‌دهند تا داده‌هاي داخل يك جدول پايگاه اطلاعاتي را پردازش كنيم:

s جمله INSERT (درج)

s جمله UPDATE (بهنگام سازي)

s جمله DELETE (حذف)

محصولاتي مثل اكسس، dBase IV يا فاكس پرو به شكل بسته نرم‌افزاري داراي ابزار مناسبي براي ورود، تصحيح و حذف ركوردهاي پايگاه داده‌اي مي‌باشند. يكي از دلايلي كه SQL جملات پردازش داده‌ها را تهيه كرده است اين است كه SQL در درجه اول به همراه برنامه‌هاي كاربردي استفاده مي‌شود و اين امكان را فراهم مي‌آورد تا با استفاده از ابزار كاربردي خود داده‌ها را تصحيح كنيد و برنامه نويس SQL نياز دارد كه داده‌ها را با استفاده از SQL به پايگاه داده‌اي برگرداند. به علاوه، بيشتر سيستم‌هاي بزرگ پايگاه داده‌ها براي اين طراحي نشده‌اند كه فقط ذهنيات طراح و برنامه‌نويس را دربرگيرند، بلكه اين سيستم‌ها براي اين طراحي شده‌اند كه در حجم بالا و در محيط‌هاي چند كاربره كار نمايند. طراحي اوليه در چنين سيستم‌هايي متكي به پرس و جوي بهينه و موتورهاي بازيابي داده‌هاست.

بيشتر سيستم‌هاي پايگاه داده‌اي رابطه‌اي ابزاري براي صدور و ورود داده‌ها تهيه كرده‌اند. اين داده‌ها معمولا به شكل يك فايل متن محدود شده‌اي ذخيره مي‌شوند. اغلب يك ساختار فايل ذخيره شده شامل اطلاعاتي درباره جدولي است كه وارد شده است. ابزاري مثل SQL * Loader در اوراكل BCP در SQL Seever، Import / Export در اكسس مايكروسافت.

 

درج داده‌ها با استفاده از جملهINSERT

جمله INSERT اين امكان را به ما مي‌دهد تا داده‌ها را وارد پايگاه داده‌اي كنيم. اين جمله مي‌تواند به دو جمله تقسيم شود:

INSERT … VALUES

INSERT … SELECT

 

در يك ركورد با استفاده از INSERT … VALUES

نحوه نگارش جمله INSERT … VALUES داده‌ها را به داخل يك جدول به شكل يك ركورد درج مي‌كند. اين جمله براي عمليات كوچكي كه درگير چند ركورد است، مناسب مي‌باشد. نحوه نگارش اين جمله به شكل زير است:

INSERT INTO table – name (column – namel, column – name2, …)

VALUES (nalue1 , value2, …)

فرمت اصلي جمله INSERT … VALUES با استفاده از ستون‌هايي كه مشخص نموده‌ايم يك ركورد به جدول اضافه مي‌كند و مقادير مربوطه را به داخل اين ستون‌ها اضافه مي‌نمايد.

در هنگام استفاده از اين جمله سه قاعده را بايد در موقع اضافه نمودن داده‌ها به جدول درنظر بگيريم:

1) بايد نوع داده مقادير بكار رفته با نوع داده فيلدهايي كه اضافه شده‌اند يكسان باشد.

2) اندازه داده‌ها بايد در قالب ستون گنجانده شوند. مثلا يك رشته 80 كاراكتري نمي‌تواند در داخل يك ستون 40 كاراكتري اضافه شود.

3) مكان داده در VALUES بايد مطابق مكان ستوني باشد كه بايد داده به آن ستون اضافه شود. (يعني اولين مقدار بايد به داخل اولين ستون و دومين مقدار به دومين ستون و ... اضافه شود).

توجه ـ در جمله INSERT، نام ستون الزامي نيست و اگر نام ستون قيد نشده باشد SQL مقادير را بر طبق شماره ستون‌هاي آنها قرار مي‌دهد. به عبارت ديگر، SQL اولين مقدار را در اولين ستون و دومين ستون را در دومين ستون و الي آخر درج مي‌كند.

INSERT INTO table – name

VALUES (value1, value2, …)

درج چندين ركورد با استفاده از جمله INSERT … SELECT :

جمله INSERT … SELECT هنگامي كاربرد دارد كه بخواهيم ركوردهاي زيادي را به يك جدول اضافه كنيم. در چنين حالتي جمله INSERT … SELECT خيلي مفيد است و اين امكان را به برنامه نويس مي‌دهد تا اطلاعاتي را از جدولي يا گروهي از جدول‌ها به داخل جدول ديگر منتقل كند.

نحوه نگارش جمله INSERT … SELECT بصورت زير است:

INSERT INTO table – name (column – namel, column – name2, …)

SELECT column – namel column – name2, …

FROM table – name

WHERE seaech – condition

در جمله INSERT … SELECTقواعد زير وجود دارد:

1) جمله SELECT نمي‌تواند رديف‌هايي از جدول را انتخاب كند كه در حال درج در آن هستيم.

2) تعداد ستون‌هاي جمله INSERT INTO بايد مساوي با تعداد ستون‌هاي برگشتي از جمله SELECT باشد.

3) نوعت داده‌ها در جمله INSERT INTO بايد مساوي با نوع داده‌هاي ستون‌هاي برگشتي از جمله SELECT باشد.

استفاده ديگر جمله INSERT … SELECT بازگرداندن جدولي است كه شما آن را حذف و يا ايجاد كرده‌ايد. (تهيه Back Up)

SELECT *

INTO new – table – name

FROM original – table – name

و يا:

INSERT INTO new – table – name

SELECT *

FROM original – table – name

حال مي‌توانيم تغييرات موردنظر را در جدول اصلي با خيالي راحت اعمال نماييم.

تغيير نوع داده‌هاي موجود با استفاده از جمله UPDATE

هدف از جمله UPDATE تغيير مقادير موجود ركوردهاست. نحوه نگارش اين جمله به شكل زير است:

UPDATE table – name

SET column – namel = new – valuel [ , column – name2 = new – value2, …]

WHERE search – condition

اين جمله شبه جمله WHERE را كنترل مي‌كند. براي تمام ركوردهاي جدول داده شده شبه جمله WHERE به مقدار TRUE ارزيابي مي‌شود و بهنگام مي‌گردد.

توجه ـ اگر شبه جمله WHERE را از جمله UPDATE حذف كنيم، تمام ركوردهاي داده شده با مقدار داده شده بهنگام مي‌شوند.

حذف اطلاعات به كمك جمله DELETE

علاوه بر اضافه كردن اطلاعات به پايگاه داده‌اي، مي‌توانيم آنها را از پايگاه اطلاعاتي حذف كنيم. نحوه نگارش حذف به شكل زير است:

DELETE FROM table – name

WHERE condition

 

حذف تمام سطرها:

DELETE FROM table – name

و يا:

DELETE * FROM table – name

بسته به استفاده از جمله WHERE در جمله DELETE، SQL مي‌تواند كارهاي زير را انجام دهد:

ـ يك رديف را حذف كند.

ـ چندين رديف را حذف كند.

ـ تمام رديف‌ها را حذف كند.

ـ هيچ رديفي را حذف نكند.

در اينجا به چند نكته اشاره مي‌شود. وقتي از جمله DELETE استفاده مي‌كنيم:

s جمله DELETE نمي‌تواند يك فيلد را حذف كند. (به جاي آن از UPDATE استفاده مي‌كنيم)

s جمله DELETE تمام ركورد را از يك جدول حذف مي‌كند.

توجه ـ شبه UPDATE, INSERT، حذف ركوردها از يك جدول ممكن است باعث بروز مشكلات جامعيت در داخل جداول ديگر گردد. اين مطلب مهم را وقتي در داخل يك پايگاه داده‌اي مشغول تغيير هستيم، بايد درنظر داشته باشيم.