Module 2 The data structures usage and access to these data methods from the

methods from the information systems

first defined by Edgar Codd on the principle that relationships

between database tables could be defined by the programmer rather than implicitly in the database definition. This improved on the flexibility of the hierarchical database and allowed the programmer to join any two tables together on any common field as required at the application level.
The relational model defines tables as a collection of fields (domains) which contain values stored as records (tuples) in the table. Each record must have a primary key which uniquely identifies the occurrence of the record within the table. Fields are defined as numeric, character, date and so forth and may or may not contain values. A relational database can distinguish between a blank or zero and an empty or null value.
The programmer may define a join between two tables on any common field. This is usually determined by the database designer who includes foreign key values in the child data file that contain primary key values of the parent data file to allow corresponding records to match up. The programmer may however join tables on any field or fields of the same data type in both tables to create a many-to-one or one-to-one relationship. Note that many-to-many relationships may not be implemented in a relational database and are implemented with a virtual link table containing foreign key relationships to each of the parent tables.
A Database Management System (DBMS) usually has a database definition language (DDL) which allows for the field types and tables to be defined and a data manipulation language (DML) which allows for the retrieval and update of data. The manipulation language often comes in several formats allowing access to the database from a variety of programming languages.

definition and data manipulation language called Structured Query Language or

SQL (pronounced Sequel). This was implemented in IBM's first relational database product and has now become the standard for most relational database systems. Many older hierarchical and network database management systems also allow data manipulation by interpreting SQL syntax to perform operations on data stored in more traditional logical database formats.
SQL Server History
Sybase
Sybase come into the fray over ten years ago as a pure implementation of an RDBMS taking into account many of the technical refinements of the first generation RDBMS. The implementation is functionally equivalent and an effective competitor to relational database products from Oracle, Ingres and IBM DB2. Sybase runs on many large UNIX computers and is compatible to a large extent with SQL Server.
SQL Server 4.2
Microsoft licensed Sybase technology for use on their operating systems and SQL Server is an implementation of Sybase 4.2 on the OS/2 and Windows NT platforms. The NT version offers the technical advantages of the Sybase implementation coupled with a visual administration tool and very cost effective transaction rates.
SQL Server 6.0
SQL Server 6.0 is a rewrite of the original SQL Server product that takes advantage of the Windows NT Operating System and allows remote management of a collection of enterprise wide servers. Microsoft are following an independent path from Sybase and have incorporated advanced features such as Replication and support for multi-processor hardware in this version.

improvements particularly in areas where many users are accessing the

same portion of a table for updates. This improves various contention scenarios when many users are attempting to add records and compete to add sequentially to a clustered index for example.
Replication is also much improved and can now replicate with other ODBC data sources as well as interface with Oracle or other more complicated corporate situations.
SQL Server 7.0
SQL Server 7.0 re-engineered the product to use native Windows NT files for a more logical integration with backup systems. Many of the configuration parameters became ‘self-tuning’ to avoid the need for a DBA on smaller systems.
SQL Server 2000
More improvements for the DBA including an index tuning wizard which suggests potential indexes to be placed on tables. Introduction of user defined functions and partitioned views and functionality to support XML

SQL Server Features
SQL Server is a fully fledged relational database server that runs on all versions of Microsoft Windows. The server software is licensed from Sybase and there is a high degree of compatibility with large scale Sybase servers.

transaction which is a programmer defined unit of work. The

programmer defines the beginning and the end of the transaction and any changes made to the data in the database are logged in a transaction log until the programmer completes the transaction with a Commit command. The database will then write all of the transactions into the database. If there are any problems in completing the transaction, for example a record locking deadlock occurs with another user, then the DBMS will Rollback the database as if the transaction never happened.
The transaction log may also help with database recovery in case of a hardware failure in that the database can be rolled forward using the transaction log from a previously saved state until the last fully completed database transaction.
Correct use of programmer defined transactions allows for the data stored in the database to be correct at all times even if a hardware failure interrupts the program flow.
Data Dictionary
Usually an RDBMS will support a data dictionary. This is a set of tables which are stored in each user database and are referred to as system tables. SQL Server maintains several system tables each containing information about different parts of a database. For example a system table, called SYSINDEXES, exists in each user database which contains information about all the indexes set-up on tables across the users database.
These system tables can be queried and viewed like any other table but are usually hidden from the user to avoid confusion and can also be accessed using system stored procedures.

to allow data to be checked by the database software

before it is added or modified in the database.  This has the advantage of ensuring that data is always valid as a program cannot pass in data that breaks a constraint and also allows these checks to be implemented once in the database software rather than in each application that updates the database.

Structured Query Language
The structured query language (SQL) used in SQL Server is very similar to the ANSI SQL standard. Following are a few examples of SQL commands, more detailed explanations of the commands available can be found in the Transact-SQL Reference manual supplied with SQL Server.

In addition to the standard SQL functions, SQL Server supports extensions to the traditional syntax to allow the implementation of outer joins and other enhancements to the language.
SQL Server also implements a programming version of the SQL language known as Transact SQL which is used in the definition of program scripts for triggers and stored procedures.

varchar(60),
telephone_number varchar(20),
rating tinyint)

Insertion of a record into a table:
INSERT INTO

TABLE contact
   (contact_id,
   name,
   address,
   telephone_number,
   rating)
   VALUES
   ('00003215',
   'John Brown',
   '67 North Street, Guildford, Surrey',
   '0327-7384629',
   8)

'01327-7384629',
   rating = 9
   WHERE contact.contact_id = '00003215'
Deletion of a

record:
DELETE contact
   FROM contact
   WHERE contact.contact_id = '00003215'

Enterprise Networking
SQL Server is part of the BackOffice suite of programs designed to run on Microsoft NT Advanced Server. The technology is suitable for Enterprise Networking where many NT Servers are situated throughout an organisation connected together in a Wide Area Network.
SQL Server may be installed on some or all of the servers to provide departmental databases. Programs may access more than one database if required. In addition, a SQL user may be configured as a remote user on another server so that the two servers communicate by automatically logging the user onto the second, remote, server to allow access to data.
Further facilities such as security that is integrated with network security, replication of data between servers, remote administration of servers from a workstation, and integration with electronic mail make SQL Server a good choice for a multi-server networked environment.

SQL Enterprise Manager which allows for the management of any server

on the LAN or WAN using client software running on Windows 95 or Windows NT.
Microsoft have implemented software components which can connect to SQL Server administration functionality for programmatic control of complex administration and system management.
SQL Server has a task management program that schedules activity at regular intervals. This activity includes the implementation of replication triggers which replicate data between servers.
The current Tasks can be viewed with the Tools-Task Scheduling… menu option in the SQL Enterprise Manager.
Task Scheduling Window

Network Configuration and the specification of physical devices for the

database is fairly straightforward. The database can take advantage of sophisticated operating system features such as RAID fault tolerant disks to supplement the security features of mirrored transaction logs.
Connectivity
Microsoft provide the latest ODBC and OLEDB drivers for SQL Server to provide some of the highest connection speeds available from a variety of programming environments. ADO ActiveX data object provide a convenient way to manage OleDB data sources and a well integrated with a SQL Server environment.
Gateways exist to transparently connect a request for SQL Server data through to a Mainframe database.
Views
Views on data may be easily defined to allow local or global corporate database schemas to be defined and yet allow for the underlying local structure to be changed if required without affecting existing programs.
Triggers
Triggers allow programs to be executed on the server whenever data is updated to prevent updates or to perform processing,
Stored Procedures
Stored procedures are programs that run on the server using an enhanced form of SQL called Transact-SQL. This includes program control functionality and the facility to call external programs residing on the server such as electronic mail.

