• Save
Intro to tsql
Upcoming SlideShare
Loading in...5
×
 

Intro to tsql

on

  • 431 views

 

Statistics

Views

Total Views
431
Views on SlideShare
431
Embed Views
0

Actions

Likes
1
Downloads
0
Comments
0

0 Embeds 0

No embeds

Accessibility

Categories

Upload Details

Uploaded via as Microsoft PowerPoint

Usage Rights

© All Rights Reserved

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Processing…
Post Comment
Edit your comment

Intro to tsql Intro to tsql Document Transcript

  • Introduction To SQL Unit 14 Modern Business Technology Introduction To TSQL Unit 14 Developed by Michael Hotek
  • Batches
    • Previously we can discussed batches of SQL statements
    • A brief review:
      • A batch is one or more SQL statements
      • If one statement in a batch is invalid, the entire batch is rejected
      • An object can not be created, dropped, and recreated in a batch
    • So, what does this have to do with stored procedures
    • A stored procedure is a batch of SQL statements
    • The only difference is that a batch is compiled at the time of execution and a stored procedure is already compiled
    Stored Procedures
  • Stored Procedures
    • A stored procedure is a collection of SQL statements that are stored under a name and executed
    • Allow many users to execute the same code
    • Provide a centralized and consistent implementation of code
    • Commonly used by
      • Frequently used queries
      • Business logic
      • Error handling routines
      • Repetitive administrative functions
  • Steps to Execution
    • When a SQL statement is executed, many things happen on the server
      • Parsing - the statement is parsed into a format SQL Server can handle for efficient operation
      • Syntax checking - During the parsing stage, the SQL is also checked for any syntax errors
      • Resolution - all objects are resolved to their internal representations (IDs)
      • Compile - The statement is compiled into machine language the server can execute
      • Query plan - A plan for executing the query is determined for the fastest access to data
    • All of this happens rather quickly on the server and is required for every statement you execute
  • Stored Procedures
    • When you create a stored procedure all of the steps of parsing, checking, compiling, etc. are carried out
    • When the user executes the stored procedure none of these steps need to be performed
    • This is what makes stored procedures execute more quickly than batches
  • Stored Procedures
    • The first time a stored procedure is executed, a query plan is built and stored
    • This query plan is determined by any arguments passed to the proc the first time and statistics SQL Server keeps
    • After the first execution, the stored query plan is used an does not need to be rebuilt
    • A stored procedure is not a shared object. Each concurrent user receives their own copy.
      • If two users simultaneously execute a stored procedure, there will actually be two copies of the object executing (one for each user)
  • Benefits
    • Execute faster than the same set of commands run as a batch
      • The code is already compiled
      • No query plan needs to be created
      • The code generally resides in memory
    • Reduce network traffic
      • You are sending an exec proc command instead if the entire batch of SQL across the network
    • Enforce consistency
      • Commands are executed the same
      • Error handling is standardized
    • Provide security
      • Users can be given execution permission on a stored procedure that modifies data instead of permission to directly modify the table
    • Modular design
  • Creating
    • To create a stored procedure, you issue the create procedure command
    • create procedure proc_name
    • as
      • SQL statement or batch
    • return
    • The stored procedure is stored in the current database, but it can access objects in other databases
    • The create procedure command can not be combined with any other statements in a single batch
  • Guidelines
    • Manage the source code of your stored procs the same as you would any other code in the development process
    • Even though the DBMS will return at the end of a proc, always end a procedure with the return statement
    • Develop naming, commenting, and documentation standards for all of your stored procedures.
      • Makes procedures more readable
      • Simplifies identification of procedures
      • Reduces the administrative overhead
  • Valid Statements
    • Just about any SQL statement can be included in a stored procedure except:
      • create view
      • create rule
      • create default
      • create procedure
      • create trigger
      • use
    • Not being able to issue a use can be at times be limiting, so be careful to plan where the stored procedures are located
  • Naming
    • One little known fact for SQL Server (Sybase and MS) is that any procedure named sp_… is treated as a system stored procedure and can be executed with a database different than the one created in
    • You can cause the stored procedure to execute in the context of another database simply be preceding it with a database name
    • (exec pubs..sp_test)
  • Executing
    • To execute a stored procedure, the user issues an execute proc command
    • execute proc_name or exec proc_name
    • You can leave off the exec if the statement is the first statement in a batch, but this is very poor programming
    • Procedures can be called from:
      • Batches
      • Other stored procedures
      • Triggers
      • Other programs
  • Stored Procedures
    • To view the source code for a stored procedure, you would use the sp_helptext (or the equivalent) stored procedure
      • exec sp_helptext myproc
    • You can rename a procedure with sp_rename
      • exec sp_rename myproc sp_myproc
    • To delete (drop) a procedure, issue the drop procedure command
      • drop procedure myproc
      • You must drop a procedure before you create one with the same name
      • When you change the source code for the procedure
  • Input Parameters
    • Stored procedures can accept input parameters. (Most procs are constructed this way.)
    • An input parameter is nothing more than a variable that is supplied a value when the user executes the proc
    • The input parameter(s) are defined within the stored procedure
    • This increases the flexibility of the procedure
  • Input Parameters
    • create procedure proc_name
    • (@parameter datatype
    • [,@parameter datatype…])
    • as
      • SQL batch
    • return
    • --Single input parameter
    • create procedure myproc
    • (@name vahrchar(40))
    • as
    • select * from authors where au_lname = @name
    • return
    • exec myproc ‘Smith’
  • Input Parameters
    • Parameter names can be up to 30 characters including the @
    • There can be up to 255 parameters in a procedure
    • A value passed to a procedure can contain a wildcard character as long as the parameter is used in a like clause
    • An object name can not be passed as a parameter
  • Executing Procedures
    • A procedure with parameters can be executed two ways:
      • by name
      • by position
    • When a proc is executed by name, the input parameter is explicitly referenced
      • exec myproc @name = ‘Smith’
    • When called by position, the arguments are in the order the parameters were defined
      • exec myproc ‘Smith’
    • You will very rarely execute a procedure by name. But, executing by name is more self-documenting
  • Multiple Parameters
    • You can define more than one parameter for a stored procedure
    • create proc myproc
    • (@var1 int, @var2 int, @var3 char(2))
    • as…
  • Default Value
    • You do not have to always pass the same number of arguments that have been defined in the procedure
    • To allow this, input parameters can be defined with default values
    • create procedure proc_name
    • (@parameter datatype = default
    • [,@parameter datatype = default…])
    • as
      • SQL batch
    • return
  • Default Values
    • When executing a procedure, you must pass values for all parameters that do not have defaults assigned to them
    • If a parameter is optional, or is usually assigned a particular value, assign a default to that parameter
  • Common Errors
    • Values are not compatible with the defined datatype
    • Parameters are passed via mixed methods; some by name, some by position
    • One or more parameters is missing
    • Parameters are passed in the wrong order
  • Stored Procedures
    • Sometimes we need to return values from a stored procedure
    • This is accomplished with output parameters
      • This is not supported in all DBMSs
    • create procedure proc_name
    • (@parameter datatype = default
    • [,@parameter datatype = default…]
    • [,@parameter datatype output…])
    • as
  • Error Handling
    • You should always implement error handling in your stored procedures
    • This includes the use of
      • raiserror
      • transactions
      • return status
    • To debug your stored procedures, make use of the print statement to inform you of states of variables and execution branches
    • Just make sure to remove these before the procedure goes into production
  • Output Values
    • create procedure myproc
    • (@book_id char(6),
    • @total_sales int output)
    • as
    • select @total_sales = sum(qty)
      • from salesdetail
      • where title_id = @book_id
    • return
    • declare @total int
    • exec myproc 'PS2091' @total output
    • select @total
    • --------
    • 2045
  • Return Status
    • Every procedure will return a status
      • 0 for successful completion
      • -1 to -99 for errors
    • Use a return statement to specify a return value
      • return 10
    • The return statement does not accept a variable. (This is what the output parameter is for.)
    • When returning values from your procedure do not use one of the reserved numbers from SQL Server
  • Comments
    • Add comments to document functionality
    • Establish standards to promote consistency
    • Suggestions
      • Break large single statements across multiple lines
      • Create a common header for all procs
        • Purpose
        • Return values/data
        • How to use
        • Description of each parameter and variable
        • Modification history
        • Author, mod date, and creation date
          • I generally don't identify the author, but this is preference
  • Comments
    • Suggestions con't:
      • Include all comments after the as statement
        • Any comments included before the as statement will not get included
      • Do all variable declarations and assignment selects in a block
    • Example
    • (Can be found at http://www.mssqlserver.com/articles)
  • Transaction Control
    • Establish a transaction mode (chained or unchained) for your application -- Sybase only
    • Establish a consistent error handling strategy for any failed transaction
    • Implement standard procedure templates and transaction control in nested stored procedures to maintain consistency
  • @@trancount
    • @@trancount contains the nesting level of transaction
    • Each begin tran increments the variable
    • Each commit decrements the variable
    • Rollback resets @@trancount to 0
    • begin tran --@@trancount = 1
    • begin tran --@@trancount = 2
    • begin tran --@@trancount = 3
    • commit --@@trancount = 2
    • rollback --@@trancount = 0
  • Nested Procedures
    • You can nest procedures (have one procedure that calls another) up to 16 levels deep
    • create proc…
    • exec proc2...
    • exec proc3...
    • return
  • Nesting
    • A stored procedure containing a transaction can contain another procedure containing a transaction
    • Use @@trancount to keep track of the nesting level
    • After a commit or rollback in an inner nested procedure, will cause subsequent statements in the outer batch to execute
    • Keep in mind the effect of commit and rollback on @@trancount
  • Nesting and Savepoints
    • Nested transactions that contain savepoints, if rolled back, will not cause the outermost transaction to be rolled back
    • In order to achieve this effect, you must explicitly name the savepoint
    • save tran xyz...
    • rollback tran --Roll back to the savepoint
    • save tran xyz…
    • rollback --Rolls back everything
  • Server Cursors
    • Server cursors are cursors that execute within a stored procedure
    • They are declared and used exactly as was explained in the cursors unit
    • create proc…
    • declare mycursor for…
    • open mycursor…
    • fetch mycursor
    • close mycursor
    • deallocate mycursor
    • return
  • Cursor Scope
    • A stored procedure can access the cursors that are declared outside the procedure or in other procedures in the call tree
    • If a proc pA declares a cursor cA and then calls proc pB, pB can access cursor cA
    • If pB declares a cursor cA, then the cursor in pA is no longer available to pB or any procedures that it calls
  • Standards
    • Add defaults to all input arguments
    • Check for missing arguments and print a usage statement
    • Check the validity of parameters
    • Include return status for error handling
    • Print meaningful messages for the user
    • Comment your code
  • Restrictions
    • Some SQL statements can not be used
    • Create tables before you refer to them
    • A table can not be created, dropped, and recreated in the same procedure
    • You must drop a procedure before creating another one of the same name
    • Procedures can be nested up to 16 levels deep
  • Notes
    • Stored procedures can reference objects in another database
    • Temporary tables created in a procedure are dropped when the procedure ends
    • Set options in a procedure stay in effect for the duration of the procedure and are reset when it ends
  • Dependencies
    • Stored procedures operate on one or more objects in a database(s)
    • Use the sp_depends stored procedure to get a list of objects the stored procedure references
    • sp_depends proc_name
  • Recompile
    • A query plan is created the first time a procedure is executed
    • Sometimes, the query plan is out of date or a different query plan should be used
    • To cause SQL Server not recreate the query plan, use the with recompile option
    • create proc…
    • with recompile
    • as...
  • Recompile
    • Use the with recompile only when there is no way to predict the best query plan at compile time
    • You can also do this on a one time basis by specifying the with recompile in the execute statement
    • exec myproc with recompile
    • This is generally done to update a query plan with the statistics now available to the DBMS
  • Unit 14 Review
    • A stored procedure is a batch of SQL that is compiled and stored in a database
    • Some SQL statements can not be used in a procedure
    • A stored procedure can use input parameters to increase the flexibility of the procedure
    • Input parameters can be created with default values
    • Output parameters can be used to return values
    • Every procedure will give a return status
    • Comments should be placed in procedures to document the code
    • A procedure will take on the current transaction mode the session is working under
    • Transactions can be nested
    • @@trancount keeps track of the current nesting level
      • begin increments
      • commit decrements
      • rollback sets to 0
    • Stored procedures can see cursors declared within their calling tree
    • Use the with recompile option to recreate a query plan
  • Unit 14 Exercises
    • Time allotted for exercises is 1 hour