1. Input Variables

2. Input Variables with SELECT and UPDATE Statements

3. Exercise:  Pass Data to a SELECT Stored Procedure

4. Conclusion

5. Database script for SPFORBEGINNERS (the database referenced in this article)

At the end, I have also included a SQL script for creating the database used in my examples. It is a small database, and easily replicated.

What Are Stored Procedures?

Have you ever written SQL statements, like inserts, selects, and updates? Then you have already written most of a stored procedure. A stored procedure is an already written SQL statement that is saved in the database. If you find yourself using the same query over and over again, it would make sense to put it into a stored procedure. When you put this SQL statement in a stored procedure, you can then run the stored procedure from the database’s command environment.
An example is:

exec usp_displayallusers

The name of the stored procedure is “usp_displayallusers”, and “exec” tells SQL Server to execute the code in the stored procedure. (Note: “usp_” in front of the stored procedure name is used to designate this stored procedure as a user-created stored procedure.) The code inside the stored procedure can be something as simple as:

SELECT * FROM USERLIST

This “select” statement will return all data in the USERLIST table. You may think, skeptically, that stored procedures aren’t terribly useful. Just save the query and run it when you need to. Too easy, right?

Well, there is more to the story. Many queries get more complex than “select * from . . .”  Also, you may want to call the stored procedure from an application, such as an ASP page, Visual Basic application, or a Java servlet. With a stored procedure, you can store all the logic in the database, and use a simple command to call the stored procedure. Later, if you decide to use J2EE, you only need to change the application layer, which will be significantly easier. Much of the business logic will remain in the database.

Enough background—let’s write some stored procedures.

Getting Started with Stored Procedures

What do I need to get started? I have heard that question often. To begin writing stored procedures, the following are essential:

1. A database management system.

2. A database built inside the database management system (see the end of this article for a sample).

3. A text editor, such as Notepad or Query Analyzer.

Items 1 and 2 are absolutely essential. You can’t write stored procedures without a database. They would be useless. Sometimes, I write my procedures in Notepad (or another text editor), and copy them into the New Stored Procedure window in My SQL Server.

Next, you will have to decide what you want your stored procedure to do. It can be tempting to just dive right into the task at hand, but it is always prudent to sketch out some ideas first. Some considerations should be:

* Do you want to view data in the database (SELECT), insert new records (INSERT INTO), or do I want to change an existing record (UPDATE)?

* With which tables will you have to work? Does it make sense to create a VIEW first?

* How often will this procedure actually be used?

Once you have struggled with these questions (something of an exaggeration, I guess), you will be ready to start coding!

Note: Throughout this article, I will focus on stored procedures for My SQL Server. You can apply the same principles to other database management systems, but I will make clear references to working in a My SQL Server environment.

You May Consider this things also

Before creating a stored procedure, consider that:

* CREATE PROCEDURE statements cannot be combined with other SQL statements in a single batch.

* To create procedures, you must have CREATE PROCEDURE permission in the database and ALTER permission on the schema in which the procedure is being created. For CLR stored procedures, you must either own the assembly referenced in <method_specifier>, or have REFERENCES permission on that assembly.

* Stored procedures are schema-scoped objects, and their names must follow the rules for identifiers.

* You can create a stored procedure only in the current database.

When creating a stored procedure, you should specify:

* Any input parameters and output parameters to the calling procedure or batch.

* The programming statements that perform operations in the database, including calling other procedures.

* The status value returned to the calling procedure or batch to indicate success or failure (and the reason for failure).

* Any error handling statements needed to catch and handle potential errors.

Error handing functions such as ERROR_LINE and ERROR_PROCEDURE can be specified in the stored procedure.

Related Post

Q)  How can you load the drivers?
A) Loading the driver or drivers you want to use is very simple and involves just one line of code. If, for example, you want to use the JDBC-ODBC Bridge driver, the following code will load it:

Class.forName(”sun.jdbc.odbc.JdbcOdbcDriver”);

Your driver documentation will give you the class name to use. For instance, if the class name is jdbc.DriverXYZ, you would load the driver with the following line of code:

Class.forName(”jdbc.DriverXYZ”);

Q)  What will Class.forName do while loading drivers?
A) It is used to create an instance of a driver and register it with the DriverManager. When you have loaded a driver, it is available for making a connection with a DBMS.

Q)  How can you make the connection?
A) To establish a connection you need to have the appropriate driver connect to the DBMS. The following line of code illustrates the general idea:

String url = “jdbc:odbc:Fred”;
Connection con = DriverManager.getConnection(url, “Fernanda”, “J8?);