to perform tasks rather than calling a workstation process. This

is particularly relevant in high transaction systems which interface with other components of the computing infrastructure as network traffic is not a bottle-neck when the processing is performed solely on the server,
Replication
Data is published on one server and other servers are defined as subscribers to that data. The SQL Executive copies data regularly during the process of database synchronisation. Replicated data is not modifiable on the subscription databases.
User Defined Functions
User defined function (new in SQL 2000) allow Transact-SQL to be used to create a program that returns a single value or one that returns a cursor. The former allows re-usable functions to be used in program implementation and the latter provides a programmatic alternative to defining a View.
XML
XML has considerable support in SQL 2000 and allows fully formed XML files to be returned directly from a server stored procedure without the need of any further middleware.
HTML
SQL Server has been integrated with Internet Information Server to serve directly to an http: request. This can provide powerful functionality when used together with stored procedures return XML in combination with an XLST formatting file.

means of defining a database and its constituent tables. The

following procedures are covered in detail:
- Create a new database and set database parameters.
- Create a Table and constituent fields.
- Define additional properties on a field.
- Add default and check constraints to a field.
- Define a primary key.
- Define a foreign key and set up referential integrity constraints between tables.
- Create a user defined data type.
- Generate a SQL Script for the database objects.
Enterprise Manager
The Enterprise manager can be used to manage a number of SQL servers throughout the enterprise. Most options are made available by navigating the tree structure of the Enterprise Manager and right clicking on the desired option.
Each installation of SQL Server has several system databases:
MASTER contains many configuration details of the server including details of the schema for each database. It is important that this database is backed up whenever changes are made to the structure of any of the databases as it is very difficult to repair a system if the MASTER database is missing.
The MODEL is used as the template to create a new database.
MSDB is used by the SQL Agent for holding details of scheduled jobs created to do housekeeping tasks such as backing up databases.
TEMPDB is used for temporary storage during everyday use of the database. This includes temporary tables created in stored procedures and other working tables.

Server machine which runs SQL Server programs as a network

service. The Client workstation makes a request to the SQL Server service running on the NT Server which performs the database retrieval before returning the required data to the workstation.
The database files are usually stored on the server machine and a database needs to be set up to hold the physical files for each database application. This task is often performed by the database administrator so that a new empty database is provided for the programmer to configure.
Each database has two physical files. One contains the data and the other contains the log. Data is written to the database and a record of each transaction is made in the log file. If the database file becomes corrupted, it can be restored from a backup and the transaction log rolled forward to restore the database.

It is recommended that the Database and the Log are stored on separate physical devices. This allows the database to be recreated from a backup and the transaction log if the physical disk containing the database files is corrupted.

A new database is created by right clicking on the databases option in the tree view of the enterprise manager and selecting the New Database option (also available from the Action menu option).
Provide an appropriate size for the database and preferably define a maximum size. Allow the database to grow by a reasonable amount each time so the system is not constantly redefining the database size. Place the transaction log on a separate physical disk dive if possible. The log is usually 10-15% of database size.

used to create a new database.
It is advisable to backup

the MASTER database each time changes are made to any database on the server.

database and right clicking on the TABLE tree to select

the NEW TABLE option.

Create a Table

Create a Table with SQL Enterprise Manager

must be used for each field:

Integer: int, smallint, tinyint, bigint.
Exact

Numeric: decimal, numeric.
Approximate Numeric: float, real.
Money: money, smallmoney.
Character data: char(n), varchar(n).
Binary data binary(n), varbinary(n).
Date and time: datetime, smalldatetime.
Text and Image text, image.
Other: bit, timestamp, sql_variant, user defined.
Unicode: nchar(n). nvarchar(n), ntext.
Identifier uniqueidentifier

SQL Server field types are copied from the MODEL database each time a new database is created and may be added to by defining user defined data types.

requirements will vary according to the business requirements of the

application:

A market research database may have very large amounts of data and numeric field types should be selected with a view to the storage requirements. A SMALLINT integer field will need less space than a FLOAT field for example. Be careful when using TINYINT however as the maximum allowable value is 255.

Numeric accuracy is important in financial applications and allowance should be given for the requirement to store fractions as decimals particularly for stock market applications. Some fractions may require many decimal places to be stored accurately. DECIMAL is often the most precise data type for numerical values.

The MONEY data type is normally the best for storing currency values

The VARCHAR data type allows character data of variable length to be stored at the cost of an extra bit for each value to store the width of the field. VARCHAR is not appropriate for very short field lengths or for fields where the width is relatively constant throughout the table (a single byte is used to store the length of each value).

TEXT and IMAGE fields store data in 2K chucks by default to a maximum of 8,000 bytes. It is recommended that Null values are permitted if there are a large number of empty values in the table. In some applications it may be more efficient to store the data as external files and use network protocols to access them.

Unicode data types use two bytes for each character and allow a variety of international characters to be stored.

is recommended that the ALLOW NULLS option is deactivated for

each field to prevent problems when inserting records. A default value for each field should be defined in the properties for the field as shown below.
Field Properties

Other options allow the precise format of numeric fields to be set and unique identifier functions to be set on candidate primary leys for the table.
FORMULA is used to set up a calculated field and COLLATION is used to set a specific sort order on the field. These options are rarely used.

Table Ownership
Tables are referred to with a four part qualifier:
SELECT * FROM servername.database.owner.table
The qualifiers can normally be omitted depending on the context. The following code ensures that the context is the PUBS database and so the database need not be qualified: USE pubs
SELECT * FROM authors
A system stored procedure can be used to change the ownership of an object as follows:
EXECUTE sp_changeobjectowner authors, dbo
It is recommended that all objects in a database are owned by the database owner: dbo.

on the DESIGN TABLE..option to bring up the DESIGN TABLE

window.
New fields are added by entering the new field definition at the bottom of the window. The name of existing fields can be changed and their widths altered by changing the appropriate values. Be careful when shrinking the field size as data may be lost. Defaults can be specified for a field by entering a constant in the column for defaults against the field. These are constant values specified for the individual field only.
Pressing the Save Table button saves any changes to the table. Definitions of keys and other table settings can be displayed with the Advanced Features option later in this chapter.

Table Designer

Null Values
Relational database theory differentiates between a null value for a field and a zero value. SQL Server can determine whether a value has never been entered against a numeric value (a null) or whether a zero has been entered by the user.
Null values are important in relational theory but can cause problems in application development if not used correctly. Arithmetic and Boolean operation on Null values can yield unexpected results.

transaction that attempts to add a record without a specific

value entered against particular fields. This is useful for forcing entry of numeric values, foreign key or lookup fields, and status flags.

Default Constraints
Defaults may be defined against a field to automatically enter a value when a new record is inserted into the table if the application has not entered a value.
Defaults can be useful with fields that are defined as NOT NULL as SQL Server will supply a value for the field if not specified by the application.
Defaults may be set by typing a value in against the DEFAULT field property when defining a field with the DESIGN TABLE window. The default must be specified as a constant value.
Specifying a Default Value

Defining a default value with the DESIGN TABLE window will automatically create a default constraint on the table. A field default constraint can also be added to (or dropped from) a table with a SQL data manipulation command as follows:

ALTER TABLE [authors] WITH NOCHECK ADD
CONSTRAINT [DF_authors_state] DEFAULT ('CA') FOR [state]

logic to check the values to be entered in a

field. The AUTHORS table could be altered to prevent further entry of any authors from Texas by setting a constraint which prevented the state field from being set to TX.

