Problem

You previously exported a DataSet to an XML file, and now you need to get it back.

Solution

Use the DataSet object’s ReadXML() method to restore data from a previously generated XML export.

Discussion

Recipe 13.9 exports some XML and a related schema for a table with state-specific information. To read it back into a DataSet object, use the following code:

	Dim stateSet As New Data.DataSet
	stateSet.ReadXmlSchema("c:StateSchema.xml")
	stateSet.ReadXml("c:StateInfo.xml")

You do not need to import a previously saved schema into a DataSet before retrieving the related data, but it helps. Without the schema,

Read More >>

Problem

You have some data in a DataSet object, and you would like to export it to an XML file for later reimportation.

Solution

Use the DataSet’s WriteXML() method to send the DataSet content to the file in a common XML format.

Discussion

Recipe 13.8 builds a DataTable object with two state-specific records. The following code adds that table to a DataSet object and writes its records to an XML file:

	Dim fullDataSet As New Data.DataSet
	fullDataSet.Tables.Add(stateTable)
	fullDataSet.WriteXml("C:StateInfo.xml")

These statements generate the following XML content:

	<?xml version="1.0" standalone="yes"?>
	<NewDataSet>
	  <UnitedStates>
	    <ShortName>WA</ShortName>
	    <FullName>Washington</FullName>
	    <Admission>1889-11-11T00:00:00-08:00</Admission>
	    <Population>5894121</Population>
	  </UnitedStates>
	  <UnitedStates>
	    <ShortName>MT</ShortName>
	    <FullName>Montana</FullName>
	    <Admission>1889-11-08T00:00:00-08:00</Admission>
	    <Population>902195</Population>
	  </UnitedStates>
	</NewDataSet>

You can also output the XML directly

Read More >>

Problem

You want to manage some data in a database-table-like fashion, but the source data is not coming from a database, or from anything that looks like a table.

Solution

Build a DataTable manually, and fill in all the table details and data yourself.

Discussion

The following code builds a simple table of state information and adds two records:

	Dim stateTable As DataTable = New DataTable("UnitedStates")

	' ----- Use the abbreviation as the primary key.
	Dim priKeyCol(0) As Data.DataColumn
	priKeyCol(0) = stateTable.Columns.Add("ShortName", GetType(String))
	stateTable.PrimaryKey = priKeyCol

	' ----- Add other data columns.
	stateTable.Columns.Add("FullName", GetType(String))
	stateTable.Columns.Add("Admission", GetType(Date))
	stateTable.Columns.Add("Population", GetType(Long))

	' ----- Add a record.
	Dim stateInfo As Data.DataRow = stateTable.NewRow()
	stateInfo!ShortName = "WA"
	stateInfo!FullName = "Washington"
	stateInfo!Admission = #11/11/1889#
	stateInfo!Population = 5894121
	stateTable.Rows.Add(stateInfo)

	' ----- Add another record.
	stateInfo = stateTable.NewRow()
	stateInfo!ShortName = "MT"
	stateInfo!FullName = "Montana"
	stateInfo!Admission = #11/8/1889#
	stateInfo!Population = 902195
	stateTable.Rows.Add(stateInfo)

	' ----- Prove that the data arrived.
	MsgBox(stateTable.Rows.Count)       ' Displays "2"
	MsgBox(stateTable.Rows(0)!FullName) ' Displays "Washington"

ADO.NET defines the basic structures for tables,

Read More >>

Problem

While a data reader is fast and convenient, you would like to keep the retrieved data around for a while, even when you are disconnected from the database or other data source.

Solution

Use the data reader to bring the results into a data set. The DataSet object represents one or more in-memory database tables, each with its records stored in a separate DataTable object.

Discussion

The following code loads all records from the Table1 table into a DataSet object, creating a DataTable object named Table1 within that data set:

	' ----- Connect to the database.
	Dim 
connectionString As String = _
	   “Data Source=MySystemSQLEXPRESS;” & _
	   “Initial Catalog=MyDatabase;Integrated Security=true”
	Dim theDatabase As New SqlClient.SqlConnection(connectionString)
	theDatabase.Open()

	‘ —– Prepare the SQL statement for use by the data set.
	Dim sqlStatement As New SqlClient.SqlCommand( _
	   “SELECT * FROM Table1″, theDatabase)
        Read More >>

Problem

You need to issue multiple database updates in the context of a single, atomic transaction.

Solution

Use an ADO.NET transaction to envelop the various SQL statements that need to be processed as a unit.

Discussion