Q)  How can you create JDBC statements and what are they?
A) A Statement object is what sends your SQL statement to the DBMS. You simply create a Statement object and then execute it, supplying the appropriate execute method with the SQL statement you want to send. For a SELECT statement, the method to use is executeQuery. For statements that create or modify tables, themethod to use is executeUpdate. It takes an instance of an active connection to create a Statement object. In the following example, we use our Connection object con to create the Statement object

Statement stmt = con.createStatement();

Q)  How can you retrieve data from the ResultSet?
A) JDBC returns results in a ResultSet object, so we need to declare an instance of the class ResultSet to hold our results. The following code demonstrates declaring the ResultSet object rs.
ResultSet rs = stmt.executeQuery(”SELECT COF_NAME, PRICE FROM

COFFEES”);
String s = rs.getString(”COF_NAME”);
The method getString is invoked on the ResultSet object rs, so getString() will retrieve (get) the value stored in the column COF_NAME in the current row of rs.

Q)  What are the different types of Statements?
A) Regular statement (use createStatement method), prepared statement (use prepareStatement method) and callable statement (use prepareCall)

Q) How can you use PreparedStatement?
A) This special type of statement is derived from class Statement.If you need a  Statement object to execute many times, it will normally make sense to use a PreparedStatement object instead. The advantage to this is that in most cases, this SQL statement will be sent to the DBMS right away, where it will be compiled. As a result, the PreparedStatement object contains not just an SQL statement, but an SQL statement that has been precompiled. This means that when the PreparedStatement is executed, the DBMS can just run the PreparedStatement’s SQL statement without having to compile it first.
PreparedStatement updateSales =
con.prepareStatement(“UPDATE COFFEES SET SALES = ? WHERE COF_NAME LIKE ?”);

Q)  What does setAutoCommit do?
A) When a connection is created, it is in auto-commit mode. This means that each individual SQL statement is treated as a transaction and will be automatically committed right after it is executed. The way to allow two or more statements to be grouped into a transaction is to disable auto-commit mode:
con.setAutoCommit(false);
Once auto-commit mode is disabled, no SQL statements will be committed until you call the method commit explicitly.
con.setAutoCommit(false);
PreparedStatement updateSales =
con.prepareStatement( “UPDATE COFFEES SET SALES = ? WHERE COF_NAME LIKE ?”);
updateSales.setInt(1, 50); updateSales.setString(2, “Colombian”);
updateSales.executeUpdate();
PreparedStatement updateTotal =
con.prepareStatement(“UPDATE COFFEES SET TOTAL = TOTAL + ? WHERE COF_NAME LIKE ?”);
updateTotal.setInt(1, 50);
updateTotal.setString(2, “Colombian”);
updateTotal.executeUpdate();
con.commit();
con.setAutoCommit(true);

Q) How do you call a stored procedure from JDBC?
A) The first step is to create a CallableStatement object. As with Statement an and PreparedStatement objects, this is done with an open Connection object. A CallableStatement object contains a call to a stored procedure.

CallableStatement cs = con.prepareCall(“{call SHOW_SUPPLIERS}”);
ResultSet rs = cs.executeQuery();

Q)  How do I retrieve warnings?
A) SQLWarning objects are a subclass of SQLException that deal with database access warnings. Warnings do not stop the execution of an application, as exceptions do; they simply alert the user that something did not happen as planned. A warning can be reported on a Connection object, a Statement object (including PreparedStatement and CallableStatement objects), or a ResultSet object. Each of these  classes has a getWarnings method, which you must invoke in order to see the first warning reported on the calling object:
SQLWarning warning = stmt.getWarnings();
if (warning != null)
{
System.out.println(“n—Warning—n”);
while (warning != null)
{
System.out.println(“Message: ” + warning.getMessage());
System.out.println(“SQLState: ” + warning.getSQLState());
System.out.print(“Vendor error code: “);
System.out.println(warning.getErrorCode());
System.out.println(“”);
warning = warning.getNextWarning();
}
}

Q)  How can you move the cursor in scrollable result sets?
A) One of the new features in the JDBC 2.0 API is the ability to move a result set’s cursor backward as well as forward. There are also methods that let you move the cursor to a particular row and check the position of the cursor.
Statement stmt = con.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE,ResultSet.CONCUR_READ_ONLY);
ResultSet srs = stmt.executeQuery(”SELECT COF_NAME, PRICE FROM COFFEES”);
The first argument is one of three constants added to the ResultSet API to indicate the type of a ResultSet object: TYPE_FORWARD_ONLY, TYPE_SCROLL_INSENSITIVE , and TYPE_SCROLL_SENSITIVE. The second argument is one of two ResultSet constants for specifying whether a result set is read-only or updatable: CONCUR_READ_ONLY and CONCUR_UPDATABLE. The point to remember here is that if you specify a type, you must also specify whether it is read-only or updatable. Also, you must specify the type first, and because both parameters are of type int , the compiler will not complain if you switch the order.