Check constraints may be entered with the SQL Enterprise Manager by selecting the appropriate Table object and rightclicking to edit the table. Pressing the ADVANCED FEATURES push button will bring up a Page which allows various constraints to be set. The Check Constraints page allows for simple checks to be made on the data.

SQL Server will not allow a value to be entered or modified that conflicts with the check constraint and will generate an appropriate error message if an attempt is made to violate the constraint:

Specifying a Check Constraint for a Table

are new with SQL Server 6.0 and replace the previous notion

of defining Defaults that are bound to fields. They are compatible with the latest SQL ALTER TABLE syntax.

Constraints can also be added with a SQL script by utilising the ALTER TABLE command:

ALTER TABLE authors
ADD CONSTRAINT CK_authors_city CHECK( city<>'gotham')

the Table design window by using selecting the required field

and using the SET PRIMARY KEY button represented by the key shape at the top of the table design window. Multiple fields may be selected to create a composite Primary Key.
Set the Primary Key in the Table Design Window

SQL Server automatically defines the required primary key index. The penultimate button on the right of the Table Designer toolbar allows the user to MANAGE INDEXES/KEYS.. and can be used to refine the primary key definition.
Fields that allow Nulls may not be specified as Primary Keys.

as an Identity column which is automatically incremented each time

a new record is added to create a unique value suitable as a primary key on a table. An initial seed value and an increment can also be set.

Identity columns are typically used as primary keys and have the advantage of being small in size and therefore fast for SQL Server to use when joining tables.

Specifying Identity Column Properties

Identity columns also provide a degree of data independence and can be a better design option than alternate candidate keys. An employee table, for example, has both the Staff Identifier and the National Insurance Number of the person as candidate keys. However the person cannot be added into the table until a Staff Identifier has been allocated causing problems in entering data before the person actually starts work. Similarly a National Insurance Number may not be immediately available or may change, forcing key values to be cascaded down any dependent tables. An independent identity column is a better primary key than either of the obvious candidate keys.

identity columns:

The @@IDENTITY system variable will indicate the value of

the primary key of the previously inserted record.
IDENT_CURRENT('person') will return the latest identity column value for the person table. Similarly IDENT_SEED and IDENT_INCR will return the seedand increment for the required table.
DBCC CHECKIDENT('person') will check that the values in the identity column are correctly defined for the table.
SET IDENTITY_INSERT OFF is required when inserting records where the value of the identity column is already known.
Only one identity column is allowed for each table and can be specified in a select statement as follows:

SELECT IDENTITYCOL, surname FROM person

Unique Identifiers
There are some problems with Identity Column keys particularly if a table is distributed over several servers and needs to be replicated. The UNIQUEIDENTIFIER data type has similar properties but is a 16 character globally unique identifier that is automatically defined by setting the default value to NEWID() in the field properties.
Unique Identifiers can be represented with the field name or the ROWGUIDCOL keyword in a SELECT command:
SELECT ROWGUIDCOL, surname FROM person
UNIQUEIDENTIFIER fields are larger than integer fields and care should be taken using them on very large tables.

created when a primary key is defined using the Table

Designer. The MANAGE INDEXES/KEYS.. button on the right of the Table Designer allows all indexes, including primary keys, to be defined in more detail.

The Primary Key is comprised of one or more fields that do not allow null values. Composite Keys can be defined by selecting a second column for the Primary Key. Select the Clustered option if the table is to be physically ordered in the sequence of the Primary Key.

for manipulating data:
SELECT existing data from one or more tables.
INSERT

a new record into a table.
DELETE one or more records from a table.
UPDATE existing records in a table.

This section explains these commands with particular reference to the flexibility of the SELECT command. The Query Analyser available from the TOOLS menu of the SQL Executive should be used to run the examples against the PUBS database.

pubs
The pubs database is installed together with SQL Server and is used in most of the examples in this book. This small database contains data referring to book publishers and the titles they publish alongside details of the authors that write the titles and the stores that sell them.

A SQL batch program called INSTPUBS.SQL is installed with SQL Server to allow the reinstallation of a fresh PUBS database for training purposes. Please ask your system manager to install a new PUBS database if required.

a set of data from existing tables in the database.

The syntax of the command is designed to define a set of data which includes the fields (columns) and the set of records (rows) which should be selected.
The structure of the command is as follows:

Field List
The select list is the list of fields or expressions that are required in the selected table. These correspond to the fields in the result set:
SELECT au_fname, au_lname FROM authors
The asterisk can also be used to select all fields from a table.
SELECT * FROM authors
An alias can be given to the field name to rename the field in the result table:
SELECT au_lname AS surname, au_fname AS firstname FROM authors

au_lname + au_fname AS fullname FROM authors
Expressions can be used

in the select list:
SELECT s.*, t.price, qty * price AS qtyprice
   FROM sales s
   INNER JOIN titles t ON s.title_id = t.title_id
Scalar functions can be applied to fields or expressions for more complex queries:
SELECT UPPER(au_lname), CAST(address + ',' + city + ',' +
   state + space(1) + zip as varchar(45))
   FROM authors
WHERE Clause
The WHERE clause is used to narrow down the rows selected for the result table.
SELECT * FROM authors WHERE au_lname = 'White'
AND and OR and NOT can be used:
SELECT * FROM authors
   WHERE (state = 'CA' or state = 'UT')
   AND (NOT contract = 1)
The IN clause can be used instead of OR:
SELECT * FROM authors
   WHERE state IN ('CA','UT')

between given values:
SELECT * FROM titles WHERE price BEWTEEN 10.00

AND 29.00
NULL values can be identified in a WHERE clause:
SELECT * FROM stores WHERE zip IS NULL
The TOP n clause can be used to limit the number of records returned from a SELECT command.

Wild Cards
Wild cards can be used in selection criteria, for example to select any AUTHORS containing the letter 'a' in the surname:
SELECT * FROM authors WHERE au_lname LIKE '%A%*'
The LIKE syntax allows a wide variety of pattern matching templates. The above example utilises the % character as a wild card symbolising any sequence of characters. Angle brackets are used to define a range of characters. The following example to picks out book titles with an identifier beginning with a character in the range B to M:
SELECT * FROM titles WHERE title_id LIKE '[B-M]%'
The underscore character indicates any single character, # any single digit, angle brackets picks any single character within the brackets, and [^] will pick any character not within the angle brackets. This example selects Titles which do not have P or M as the first letter of the identifier and have 1 as the third character:
SELECT * FROM titles
   WHERE title_id LIKE '[^PM]_1%'

of the wild cards to be used as a literal

in the expression. This example finds any occurrence of the % character in the PAYTERMS field of the STORES table:
SELECT * from sales
   WHERE payterms LIKE '%\%%' ESCAPE '\'
SQL Server is often configured not to be case sensitive. You may need to check this option or use expressions of the form WHERE UPPER(au_lname) = 'SMITH'.
FROM Clause
The FROM clause specifies which tables are involved in the SELECT statement. The clause is mandatory:
SELECT * FROM authors
If more than one table is required in the query then they may be separated by commas:
SELECT * FROM titleauthor, authors, titles
   WHERE titleauthor.au_id = authors.au_id AND
   titleauthor.title_id = titles.title_id
The tables may be assigned an alias if required to shorten or provide an alternative name in the statement:
SELECT * FROM titleauthor ta, authors a, titles t
   WHERE ta.au_id = a.au_id AND
   ta.title_id = t.title_id

that uses the same table twice to show an employees

manager for example:
SELECT employee.surname, manager.surname ;
   FROM employee, employee manager ;
   WHERE employee.manager = manager.id