The following block of code connects to a database via ADO.NET and makes several database updates within a single transaction:

	' ----- Connect to the database.
	Dim connectionString As String = _
	   "Data Source=MySystemSQLEXPRESS;" & _
	   "Initial Catalog=MyDatabase;Integrated Security=true"
	Dim theDatabase As New SqlClient.SqlConnection(connectionString)
	theDatabase.Open( )	' ----- Create a command object that will hold each
	'       processed SQL statement.
	Dim sqlStatement As New SqlClient.SqlCommand
	sqlStatement.Connection = theDatabase	' ----- Start the transaction.
	Dim theTransaction As
        Read More >>

Related Articles

• The Enterprise Library Data Access Application Block, Part 2 (msdn.microsoft.com)

Problem

You need to use a stored procedure in your database, and you’re not sure how to specify values for its input and output parameters.

Solution

Use the command object’s Parameters collection to set and retrieve stored procedure argument values.

Discussion

Here’s a simple SQL Server stored procedure that does nothing more than retrieve a field from a table given its ID value:

	CREATE PROCEDURE GetRecordName
	   @PriKey int,
	   @NameResult varchar(50) OUT
	AS
	BEGIN
	   -- Given an ID value, return the RecordName field.
	   SET @NameResult =
	      (SELECT RecordName FROM Table1 WHERE ID = @PriKey);
	END

To use this stored procedure, create a command object that calls it, and add separate input and output parameters: Read more…

Ebook page contain :

• Visual Basic 2005 Cookbook
• Visual Basic 2005, a developers notebook.chm
• OReilly.Visual.Basic.2005.in.a.Nutshell.3rd.Edition.Jan.2006.chm
• Visual Basic 2005 Express Edition For Dummies Dec 2005 eBook-DDU.pdf

You can download from here

Tags: ebook, vb 2005, visual basic 2005

Problem

You need to insert a lot of records into a table, and you would like to simply replace the new data values in the SQL statement without having to build the SQL statement from scratch each time.

Solution

Attach one or more Parameter objects to the Command object.

Discussion

The following SQL Server example inserts new records into Table1, setting the Column2 column to a distinct value for each inserted record:

	' ----- Connect to the database.
	Dim connectionString As String = _
	   "Data Source=MySystem\SQLEXPRESS;" & _
	   "Initial Catalog=MyDatabase;Integrated Security=true"
	Dim theDatabase As New SqlClient.SqlConnection(connectionString)
	theDatabase.Open()

	' ----- Build the generic command text.
	Dim theCommand As New SqlClient.SqlCommand()
	theCommand.CommandText = _
	   "INSERT INTO Table1 (Column1) VALUES (@NewValue)"
	theCommand.Connection = theDatabase

	' ----- Add the first record.
	theCommand.Parameters.AddWithValue("NewValue", "Blue")
	theCommand.ExecuteNonQuery()

	' ----- Add the second record.
	theCommand.Parameters("NewValue").Value = "Red"
	theCommand.ExecuteNonQuery()

	' ----- Finished.
	theCommand = Nothing
	theDatabase.Close()
	theDatabase.Dispose()

Parameters are often used to interact with stored procedures, but you can use them in other, more basic SQL statements to substitute for placeholders included in the SQL statement text. In SQL Server, placeholders begin with an at sign (@) followed by a parameter identifier. These identifiers match the names used when creating SqlParameter objects. These parameters are attached to the SqlCommand object containing the generic SQL text.

Once you’ve created the command object, adding parameters is simple. The easiest method employs the Parameters collection’s AddWithValue() method to add the named parameters. This method accepts a parameter name and a value as any System.Object instance:

	theCommand.Parameters.AddWithValue("NewValue", "Blue")

Once the parameter is in place, you can modify it in later statement reprocessing, accessing it by name:

	theCommand.Parameters("NewValue").Value = "Red"

The exact syntax used to identify parameter placeholders in the SQL statement text may vary between providers.

Problem

You’ve issued INSERT, UPDATE, and DELETE statements through a command object, but you need to retrieve some data with a SELECT statement.

Solution

Use a DataReader object to quickly review the results of a SELECT statement.

Discussion

The following code retrieves a set of records from Table1:

	' ----- Connect to the database.
	Dim connectionString As String = _
	   "Data Source=MySystem\SQLEXPRESS;" & _
	   "Initial Catalog=MyDatabase;Integrated Security=true"
	Dim theDatabase As New SqlClient.SqlConnection(connectionString)
	theDatabase.Open()

	' ----- Prepare the SQL statement for the reader.
	Dim sqlStatement As New SqlClient.SqlCommand( _
	   "SELECT * FROM Table1 WHERE Column2 = 25", _
	   theDatabase)
	Dim dataResults As SqlClient.SqlDataReader = _
	   sqlStatement.ExecuteReader()

	' ----- Clean up.
	sqlStatement = Nothing
	theDatabase.Close()
	theDatabase.Dispose()