Specifying the constant TYPE_FORWARD_ONLY creates a nonscrollable result set, that is, one in which the cursor moves only forward. If you do not specify any constants for the type and updatability of a ResultSet object, you will automatically get one that is TYPE_FORWARD_ONLY and CONCUR_READ_ONLY.

Q)  What’s the difference between TYPE_SCROLL_INSENSITIVE , and TYPE_SCROLL_SENSITIVE?
A) You will get a scrollable ResultSet object if you specify one of these ResultSet constants.The difference between the two has to do with whether a result set reflects changes that are made to it while it is open and whether certain methods can be called to detect these changes. Generally speaking, a result set that is TYPE_SCROLL_INSENSITIVE does not reflect changes made while it is still open and one that is TYPE_SCROLL_SENSITIVE does. All three types of result sets will make changes visible if they are closed and then reopened:
Statement stmt = con.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_READ_ONLY);
ResultSet srs = stmt.executeQuery(“SELECT COF_NAME, PRICE FROM COFFEES”);
srs.afterLast();
while (srs.previous())
{
String name = srs.getString(“COF_NAME”);
float price = srs.getFloat(“PRICE”);
System.out.println(name + ” ” + price);
}

Q)  How to Make Updates to Updatable Result Sets?
A) Another new feature in the JDBC 2.0 API is the ability to update rows in a result set using methods in the Java programming language rather than having to send an SQL command. But before you can take advantage of this capability, you need to create a ResultSet object that is updatable. In order to do this, you supply the
ResultSet constant CONCUR_UPDATABLE to the createStatement method.
Connection con =DriverManager.getConnection(“jdbc:mySubprotocol:mySubName”);
Statement stmt =con.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE,ResultSet.CONCUR_UPDATABLE);
ResultSet uprs =stmt.executeQuery(“SELECT COF_NAME, PRICE FROM COFFEES”);

Random Posts

Q) Is java.sql.DriverManager a class or an Interface ?
A) It’s a class. This class provides the static getConnection method, through which the database connection is obtained.

Q)  Is java.sql.Connection a class or an Interface ?
A) java.sql.Connection is an interface. The implmentation is provided by the vendor specific Driver.

Q)  Is java.sql.Statement a class or an Interface ?
A) java.sql.Statement,java.sql.PreparedStatement and java.sql.CallableStatement are interfaces.

Q)  Which interface do PreparedStatement extend?
A) java.sql.Statement

9) Which interface do CallableStatement extend?
A) CallableStatement extends PreparedStatement.

Q) What is the purpose Class.forName(“”) method?
A) The Class.forName(“”) method is used to load the driver.

Q) Do you mean that Class.forName(“”) method can only be used to load a driver?
A) The Class.forName(“”) method can be used to load any class, not just the database vendor driver class.

Q)  Which statement throws ClassNotFoundException in SQL code block? and why?
A) Class.forName(“”) method throws ClassNotFoundException. This exception is thrown when the JVM is not able to find the class in the classpath.

Q)  What exception does Class.forName() throw?
A) ClassNotFoundException.

Q)  What is the return type of Class.forName() method ?
A) java.lang.Class

Q)  Can an Interface be instantiated? If not, justify and explain the following line of code:
A) Connection con = DriverManager.getConnection(“dsd”,”sds”,”adsd”);
An interface cannot be instantiated. But reference can be made to a interface. When a reference is made to interface, the refered object should have implemented all the abstract methods of the interface. In the above mentioned line, DriverManager.getConnection method returns Connection Object with implementation for all abstract methods.

Q)  What type of a method is getConnection()?
A) static method.

Q)  What is the return type for getConnection() method?
A) Connection object.

Q) What is the return type for executeQuery() method?
A) ResultSet

Q)  What is the return type for executeUpdate() method and what does the return type indicate?
A) int. It indicates the no of records affected by the query.

Q) What is the return type for execute() method and what does the return type indicate?
A) boolean. It indicates whether the query executed sucessfully or not.

Q)  is Resultset a Classor an interface?
A) Resultset is an interface.

Q)  What is the advantage of PrepareStatement over Statement?
A) PreparedStatements are precompiled and so performance is better. PreparedStatement objects can be reused with passing different values to the queries.

Q)  What is the use of CallableStatement?
A) CallableStatement is used to execute Stored Procedures.

Q)  Name the method, which is used to prepare CallableStatement?
A) CallableStament.prepareCall().

Random Posts