SQL Server uses a fully qualified name to identify a table. There are four parts to the fully qualified name:server.database.owner.table. The FROM clause can specify a table that is located in another database or even another table:
USE northwind
SELECT * FROM pubs.dbo.authors
ORDER BY
The ORDER BY clause allows for a result table to be ordered in any desired sequence:
SELECT * FROM authors ORDER BY au_lname, au_fname
The order sequence may also refer to the output fields in the result table using a number indicating the sequence of the field in the select list:
SELECT au_lname, au_fname FROM authors ORDER BY 2,1
The DESC keyword may be used to reverse the sort order of a column in the ORDER part of the SELECT statement:
SELECT title, ytd_sales, type as category
   FROM titles
   WHERE type = 'business'
   ORDER BY 2 DESC

together using the primary and foreign keys. Relational databases allow

for any two tables to be joined together with an expression in the first table matching any expression in the second table as long as the width and data type of the expression is identical.
Joins allow considerable flexibility to the programmer in joining tables together although, nearly always, the programmer will want to join one table to another using the foreign and primary keys.
SELECT * FROM titleauthor ta, authors a, titles t
    WHERE ta.au_id = a.au_id AND
   ta.title_id = t.title_id
The more modern syntax for a natural join is to use the INNER JOIN syntax as follows:
SELECT * FROM titleauthor ta
   INNER JOIN authors a ON ta.au_id = a.au_id
   INNER JOIN titles t ON ta.title_id = t.title_id
Specifying two tables in a SELECT statement without specifying a join condition will create a Cartesian product of both tables. This means that a 100 record table joined to a 200 record table with no WHERE clause will create a 20,000 record result table.

the aggregate functions to count up the number of occurrences

of a value or to summate, average or perform statistical calculations on a table:
SELECT title_id, SUM(qty) AS totalsales 
  FROM sales  GROUP BY title_id
SELECT title_id, COUNT(*) FROM sales GROUP BY title_id
The following example shows the maximum, minimum and average order level for each title together with the total number of records for each title and a count of the number of different stores ordering the title:
SELECT title_id, COUNT(*) AS ordercount,
   COUNT(stor_id) AS storecount,
   MAX(qty) AS maxqty,
   MIN(qty) AS minqty,
   AVG(qty) AS avgqty,
   SUM(qty) AS sumqty
   FROM sales
   GROUP BY title_id
The ALL keyword can be used to include all the groupings present in the table even if there are no occurrences selected in the query. The aggregated fields for the additional groups are set as NULL values:

= 1994
   GROUP BY ALL title_id
The CUBE and ROLLUP options

on the GROUP BY command are specific to SQL Server and add additional summary records into the selection. This can help in creating results sets for complex management report.
Another aggregation command is the COMPUTE BY clause and remember that the SQL OLAP manager provides full management reporting facilities.

HAVING Clause
The WHERE clause filters the rows that are used in the query. The HAVING clause operates on a query that employs a GROUP BY clause but only after the grouping has been performed.
This allows the summary records to be selected on the basis of their aggregated values. The procedure is similar to performing a second WHERE selection on the final results table.
The following statement selects titles that have sold more than 50 copies:
SELECT title_id, COUNT(*) AS ordcount,
   FROM sales
   GROUP BY title_id
   HAVING ordcount > 50

used to prevent duplicate rows from appearing in the results

table.
The following command creates  a results table with one record for each Title Type in the TITLES table:
SELECT DISTINCT titles.type FROM titles
A similar result may be obtained with the GROUP BY clause.
Inner (Natural) Join
A natural join is the operation that joins tables together using a where clause or the more modern INNER JOIN syntax. The following statement will create a view that joins the TITLES and SALES  tables:
SELECT t.title_id, t.title, SUM(s.qty) AS totalqty
   FROM titles t
   INNER JOIN sales s ON t.title_id = s.title_id
   GROUP BY t.title_id, t.title
A natural, or inner, Join discussed above will only display records that qualify the join condition and that occur in both tables. A title that has no sales will not be included in the view.
Outer Join
An outer join allows for records to be displayed from either table even if there is no corresponding record on one or other side of the join. The Outer Join may be a left or right outer join depending on whether all the records in the first or the second table are required. A full outer join will include all records from both tables.

TITLES and the SALES tables allows all TITLES to be

displayed:
SELECT t.title_id, t.title, SUM(s.qty) AS totalqty
   FROM titles t
   LEFT OUTER JOIN sales s ON t.title_id = s.title_id
   GROUP BY t.title_id, t.title
Missing values where there are no corresponding SALES records for a Title are represented as NULL values.
A LEFT outer join includes all records from the table mentioned in the FROM clause, the RIGHT outer join includes all records from the joined table, and a FULL outer join includes all the records from both tables.

Sub Queries
Subqueries can be useful in creating views with complex selection criteria. The following example could be expressed as a normal JOIN and GROUP BY but is more clearly expressed as follows:
SELECT * FROM titles WHERE title_id IN
( SELECT title_id from sales 
   GROUP BY title_id
   HAVING SUM(qty)> 25  )
Subselections are particularly useful when working with views or temporary sets of data and can be used to check if records are in or not in another table

(SELECT title_id FROM sales s
   WHERE t.title_id = s.title_id )
This

same query could use the less specific NOT EXISTS clause:
SELECT * FROM titles t
   WHERE NOT EXISTS 
   (SELECT title_id FROM sales s
   WHERE t.title_id = s.title_id )
A join may always be expressed as a subquery

UNION
The UNION command can be used to create a single view from two tables with a similar structure. The following example creates a single table from the authors and employee tables:
SELECT
   a.au_id AS cid, a.au_lname AS lastname, a.au_fname AS fname
   FROM authors a
   UNION
   (SELECT e.emp_id AS cid, e.fname AS firstname,
   e.lname AS lastname FROM employee e)

UNION ALL keyword is specified.
Care needs to be taken where

the table structures are not identical The CAST or CONVERT scalar functions can be used to change a data type in a SELECT statement.
FOR XML mode [, XMLDATA] [, ELEMENTS][, BINARY BASE64]
SQL Server allows for rapid creation of XML from standard select statements. This is useful in creating components that use XML to communicate information:
SELECT * FROM authors
FOR XML AUTO
The modes are as follows:
AUTO defines an element with the same name as the table for each record and represents fields at attributes.
RAW uses an element names instead of the element named after the table.
EXPLICIT allows precise definition of the XML tree.
XMLDATA specifies full data type information using an external schema.
The ELEMENTS clause is used together with AUTO to include the columns of the select statement as sub-elements instead of attributes in the XML.
SELECT * FROM authors FOR XML AUTO, XMLDATA, ELEMENTS
SQL Server 2000 has additional commands that allow a stored procedure to read an XML file (OPENXML).
SELECT .. INTO

INTO command provided that the user has CREATE TABLE permissions

on the database.
SELECT *
   INTO contractauthor
   FROM authors
   WHERE contract = 1
INSERT Statement
The INSERT statement allows new records to be added into a table:
INSERT [INTO]
   {table_name | view_name} [(column_list)]
   {DEFAULT VALUES | values_list | select_statement}
The INSERT statement requires that the values satisfy any validation constraints specified on the table otherwise the transaction will fail.
INSERT INTO authors
   (au_id, au_lname, au_fname, contract )
   VALUES ( "999-99-9001", "Crook", "Stamati", 1 )
There are constraints defined on the Authors table that will prevent a new record from being added if the identifier is not unique or if the first name, last name, or contract field values are not specified
The INSERT command may also be used in combination with a SELECT statement to add records into a table:
INSERT INTO bestseller
   ( title_id, qty )
   SELECT title_id, SUM(qty) FROM sales s
   GROUP BY title_id
   HAVING SUM(qty) > 25

