9 September
These are some notes that I took while studying for my MCSD final exam on SQL server 2000. There are some good things in here and some things that might not make sense until I organize them and put them into a nice little paper.
Linked Servers
- sp_linkedservers lists linked servers
- If you want different passwords between linked servers, you have to map the usernames by creating a user account on each server and then calling sp_addlinkedsrvlogin (nameofserver, currentcredentials, localloginname, remoteloginname, loginpassword on remote server).
- Use fully qualified name of remote server to query.
- Must drop username links before dropping linked servers.
Views
WITH CHECK OPTION for Views
Prevents users accessing the view from editing the values in such a way that the data would not get selected by the view.
INDEXED VIEWS
Allow data that is retrieved frequently to be retrieved faster and must use ansii nulls option on. A clustered index must be created first.
UNION
Should be used to join two tables in a view from different disparate databases and order by must be specified outside of view.
COALESCE selects one or the other
To compile queries remotely use the OPENQUERY function, only to be used with linked servers.
OPENDATASOURCE in FROM can be used to access non-linked remote servers in T-SQL by passing all params when the function is called.
OPENROWSET is used just like OPENDATASOURCE to query data remotely.
Complex Updates
- UPDATE T1 SET Column2 = 25, Column3 = 250, WHERE Column1 = 2
- Must specify table names in updates with ambigous columns from 2 tables or table in from or where clause.
- After aliasing a table name you cannot use the table name.
- You can specify table aliases in FROM statement
Inserts
- If you use a different number of columns for an insert than the table contains you must specify the columns.
- INSERT Table1 SELECT * FROM Table2 only works for direct column type mappings or int to character. You can also optionally specify columns to insert from destination and source.
- INSERT INTO with SELECT only used for small queries Simple Query
- Use BCP for large text file imports. Export from source to text, insert to destination from text. Cannot delete rows if they are used in foreign key relationships.
**DELETE WITH JOIN EXAMPLE**
Delete od
FROM [Order Details[ od JOIN Orders o
ON od.OrderID = o.OrderID WHERE DATEPAET (yy, OrderDate) =1996
Cursors
- Forward only, fast forward only, Scrollable, Dynamic, Sensitive
- Changes made outside the cursor are visible
- Supports positioned updates and deletions, unless defined as read-only
Concurrency Control
- Read-only cursors do not lock the rows from outside changes
- Optimistic checks if a row is modified (important not to lock data but only one transaction can succeed)
- Client refreshes the cursor if cursor is modified
(TWO METHODS FOR CHECKING CONCURRENCY)
- Row Versioning, timestamp column, columns must include the rowversion data type
- With Values, checks the row checksum
Pessemistic (guaranteed transaction) ... All changes will succeed
- Cursor Implementations
- Client Cursors (Default rowset is returned to client)
- Server Cursors (T-SQL or API based)
Database APIs
- OLE DB
- ODBC
- DB-LIBARY - Legacy only supports up to 6.5, Still support SQL 7.0 but can not use new SQL server features.
- ADO - High level API used with any programming language that supports Active X. Encapsulates OLE DB and ODBC. Limits some of their inherited functionality.
- Client Cursors (Cached Rows on client)
- Implemented internally by ODBC, DB-Library, or ADO.
- Are not available in T-SQL- DB returns full resultset for each query
- Increased memory requirements on clients
- Supports forward only and static, NOT Dynamic
- Support all select statements
- Server Cursors
- Can be defined by DECLARE CURSOR statements (can fetch only one row at a time)
- Can be defined by using DB APIs (can fetch multiple rows at a time)
- No multiple rowsets
- Do not support COMPUTE, COMPUTE BY, FOR BROWSE, INTO
- Do NOT mix T-SQL (DECLARE CURSOR) and API cursors (DB-Libarary, ODBC, OLE DB)
- OPEN cursor always starts before first row. Must use FETCH NEXT to start at the first
- OPEN cursor is default forward only.
- Free cursor resources using DEALLOCATE [cursorname]
- DECLARE [cursorname] CURSOR SCROLL to declare a scrollable cursor
- FETCH to retrieve rows in specific positions ABSOLUTE
- FETCH relative grabs a row relative to the cursor's current position
- DELETE [cursorname] WHERE CURRENT OF [cursorname]
When to use default resultset vs. cursors
- when using full resultset
- when it is not necessary to visually analyze data in order to target specific rows
- use client cursor to scroll through large result sets (static forward only, support all select statements)
- use server cursor to perform positioned updates after visually analyzing the returned rows
- use API cursors to fetch multiple rows
- dynamic cursors open faster
- keyset-driven and static cursors usually work faster in joins
- use optimistic concurrency control to maintain high concurrency
- use pessimistic concurrency control to ensure that each attempted update succeeds
Working with XML
Note: FOR XML must be added to select statement
RAW
- each row is presented as an element with 'row' as the identifier
- tabular
- rows appear in the same order as the select list
- all elements are at the same level
- IE requires that there is a top level element
- you can specify the root node as part of the param using root word
AUTO
- Each table is represented by an element
- corresponding attributes are columns
- tables are nested in the order in which they are selected with the columns listed
- specify with elements so that the nodes are in elements rather than attributes
EXPLICIT
- use this to specify the format of the XML in the query
- use column names and attribute names in the query in order to markup the schema
- specify element in the column to specify element based output in XML rather than attribute based output
- used for full control of XML outputs
Extracting relational data
- OPENXML
DECLARE @idoc int, @doc nvarchar (1000)
**EXEC sp_xml_preparedocument [@docout] OUTPUT, [@docinput]
SELECT * FROM OPENXML (@idoc, 'Root/Customers')
- Schemas must be matching to specify schema using WITH [schemaname]
- Remove the internal document sp_xml_removedocument
- schemas on the fly must specify each node after WITH statement ([columnname int '../@xmlattributename]), <<xpath
- XPATH is case sensitive
- flags are used for element centric data, must specify schemas or else values will be null
Programming Business Logic Transactions
- A logically complete unit of work
- all data in logically consistent state
- changes to data must be permanent during system failures
- Concurrent transaction are isolated from others
- Programmers are responsible for the logical consistency
- SQL Server is responsible for the physical integrity of data
Transaction Modes
- Autocommit - each T-SQL statement is a separate transaction
- compile time errors do not build transaction plans but table"runtime"errors do execute
- Explicit - a user explicitly starts and ends transactions (auto rollbacks on failure) constraint violations must correctly be rolled back by users
- must specify rollback when failure occurs and all changes will be rolled back.
- the only reason SQL will rollback automatically is if a connection failure has occured
- if commit is called even if the transaction threw an exception, then data will be corrupted
- Implicit will automatically rollback
> SET IMPLICIT_TRANSACTIONs ON will prompt you to commit transaction when disconnect occurs
Isolation Levels (ordered by increasing isolation)
- READ UNCOMMITTED - allows dirty, or uncommitted, data to be read
- READ COMMITTED - allows only committed data to be read (locks data from being read)
- REPEATABLE READ - prevents other users from updating or deleting selected data
- SERIALIZABLE - prevents other users from making any changes to selectable, reduced concurrency, must release locks
Deadlocks
- Occurs when one transaction is attempting to change data when another transaction has already performed a lock.
- Error 1205 will occur if they both lock the data. The second transaction is the deadlock victim
- Deadlock is lifted when first transaction finishes
Efficient Transactions
- Keep transactions short
- Avoid user interaction within a transaction
- Open a transaction only to modify data
- Minimize the use of implicit transaction mode
- Minimize the amount of data targeted by a transaction
- Use lower transaction isolation levels (improve concurrency)
- When using cursors, specify optimistic concurrency control
- Design transactions to occur in the same order as the data
Error handling
- check for errors after each statement but use RETURN to stop processing
- @@ERROR returns the last error, it returns 0 if an error does not occur
- BEGIN and END are control statements
Stored Procedures
- Input parameters
- use @paramatername datatype and use comma to separate. Up to 2100 parameters can be used
- AS comes after parameter list
- Output paramaters
Triggers Special type of stored procedures
> Trigger Mechanics
- When INSERT, UPDATE and DELETE statements can fire triggers
- INSTEAD OF triggers fire instead of triggering statements and before contraints
- Only one INSTEAD of trigger can be created for each type of statement
- AFTER triggers fire after triggering statements
- Multiple AFTER triggers of the same type can be created on the same table
- Triggers are event-driven stored procedures; they are called automatically when specified data modifications are attempted
- Triggers provide functionality that goes beyond that of constraints
- Instead of triggers are executed instead of
- After triggers are fired after
Tuning and Optimizing Data Access
> Methods for optimizing query performance
- Application Design
- Minimize network usage (batches)
- only return required rows and columns SET NOCOUNT ON to eliminate the number of rows count
- Cursors require more round trips. Limit cursor usage
- Use stored procedures and avoid ad hoc queiries (send only params)
- Move logic to data
- Allow applications to cancel their queries (no reboots)
- Follow the recommended practices for minimizing deadlocks
- Keep queries and transactions as short as possible
- Always specify time-out periods
SQL Profiler
- Is a graphical SQL Server monitoring tool
- Capture information about events
- Save to file or table
- Replay trace events at normal speed or one at a time
- Trace information can be used to identify and address performance issues and other problems:
- Debugging stored procedures
- Identifying long-running queries
- Auditing user access to instances of SQL server
- Use filters to specify certain aspects to look for
- Create templates for your own custom traces
Index Tuning Wizard
- Tune custom selects or profiler results
- Schedule and save the scripts for index tuning
- Can apply changes now or later
- Can view or Edit the tuning wizard script
Statistics
- Provide statistical information about the distribution of values in a column
- Are automatically created on all indexed columns at the time of index creation
- Can be created automatically or manually on non-indexed columns
- Are used by the query processor to determine optimal data access strategies for query execution
- Can be updated automatically or manually
- Updating statistics is important but we should disable automatic statistics during business hours
- (sp_updatestats
> Most optimization happens at the client
> Optimize at design time
> Use stored procs in client apps
> Use SQL profiler to debug and optimize stored procedures and batches used in application (locking, deadlocking, security violations)
> Use the Index Tuning wizard to modify indexes in order to optimize a specified set of queries
> Statistics on indexed columns are created automatically.Statistics need to be up-to-date
Using Indexes to Optimize Data Access
- Non clustered indexes are sorted in DESC order
- B Tree is the start of a subindex
- Each subrange is divided into two more subranges and 4 3rd level nodes.
- This occurs until only one pointer exists pointing to the location on the hard drive where that row resides
- In a clustered index the table index starts at the top and works its way down
- Built in the same manner as the B-Tree
- Clustered index are used as pointers to rows to a non clustered index
> Fill factor
- Page splits cause index fragmentation
- Drop and recreate indexes
- Specify the fill factor to specify how much data the table will initially require
> Indexing strategies
- Indexes on tables with many rows are better than small tables
- Indexes on columns with unique values are more efficient than indexes on columns with many duplicate values
- A clustered unique index is automatically created on primary key in each table
- Too many indexes adversely affect the performance of INSERT, UPDATE and DELETE statements
- A large number of indexes may improve the performance of select statements
- A single composite index on multiple columns is more efficient than a separate index on each of those columns
- A clustered index should be as narrow as possible
- Clustered indexes are especially efficient on columns that have to be sorted or searched for ranges of values
- Always list columns in appropriate order when using composite indexes
- create indexes to find WHERE clause or JOIN condition data
- Create clustered indexes on columns frequently search for reange of values
- Create non-clustered indexes on columns frequently searched for exact matches
- Create composite covering indexes for columns all contained in the select (greatly improves performance)
- In composite indexes, list columns with higher cardinality before columns with lower cardinality
- When creating indexes, specify appropriate fill factors to minimize fragmentation
- Drop and rebuild indexes to eliminate existing fragmentation
- Periodically rebuild indexes and update statistics to improve performance
Designing database security
> Providing Direct Access to Data
Logins
- Provides access to particular instance of SQL Server
- Standard logins can be used from within third-party operating systems
- Windows-based logins use integrated windows authentication
Configuring logins
- sp_addlogin [loginname], [password] to add logins SQL authentication (3rd party OSs)
- sp_grantlogin [domain\loginname] for granting a domain user account to SQL
- sp_grantlogin [domain\groupname] for granting a domain group
Server Roles
- Include logins
- Only use existing roles
- Roles specify tasks that the user can do
Database User Accounts
- Are specific to a particular database
- Are mapped to databases
- sp_grantdbaccess [loginname], [dbuseraccountname] in context connection of the db
- each database must have a user for the login that is trying to access it and must be mapped
sp_grantdbaccess
- the username does not have to be the same as the loginname
- to remove the linked access use sp_revokedbaccess [username]
- mapping windows mapped user accounts is different format than sql auth sp_grantdbaccess 'Demo\Anne'
Database Roles
- Are similar to windows user groups
- Are specific to a particular database
- can include user and group accounts
- Are fixed and cannot be deleted or changed
- public is similar to everyone role
- implicitly provide users with specific permissions
- sp_addrole [rolename]
- sp_addrolemember [rolemembername]
Managing Permissions
- Statement Permissions control statement level permissions
- Are assigned in a particular database
- Control the ability of users to create databases
- Database specific
- Assigned to roles and users of the DB
- (Grant, Deny, Revoke)
- GRANT CREATE TABLE TO [username]
- DENY CREATE VIEW TO [username]
- REVOKE CREATE TABLE TO [username]
- REVOKE [permissionname] FROM|TO [username] use FROM and TO interchangeably
- GRANT ALL TO [username] to grant all permissions in one step
- REVOKE ALL FROM [username]
- CREATE DATABASE permission is only controlled in the master database of SQL server
- Object permissions control ability to modify data in objects
- Can be assigned in a specific DB for specific objects
- (SELECT, INSERT, UPDATE, DELETE, EXEC, DRI (declare referential integrity))
- Can also be specified on individual columns
- Implied permissions are acquired through membership in fixed server or database roles and through object ownership
- May effective at the server, database or object levels
- May not be transferable
- (only admins or owners can delete or alter objects use dbddl for restricted authority for altering)
Effective permissions
- All non-conflicting permissions are combined
- Denied permissions override the corresponding permissions
- Last set of permissions overwrites earlier assigned permissions
- All permissions are assigned at column level but table level permissions overwrite each column level permissions
Roles permissions take precedence over user level permissions
Designing Security Solutions
- Application Roles (application security)
- Are specific to a particular database
- Can be used only by applications
- Program applications to use application roles rather than users
- Provide access from the security context
- sp_addapprole [rolename], [password]
- GRANT SELECT ON [tablename] to [rolename]
- sp_setapprole [rolename], [password] will set the role of the user to the specified role
- grant access to guest account for databases
- Microsoft excel uses application roles
Ownership Chains
- Owns a set of objects that form a chain of reference
- sp_addsrvrolemember [username], [rolename]
- sp_changeobjectowner [objectname], [username] basically drops the object, clears permissions, and adds the user as the owner
- if dbo and the current user are not the object owner then you must qualify the object name
- Using Views, Functions, and procedures as security
- You can query tables below views as long as the users are the same or the user access has access to both objects (the same rule applies to sprocs)
- Users can only perform activities in the application roles, views, and procedures.
Security Solutions
- Can not restrict access to rowsets but can restrict access to views and revoke underlying table access from public.
Security Solutions2
- Use table valued functions to update data in underlying tables and restrict access to a specific rowset and the current user with USER_NAME in subselect