Assuming that the query returned records, the dataResults object now makes those records available, one at a time. The Read() method retrieves each successive record from the database:

	Do While dataResults.Read()
	   MsgBox("Column1 = " & CStr(dataResults!Column1))
	Loop
	dataResults.Close()

Read() returns False when there are no more records available.

To check for the presence of any records before using the Read() method, use the HasRows property:

	If (dataResults.HasRows = False) Then MsgBox("No data.")

Data readers provide basic and direct access to result sets. They are no-frills objects, but they are quick and simple to use. Their basic and essential features form the basis of other, more complex data-gathering actions in ADO.NET. When you retrieve table results and store them in a DataSet object (described in Recipe 13.7), the DataSet indirectly uses a data reader to transfer the records from the database into the data set.

Records returned by a data reader can be accessed by name or position. For example, if you retrieve data with the columns Column1, Column2, and Column3 (in that order), you can use any of the following statements to access Column2:

	dataResults!Column2
	dataResults("Column2")
	dataResults(1)  ' Zero-based array.

The fields returned by the reader are stored as System.Object values. You must convert them to their proper data types manually, using the available conversion functions.

Data readers are “forward-only” objects; once you have retrieved a record using Read(), you cannot return to it without reissuing the SQL command to create a new data reader.

While data readers are most often used to process SELECT statements and stored procedures, there are other statements that return data results. SQL Server 2005 includes a new OUTPUT clause in INSERT statements that you can use to retrieve one or more data fields from the newly inserted record. It’s common to create a database table with an automatically generated numeric primary key. After inserting a new record into such a table, you have to use a separate SELECT statement to retrieve the new primary key value. The OUTPUT clause lets you retrieve the new primary key value directly from the INSERT statement:

	INSERT INTO Table1 (Column2, Column3)
	   OUTPUT INSERTED.Column1
	   VALUES (10, 20)

Sending this INSERT statement to the database using the ExecuteReader() method returns a single record with a single field containing the value of the new Column1 field. You can also use the ExecuteScalar() method because only a single value is returned:

	Dim sqlStatement As New SqlClient.SqlCommand( _
	   "INSERT INTO Table1 (Column2, Column3) " & _
	   "OUTPUT INSERTED.Column1 VALUES (10, 20)", _
	   theDatabase)
	Dim newID As Integer = CInt(sqlStatement.ExecuteScalar())
	sqlStatement = Nothing

Problem

Now that you’ve established a connection to a database through a provider, you’re ready to issue SQL commands. But how?

Solution

Use a Command object to issue SQL commands directly to your database through the provider connection.

Discussion

The following code updates a SQL Server table named Table1, changing every Column2 field to 25 whenever Column1 has a value of 0:

	' ----- Connect to the database.
	Dim connectionString As String = _
	   "Data Source=MySystem\SQLEXPRESS;" & _
	   "Initial Catalog=MyDatabase;Integrated Security=true"
	Dim theDatabase As New SqlClient.SqlConnection(connectionString)
	theDatabase.Open()

	' ----- Prepare the SQL statement for use.
	Dim sqlStatement As New SqlClient.SqlCommand( _
	   "UPDATE Table1 SET Column2 = 25 WHERE Column1 = 0", _
	   theDatabase)
	sqlStatement.ExecuteNonQuery()

	' ----- Clean up.
	theDatabase.Close()
	theDatabase.Dispose()

Just like connections, command objects are provider-specific. When using the SQL Server provider, the System.Data.SqlClient. SqlCommand class wraps a SQL statement string and prepares it for use by the database. You must supply a valid SQL statement that is recognizable by the database.

The SQL statement you provide to the command can include the standard Data Manipulation Language (DML) SQL statements (SELECT, INSERT, UPDATE, DELETE), or any of the platform-specific Data Definition Language (DDL) statements (such as CREATE TABLE). Do not include a terminating semicolon in the statement.

Instead of including the SQL statement and connection object in the command’s constructor, you can assign these values to the command object’s CommandText and Connection properties, respectively.

The command object includes several methods that send the command to the database for processing:

ExecuteReader()

Issues a command, and returns the data results in the form of a DataReader object. See Recipe 13.3 for additional information on data readers.

ExecuteNonQuery()

Issues a command, expecting no results. This method is generally used for INSERT, UPDATE, and DELETE commands.

ExecuteScalar()

Issues a command, expecting a single row and column of data in response. The data is returned as a generic System.Object instance, which you can convert to the appropriate data type.

ExecuteXmlReader()

Issues a command, and returns the data results as an XmlReader object.

There are also asynchronous versions of these methods (except for ExecuteScalar()).