changed:
UPDATE {table_name | view_name}
SET [{table_name | view_name}]
  

{column_list
   | variable_list
   | variable_and_column_list}
      [, {column_list2
         | variable_list2
         | variable_and_column_list2}
         ...   [, {column_listN
               | variable_listN
               | variable_and_column_listN}]]
[WHERE clause]
The Update clause can be used to update any field and usually involves a WHERE clause. Take care to specify the WHERE clause carefully or all the records will be updated:
UPDATE authors
   SET au_lname = 'Crank',
      au_fname = 'Stanley'         
   WHERE au_lname = 'Crook'
The WHERE clause is often used in conjunction with the Primary Key expression to update a single record in the table.

table by making calculations using data from another table:
UPDATE sales
  

SET qtyprice = qty * (SELECT price
      FROM titles t WHERE sales.title_id = t.title_id )

DELETE Statement
The DELETE statement allows for deletion of table records using a WHERE clause to specify the records for deletion:
DELETE [FROM] {table_name | view_name}
   [WHERE clause]
The DELETE statement must satisfy any referential integrity constraints set up in the database before records are deleted:
DELETE authors
   WHERE au_lname = 'Crook'
The TRUNCATE TABLE authors command could be used to delete all the records in the table. Take care to backup after such a command because a Truncated Delete is not logged.

uniquely identify each occurrence in the table. A staff or

employee table, for example, may have a Staff Identifier and a National Insurance number entered for all staff. Each of these fields is unique to each occurrence and creating a unique index constraint on the field will ensure that duplicate values do not occur.
Indexes may be defined on a single field or a set of fields as a composite key which may be useful for optimising queries or for sorting data for a report or batch processing tasks.
If several fields are often involved in a query selection is good for performance to create a composite key. If some selections only use one or two of the fields then they should be defined as the first columns of the index otherwise the index will not be selected by the query optimiser.
ALTER TABLE person
   ADD CONSTRAINT IX_person
   UNIQUE NONCLUSTERED (id)

Clustered Index
A single clustered index may be defined on a table that physically sorts the records into the index order. This can speed up performance on a table if sequential access to a set of records is often needed in the sequence of the clustered index. Retrieval of individual records is not improved by a clustered index.

a clustered index. Many users entering new records simultaneously with

similar clustered index values will cause a performance bottle-neck as they all need to access the same part of the clustered index. This occurs particularly with date or timestamp values or incrementing primary keys when they are used as clustered indexed. The situation has improved with SQL Server 6.5 but is still not recommended.
There are more advanced options, discussed below, that can be defined against an index but are initially best avoided as they may result in part of a transaction failing with no indication to the user that some records have been ignored by the database engine.
Indexes are defined with the Manage Indexes window available by right clicking on the required Table in the SQL Enterprise Manager and selecting the Indexes option. The fields for the Table are displayed and can be moved into the Index by clicking the Add button. More than one field can be added to create composite keys.

when inserting new records into a table. The Ignore Duplicate

Row option causes records with duplicate rows, where a clustered index has been defined, to be ignored during a transaction without failing the whole transaction. In this case, duplicate rows are not inserted into the table but the remaining records are processed.
Similarly with the Ignore Duplicate Key option, attempts to insert a record with a duplicate key that has been defined as a unique index, will ignore only that record and continue with the remainder of the transaction.
The Allow Duplicate Rows option contradicts the principle of a primary key for each record and is required only in unusual circumstances.
Relational database tables should theoretically always have a unique primary key and therefore no duplicate rows. Microsoft Access, for example, will not allow updates on a table without a primary key.
Clustered Indexes allow for the Sorted Data checkbox to be specified so processing time is not wasted sorting the Index. The Index is not created however if the data is not sorted correctly.
Primary Key constraints can also be defined using SQL Server data manipulation language which automatically creates the appropriate index:
ALTER TABLE person
   ADD CONSTRAINT PK_person
   PRIMARY KEY CLUSTED (id)

of a relationship between tables and link a child table

to a parent table. The Foreign Key value should match directly to the value of the Primary Key.
Foreign Keys can be defined in SQL Server to automatically maintain the referential integrity of the table.  Select the MANAGE RELATIONSHIPS option in the DESIGN TABLE window to define a Foreign Key.

The fields for the Primary Key Table and the Foreign Key Table are entered in the respective columns on the RELATIONSHIPS page of the TABLE window to create the relationship.
Enforcing the relationship for INSERTS and UPDATES will create the referential integrity constraint so that no OWNER of a CAR can be entered without a corresponding record in the PERSON table.

field in this example allows NULL values so a CAR

can be defined without an OWNER by leaving the value as a NULL.
A cascading delete will automatically delete linked records in the Foreign table if the record in the Primary table is deleted. Similarly, a cascade update allows a key value to be changed in both the Primary and Foreign tables if the value of the identifier changes.
Triggers are no longer required to perform cascading deletes
Foreign Key constraints can also be added using SQL:
ALTER TABLE car ADD
   CONSTRAINT FK_car_person FOREIGN KEY
   ( owner ) REFERENCES person ( id )
   ON DELETE CASCADE 

defined data types within a database. These can be useful

to prevent inconsistencies in large database schemas where similar fields occur many times. A user defined data type might be defined for telephone and fax numbers, for example, to make sure all occurrences where of the same width throughout the database.
The outline view of the SQL Enterprise Manager can be used to define a user defined data type. The data type is then available for use when defining fields with the Table Designer.
User Defined Data Type Window

to define or drop user defined types from the database:
EXECUTE

sp_addtype udtphone varchar(20)
EXECUTE sp_droptype udtphone
EXECUTE sp_help udtphone
User defined data types may be defined in the MODEL database and are then automatically copied into each new database.

Defaults and Rules
These features were in popular use in earlier versions of SQL Server but have now been replaced with the use of constraints that have the advantage of being ANSI compatible and easier to define. Their use is not recommended.
Defaults
A collection of default values may be defined independently in the database and then bound to individual fields or to a user defined data type. Unfortunately, it seems that changing the value of the default requires all the default and all bindings to be dropped and recreated. The use of defaults has been replaced by ANSI compatible default constraints.
Rules
Simple validation rules (that reference only constant values) can also be defined in the database and bound to user defined data types or directly onto a field. These are now replaced with ANSI compatible check constraints.

new virtual table that behaves in a similar fashion to

the real tables in the database.
Views can be used to hide the complexity of the underlying database structure or to show a subset of data. They are useful in presenting summary or aggregated information to users for a Decision Support or Reporting Application. The view can be redefined if any changes are made to the underlying table structures without affecting any of the existing management reports.
Views are also useful in implementing security and performance requirements. A view can be defined to allow read/write access to a subset of data to which users are otherwise denied access.
A partitioned view allows several tables to be joined together (with the UNION command) and processing to be spread over different databases or servers for parallel processing and improved performance.
SQL Enterprise manager or the CREATE VIEW command is used to create views. Use the ALTER VIEW command to change existing views that have references made to them in stored procedures or triggers.
CREATE VIEW [.][.]view_name
[ (column[,...n])]  [ WITH [ ,...n ] ]  AS  select_statement  [ WITH CHECK OPTION ]
The following example creates the TITLEVIEW view by joining three tables together. The view can be used in exactly the same manner as a normal table and will update the underlying tables

au_ord, au_lname, price, ytd_sales, pub_id
   FROM titleauthor
   INNER

JOIN authors ON authors.au_id = titleauthor.au_id
   INNER JOIN titles ON titles.title_id = titleauthor.title_id

Care should be taken with the ownership of Views an the underlying tables. In general, it is best to have the database owner (dbo) as the owner of all views and tables. Use the sp_changeobjectowner system stored procedure to change ownership.

Any standard SELECT statement can be used including complex queries with UNION, GROUP BY, and HAVING. An ORDER BY clause however is not allowed unless used in conjunction with the TOP clause.

Views with  aggregate or computed fields in the SELECT syntax cannot be modified.

The sp_depends viewname and sp_helptext viewname system procedures will display the dependent columns and the syntax of the view respectively.

Indexed Views
Views that contain summary information need to retrieve the underlying information each time they are used by the calling application. Creating an index on the View forces SQL Server to retrieve and permanently store the index in the database vastly improving performance.
The SCHEMABINDING option must be used on a View before indexing is permitted:
CREATE VIEW
CREATE INDEX…
Maintaining an index on a View adds an overhead and should not be used on very volatile data that is frequently updated. Careful design of the index can yield fruitful results as the new Index can be used by the query optimiser in any query even if the View itself is not involved.
Check Option
Views are a great way to provide limited access to data for elected users. A View on an Employee table may be defined without any salary details and permissions denied on the original table to simplify security access for this sensitive data.
The CREATE VIEW syntax has a WITH CHECK OPTION that prevents data being added or modified within the view that cannot subsequently be retrieved from the view.
The following example creates a view that only shows authors with contracts and will not allow an author to be added or modified without the contract field having a value of one:

FROM authors
   WHERE contract = 1
  

WITH CHECK OPTION
Partitioned Views
A special case of Views that UNION several tables of identical structure is known as a partitioned view. These tables can be local, within a single database, or distributed on several databases, perhaps even on different servers.
The data is usually partitioned on some logical basis such as the inclusion of a country code in the table and a check constraint is set on each table so that the query optimiser can determine which tables to look at for a typical query.
The view is then created by UNIONing all the tables and an updateable partitioned View results. The advantage of spreading each table over different databases or servers allows the query to run in parallel on multiple processors or servers and can speed performance on very large databases.
A partitioned view over several databases or servers, with an index, can provide very powerful parallel processing facilities for very large databases.

connect to external datasources directly from the server. The following

example uses an ODBC datasource defined on the server to connect and retrieve data from a FoxPro table:

select * from openrowset( 'MSDASQL',
    'DSN=dsnfoxtastrade',
    'select * from shippers where company_name like ''U%''')

The OPENROWSET command is used for ad hoc queries and is much more flexible when a connection string is used rather than a pre-defined ODBC datasource.

Linked Servers
A linked server can be defined using the Security-Linked Servers option of the SQL Executive or thesp_addlinkedserver system stored procedure. This defines a permanent relationship between the SQL Server and another SQL Server or external datasource.
The following example adds a linked server, called FOXTASTRADE, to the current SQL Server using an existing ODBC datasource:

@srvproduct='foxpro',
   @provider='MSDASQL',
   @provstr='DSN=dsnfoxtastrade'
The MSDASQL is

the generic driver to connect to ODBC datasources. More specific drivers can be easily defined e from the Security-Linked Servers option in the SQL Executive.
The OPENQUERY() function can be used to execute a pass through query directly on the linked server and return a result:
SELECT * FROM
   OPENQUERY(foxtastrade,
   'select * from category where category_name like ''B%''')
The sp_serveroption system stored procedure may be required to set the default database options for the linked server (collation sequence, etc).
Distributed queries can also be run on linked server by using the full four part object reference:
select * from linkedserver01.pubs.dbo.authors

Information on the database schema contained inside a linked server can be obtained with the relevant system stored procedure: sp_linkedservers, sp_catalogs, sp_indexes, sp_tables_ex, sp_columns_ex.

Temporary Tables
Temporary tables can be created on the server using a SQL SELECT statement. These temporary tables can be used for reporting purposes or to perform interim calculations as part of a batch process.
Temporary Tables have their name prefixed with # or ## for local and global tables respectively. Local tables are only available for the current user session or perhaps just within the scope of a single stored procedure. Global temporary tables are available to all users of the database and are deleted only when the last session that refers to the table is closed.
The following command sets up a temporary table which all users can access:
select *
   into ##contractauthor
   from authors
   where contract = 1

The SELECT .. INTO .. syntax may also be used to create a new permanent table provided that the SELECT INTO/BULKCOPY database option is set to True:
exec sp_dboption 'pubs', 'select into', TRUE

which can be executed repetitively with a simple instruction to

the server. The programs are called Stored Procedures and consist of a series of Transact-SQL commands with structures to control program flow, receive parameters and return values and other features representing familiar programming principles.
One advantage of Stored Procedures is that they are executed on the server, performing a series of actions, before returning the results to the client. This allows a repetitive series of actions to take place with minimum network traffic and can considerably improve performance in many cases.
Security permissions can keep the underlying data hidden from the programmer to aid in more complex security requirements. For example, a stored procedure could be used to add bank account details to the database with access to the underlying table denied to the user.
Stored Procedures also have direct access to server resources and can call programs residing on the server to integrate with other systems or parts of the computer infrastructure.
Stored Procedures are created with the CREATE PROCEDURE command:
CREATE PROCedure [owner.]procedure_name[;number]
   [(parameter1 [, parameter2]...[parameter2100])]
[{FOR REPLICATION} | {WITH RECOMPILE}
   [{[WITH] | [,]} ENCRYPTION]]
AS sql_statements
Local and Global Temporary procedures can be created by prefixing the procedure name with a # or ## respectively.

maintain stored procedures instead of using the CREATE, ALTER, and

DROP PROCEDURE statements.

Creating a Stored Procedure

Stored Procedures may be renamed with the sp_rename system procedure.

[[EXECute]
{[@return_status =]
   {[[[server.]database.]owner.]procedure_name[;number] |
     

@procedure_name_var}
   [[@parameter_name =] {value | @variable [OUTPUT]
      [, [@parameter_name =] {value | @variable [OUTPUT]}]...]
   [WITH RECOMPILE]

Stored procedures may perform an action or sequence of actions and return a single value or a result set. To execute a stored procedure immediately you can use the SQL Query Analyser tool. Type in the keywordEXECUTE followed by the procedure name and any parameters. The result or result set is displayed in the Result window:
EXECUTE stpgetauthors

records have been selected along with other information. This can

be suppressed by issuing the SET NOCOUNT ON command at the beginning of the stored procedure.
Stored procedures can also be executed from inside triggers or other stored procedures using the EXECUTEcommand. This is useful as common code can be placed out into a stored procedure for software reuse. Nesting and recursion is allowed down to 32 levels and the @@NESTLEVEL system variable indicates how many levels down the application has passed.
The EXECUTE command can also parse a string or a variable to execute code that can vary according to the context. The following example will select from a table specified in a local variable:
DECLARE @tname varchar(20)
SELECT @tname='authors'
EXECUTE ('select * from ' + @tname)
Multiple commands can be executed with the EXECUTE command:
EXECUTE( 'set nocount on;' + 'execute stpgetauthors' )
The procedure name may even be placed inside a variable so that automated tasks can be performed from a table:
DECLARE @pname varchar(20)
SELECT @pname='byroyalty'
EXECUTE @pname 40

a procedure on a remote server may be run simply

by specifying the server name in the procedure execute command. The remote server needs to be defined by the SQL administrator so that the servers can communicate but there is no need to log onto the second server as the local server will handle the communication.
Passing Parameters
Stored procedures can accept parameters and these are held in variables preceded with an @ symbol. These variables need their type defined explicitly in the stored procedure.
The following example accepts a parameter and returns a results set with the Authors selected by Surname according to the parameter passed.
CREATE PROCEDURE stpgetauthors
   @surname varchar(30)
  AS
BEGIN
   SELECT * FROM authors
      WHERE au_lname LIKE @surname
END
The parameter is passed to the procedure as follows:
execute stpgetauthors '[a-d]%‘
Be careful when using SELECT * in a stored procedure as the fields are stored when the procedure is created or altered and may not reflect recent changes to the table structure.

parameters if none are entered by the user. The following

example defaults the parameter to null and causes an error message if no parameter is passed to the function.

CREATE PROCEDURE stpgetauthors
   @surname varchar(30)=null
 AS
BEGIN
   IF @surname = null
   BEGIN
      RAISERROR( 'No selection criteria provided !', 10, 1)
   END
   ELSE
   BEGIN
      SELECT * FROM authors
         WHERE au_lname LIKE @surname
   END
END
A stored procedure may have more than one parameter declared and values are passed to the procedure in the order that they are declared:
CREATE PROCEDURE stpMathTutor @x int =1, @y int =1 AS
BEGIN
   …
END

for x and 3 for y as follows:

EXECUTE stpMathTutor 2,3
Missing out the second parameter with the execute will cause the variable to take up the default value and so the following example will run the procedure with x as 2 and y as the default value of 1.
EXECUTE stpMathTutor 2
Parameters may also be declared explicitly in the Execute command allowing for them to be specified independently of the order in which they have been declared. The following example gives y a value of 3 and leaves x undefned to take the default value of 1:
EXECUTE strMathTutor @y = 3
 
Returning a Value
Stored procedures also have the ability to return a value. This is done by using the return command in the procedure:
CREATE PROCEDURE stpMathTutor
   @x int =1 ,
   @y int =1
AS
BEGIN
   RETURN @x + @y
END

the variable as follows:
DECLARE @equals int

EXECUTE @equals = stpMathTutor 2,3
SELECT @equals
SQL Server will default the return value to zero. The returned values are typically used to return a status flag from the stored procedure with a non-zero value usually indicating failure during processing.
Returned values are difficult to access using ODBC their use is recommended only to return a success or failure of the stored procedure when communicating with other stored procedures.
Output Parameters
Values may also be returned into an output parameter by a stored procedure in a similar fashion to other programming languages returning a value by reference. This is achieved by including the 'output' command after the output parameter in the procedure definition.
ALTER PROCEDURE stpMathTutor
   @result int output,
   @x int =1 ,
    @y int =1
AS
BEGIN
   set @result = @x + @y
END

in a variable for later use in the calling procedure

or trigger. The variable is called in the command line with a “output” modifier:
EXECUTE stpMathTutor @equals output, 2, 3

Executing the Math Tutor

Program

Structures
Transact SQL is primarily a set based language designed for processing sets of data using SQL statements. The language does contain control of flow structures similar to other programming languages.
The BEGIN…END statements are used to create a statement block around a series of Transact SQL statements.
BEGIN      {sql_statement | statement_block}  END
The IF…ELSE structure is used extensively inside triggers and stored procedures.
IF Boolean_expression        {sql_statement | statement_block} [ELSE [Boolean_expression]        {sql_statement | statement_block}]
 
The structure can use a SELECT statement to perform complex interrogations on data:
IF (SELECT SUM(qty) FROM inserted) > 500
BEGIN
    …
END
Remember the BEGIN…END structures around blocks of code otherwise only the first line is taken as part of the program flow.

 {sql_statement | statement_block}        [BREAK]      

 {sql_statement | statement_block}         [CONTINUE]

The WHILE statement can be used to perform a loop to process a cursor for example. This might be useful when complex sets of different updates and actions need to be performed for each record in a table or when a server cursor is processed.
GOTO can be useful in controlling program flow. A label is defined in the code by placing a line with a label name and a colon and the GOTO command will move program flow to the label. This is especially useful with complex triggers and stored procedures where rollback and updates need close control:
IF (SELECT SUM(qty) FROM inserted) = 0
   GOTO noprocessing
   …
noprocessing:
   …

with the RETURN statement that returns an integer value (default

is zero) to the calling program.
Comments can be placed in a stored procedure either with /* */ delimiters or with a double hyphen (--) to make the rest of a line into a comment.
/* Test the quantity */
IF @quantity = 0
   RETURN (-1) -- No processing required.
Local Variables
DECLARE @variable_name datatype
   [, @variable_name datatype...]
Local variables are used to store values within Transact-SQL. They must be declared before use and a datatype assigned.
The SELECT statement is then used to assign values to the variables.
SELECT @variable = {expression | select_statement}
   [, @variable = {expression | select_statement}...]
[FROM table_list]
[WHERE search_conditions]
[GROUP BY clause]
[HAVING clause]
[ORDER BY clause]

most programming languages:
DECLARE @xvalue int

SELECT @xvalue = 22
Values can be determined by a SELECT statement which queries the database and returns a single value:
DECLARE @titleqty int
SELECT @titleqty = (SELECT SUM(qty)
   FROM sales WHERE title_id = @titleid)
The SET statement can be used instead of SELECT to assign a value to a variable:
DECLARE @dialcountry varchar(20)
SET @dialcountry =
   CASE @dialprefix
      WHEN '44' THEN 'UK'
      WHEN '01' THEN 'USA'
      ELSE 'OTHER'
   END
If the SELECT command used with a local variable as the last line of a stored procedure then the value of the variable is returned as a one record results set to the calling application:
SELECT @xvalue AS x, @yvalue AS y

by SQL Server and do not have to be declared.

These are always available and indicate a variety of values.
For example:
@@error                      Error number
@@identity                   Latest identity value of newly inserted record
@@language                Language currently in use
@@max_connections    Maximum connections allowed to the server
@@rowcount                Number of records affected by last command
@@rowcount                Number of rows affected by last statement
@@servername                        SQL Server name
@@version                   Version number of SQL Server
Other system information is returned from scalar functions:
DB_NAME()                  Database Name
SUSER_SNAME()         NT User Name
USER_NAME()              SQL Server User Name
All of these system variables can be used as required within any Transact SQL code as shown in the following example:
CREATE PROCEDURE stpserverinfo AS
select db_name(), user_name(),suser_sname(), @@servername, @@max_connections, @@version, getdate()

an operation and return a single value. There are many

examples some of which are listed below:

Mathematical and trigonometric functions:
·                  abs(-22.33)
·                  pi()
·                  sin(30)
·                  cos(30)
·                  tan(30)
·                  rand(22)
·                  round(3.4456,2)

Date functions:
·                  datepart(yyyy,getdate())
·                  year(@datevalue)
·                  dateadd( yyyy, 2, @datevalue)
·                  datediff( yy, @datevalue,getdate() )
·                  month( @datevalue )

)

Miscellaneous:
·           cast('abc' as varchar(5))
·                  convert(int, 22.33)
·                  columnproperty( object_id('authors'),'city', 'allowsnull')
·                  isnull( @xvalue,0,1 )

Look at

the entry on 'scalar functions' in the online books for more information.

expression2] [...]]
   [ELSE expressionN]
END

The CASE expression is very useful for

assigning different values according to an expression for each record of a table. The following example will evaluate a description of the Authors contract status as a field in the results set according to the defined conditional rules:
SELECT *,
   'Contract Status' = CASE
      WHEN contract = 1 THEN 'Contracted'
      WHEN contract = 0 THEN 'No Contract'
      END
   FROM authors

The CASE expression can be used anywhere where an expression is required including in an Update statement to set values into a field.

SQL On-Line reference and shows a SELECT statement used within

a CASE to change the expression shown:

SELECT a.au_lname Surname, a.au_fname Forename,
   "Royalty Category" =
   CASE
      WHEN (SELECT AVG(royaltyper) FROM titleauthor ta
         WHERE t.title_id = ta.title_id) > 60
         THEN 'High Royalty'
      WHEN (SELECT AVG(royaltyper) FROM titleauthor ta
         WHERE t.title_id = ta.title_id)
         BETWEEN 41 and 59
         THEN 'Medium Royalty'
      ELSE 'Low Royalty'
   END
   FROM authors a, titles t, titleauthor ta
   WHERE a.au_id = ta.au_id AND ta.title_id = t.title_id
   ORDER BY 1,2,3

in a table and perform an action. For example a

housekeeping program might run through all the new orders in a sales database and send email messages to the account manager in instances where the delivery date is more than five days from the date of order.
Cursors allow for the selection of the records in a stored procedure and the sequential processing of each record. Scrollable cursors also allow movement forwards and backwards through the table.

DECLARE cursor_name CURSOR  [ LOCAL | GLOBAL ]  [ FORWARD_ONLY | SCROLL ]  [ STATIC | KEYSET | DYNAMIC | FAST_FORWARD ]  [ READ_ONLY | SCROLL_LOCKS | OPTIMISTIC ]  [ TYPE_WARNING ]  FOR select_statement  [ FOR UPDATE [ OF column_name [ ,...n ] ] ]

command can be used to move up and down the

cursor.

FETCH [[NEXT | PRIOR | FIRST | LAST | ABSOLUTE n | RELATIVE n] FROM] cursor_name
[INTO @variable_name1, @variable_name2, ...]

The @@FETCH_STATUS variable is set to zero after a successful FETCH and should always be checked before processing. A value of -1 indicates that the results set has been exceeded and -2 indicates that the cursor record is no longer a member of the original table.

Cursors are relatively slow and should not be used if more traditional set based processing is possible. Complex expressions can be created with the CASE expression within a SELECT statement and should be used in preference to a cursor whenever possible.

The following example illustrates the use of a cursor to process the records in a table one by one. The cursor is created from a SELECT statement and the OPEN command used to open the cursor. The value are FETCHed into variables that have already been defined and a WHILE loop used to process each record. The logic for each record is contained in the loop and mails a simple message.

@surname varchar (40)
DECLARE @message varchar (80)
DECLARE curAuthors CURSOR LOCAL
   FOR

SELECT au_id, au_fname, au_lname
   FROM authors WHERE contract = 1
   FOR READ ONLY
EXECUTE master..xp_startmail
 OPEN curAuthors
FETCH NEXT FROM curAuthors INTO @id, @firstname, @surname
WHILE (@@fetch_status <> -1)
BEGIN
   IF (@@fetch_status <> -2)
   BEGIN
      SELECT @message = @id + @firstname + @surname
      EXECUTE master..xp_sendmail 'stamati crook', @message
   END
   FETCH NEXT FROM curAuthors INTO @id, @firstname, @surname
END
DEALLOCATE curAuthors

you have finished it to prevent using too many server

resources.
An alternative to a WHILE loop is to use a program marker and the GOTO statement.
System Procedures
The MASTER database contains several system procedures which are created when SQL Server is installed. These procedures have 'sp_' as a prefix to their name and are used mainly for administration purposes. They can be accessed from any database as long as the user has access rights to the master database. The procedures can be copied into your own database and edited to suit your needs.
One example is the system procedure sp_depends which returns the  dependencies of a SQL Server table, view or procedure object. The procedure returns a result set indicating all the objects upon which the object depends and all those that depend on it.

EXECUTE sp_depends 'authors‘

There are many system procedures affecting all aspects of the database and server configuration. For example, batch scripts may be created to add users to a database. See the Transact SQL Reference manual for details.
There are hundreds of system stored procedures described in the online help. Some more useful system procedures are described below:

on the server automatically from a stored procedure or a

trigger run by the server.
The extended stored procedures are held in the MASTER database and may be used to interact with the server.

in the NT event log of the server without raising

any errors on the client application:

declare @logmessage varchar(100)
set @logmessage = suser_sname() + ': Attempted to access the bingo system.'
exec master..xp_logevent 50001, @logmessage

The XP_CMDSHELL command will run an operating system command on the server:

EXECUTE master..xp_cmdshell 'dir e:\*.*'

This functionality is very dangerous in the wrong hands as files may be deleted on the server or worse havoc caused.
An example extended procedure might call a Visual Basic program that runs on the server whenever an order is entered into the database which reads the SQL database in order to enter data into a FoxPro system that is used for Order Processing. This functionality could also be performed from the original application but implementing at the server level allows for orders to be created in a variety of front end implementations and yet always perform the required transactions.
DLLs may be created on the server and called within SQL Server as an extended procedure after registering the procedure with the sp_addextendedproc function.

the integration with Microsoft Mail. This allows an update trigger,

for example monitoring stock levels, to generate an electronic mail message whenever the stock level falls below the reorder level.
SQL Server can be configured to “Auto Start Mail Client” when the SQL Server Service is started or Mail can be run on the server before starting the SQL Server service. Alternatively the mail client may be started on the server with the following extended procedure:

EXECUTE master..xp_startmail 

The startmail extended procedure can accept username and password to start a particular mail session if the setup defaults are not acceptable.
Mail may be sent to a mail user as a simple mail message or with the attachments of a file or results from a SQL Query:

EXECUTE master..xp_sendmail 'stamati crook', 'Reorder Disks 20303 Please!'

The mail procedures require the full user name as parameters. The shortened mail name will create an error.

of an integrated Mail - Database Information strategy. There are

extended procedures to read mail and to process queries attached to mail messages and attach the results set into a mail message and so on.

Error Handling
Stored procedures return a zero value by default. The convention is to return a zero value if the stored procedure is successful and a non-zero value for a failure.

declare @returnvalue int
exec @returnvalue = stpgetauthors
if @returnvalue <> 0
begin

The RAISERROR command is used to create error messages from the server which are returned to the application. The command will return an error number and a message to the calling application error handle.

RAISERROR ({msg_id | msg_str}, severity, state
[, argument1 [, argument2]] )
[WITH LOG]

although only system administrators should use values above 18. The

convention is as follows:
·                  10 is for information only
·                  11-16 is for errors that can be corrected by the user
·                  17 is where system resources are exceeded
·                  18 is a non fatal system error
Severity levels 17 and above should be notified to the system administrator. The state is a number from 0 to 127 that can be used as you like.
Additional arguments can be included in an error message to provide additional information for a specific instance of the error. The following example raises an error and includes details of the author identifier and the number or records retrieved in the error message. It also records the error in the NT Event log of the server.
if @@rowcount <> 1
begin
    raiserror (
        'stpgetauthordetail: %s :Incorrect (%i) number of records found !',
        16,1,@authorid, @@rowcount ) with log
    return (2)
end
The default error number for a user created error is 50000. All user created errors should have an error number greater than 50000.

of error messages with the sp_addmessagestored procedure which stores a message

against an error number and severity:

sp_addmessage 52001,16,'%s : Incorrect Parameters !'

The error is called with the RAISERRROR command without the need to supply the message text each time. This also allows messages to be displayed in multiple languages or system alerts to be defined to notify the system administrator immediately a particular error occurs.

if @authorid = null
begin
   raiserror(52001,16,1,'stpgetauthordetail-authorid')
   return (-1)
end

The @@ERROR system variable can be used to control errors a little more closely. The following stored procedure updates the value of the ZIP field in the authors table. This field has a constraint and will only allow a five numeric value to be applied. The @@ERROR value is used to trap for an error and return an explanatory error message to the client.