- •Using Your Sybex Electronic Book
- •Acknowledgments
- •Contents at a Glance
- •Introduction
- •Who Should Read This Book?
- •How About the Advanced Topics?
- •The Structure of the Book
- •How to Reach the Author
- •The Integrated Development Environment
- •The Start Page
- •Project Types
- •Your First VB Application
- •Making the Application More Robust
- •Making the Application More User-Friendly
- •The IDE Components
- •The IDE Menu
- •The Toolbox Window
- •The Solution Explorer
- •The Properties Window
- •The Output Window
- •The Command Window
- •The Task List Window
- •Environment Options
- •A Few Common Properties
- •A Few Common Events
- •A Few Common Methods
- •Building a Console Application
- •Summary
- •Building a Loan Calculator
- •How the Loan Application Works
- •Designing the User Interface
- •Programming the Loan Application
- •Validating the Data
- •Building a Math Calculator
- •Designing the User Interface
- •Programming the MathCalculator App
- •Adding More Features
- •Exception Handling
- •Taking the LoanCalculator to the Web
- •Working with Multiple Forms
- •Working with Multiple Projects
- •Executable Files
- •Distributing an Application
- •VB.NET at Work: Creating a Windows Installer
- •Finishing the Windows Installer
- •Running the Windows Installer
- •Verifying the Installation
- •Summary
- •Variables
- •Declaring Variables
- •Types of Variables
- •Converting Variable Types
- •User-Defined Data Types
- •Examining Variable Types
- •Why Declare Variables?
- •A Variable’s Scope
- •The Lifetime of a Variable
- •Constants
- •Arrays
- •Declaring Arrays
- •Initializing Arrays
- •Array Limits
- •Multidimensional Arrays
- •Dynamic Arrays
- •Arrays of Arrays
- •Variables as Objects
- •So, What’s an Object?
- •Formatting Numbers
- •Formatting Dates
- •Flow-Control Statements
- •Test Structures
- •Loop Structures
- •Nested Control Structures
- •The Exit Statement
- •Summary
- •Modular Coding
- •Subroutines
- •Functions
- •Arguments
- •Argument-Passing Mechanisms
- •Event-Handler Arguments
- •Passing an Unknown Number of Arguments
- •Named Arguments
- •More Types of Function Return Values
- •Overloading Functions
- •Summary
- •The Appearance of Forms
- •Properties of the Form Control
- •Placing Controls on Forms
- •Setting the TabOrder
- •VB.NET at Work: The Contacts Project
- •Anchoring and Docking
- •Loading and Showing Forms
- •The Startup Form
- •Controlling One Form from within Another
- •Forms vs. Dialog Boxes
- •VB.NET at Work: The MultipleForms Project
- •Designing Menus
- •The Menu Editor
- •Manipulating Menus at Runtime
- •Building Dynamic Forms at Runtime
- •The Form.Controls Collection
- •VB.NET at Work: The DynamicForm Project
- •Creating Event Handlers at Runtime
- •Summary
- •The TextBox Control
- •Basic Properties
- •Text-Manipulation Properties
- •Text-Selection Properties
- •Text-Selection Methods
- •Undoing Edits
- •VB.NET at Work: The TextPad Project
- •Capturing Keystrokes
- •The ListBox, CheckedListBox, and ComboBox Controls
- •Basic Properties
- •The Items Collection
- •VB.NET at Work: The ListDemo Project
- •Searching
- •The ComboBox Control
- •The ScrollBar and TrackBar Controls
- •The ScrollBar Control
- •The TrackBar Control
- •Summary
- •The Common Dialog Controls
- •Using the Common Dialog Controls
- •The Color Dialog Box
- •The Font Dialog Box
- •The Open and Save As Dialog Boxes
- •The Print Dialog Box
- •The RichTextBox Control
- •The RTF Language
- •Methods
- •Advanced Editing Features
- •Cutting and Pasting
- •Searching in a RichTextBox Control
- •Formatting URLs
- •VB.NET at Work: The RTFPad Project
- •Summary
- •What Is a Class?
- •Building the Minimal Class
- •Adding Code to the Minimal Class
- •Property Procedures
- •Customizing Default Members
- •Custom Enumerations
- •Using the SimpleClass in Other Projects
- •Firing Events
- •Shared Properties
- •Parsing a Filename String
- •Reusing the StringTools Class
- •Encapsulation and Abstraction
- •Inheritance
- •Inheriting Existing Classes
- •Polymorphism
- •The Shape Class
- •Object Constructors and Destructors
- •Instance and Shared Methods
- •Who Can Inherit What?
- •Parent Class Keywords
- •Derived Class Keyword
- •Parent Class Member Keywords
- •Derived Class Member Keyword
- •MyBase and MyClass
- •Summary
- •On Designing Windows Controls
- •Enhancing Existing Controls
- •Building the FocusedTextBox Control
- •Building Compound Controls
- •VB.NET at Work: The ColorEdit Control
- •VB.NET at Work: The Label3D Control
- •Raising Events
- •Using the Custom Control in Other Projects
- •VB.NET at Work: The Alarm Control
- •Designing Irregularly Shaped Controls
- •Designing Owner-Drawn Menus
- •Designing Owner-Drawn ListBox Controls
- •Using ActiveX Controls
- •Summary
- •Programming Word
- •Objects That Represent Text
- •The Documents Collection and the Document Object
- •Spell-Checking Documents
- •Programming Excel
- •The Worksheets Collection and the Worksheet Object
- •The Range Object
- •Using Excel as a Math Parser
- •Programming Outlook
- •Retrieving Information
- •Recursive Scanning of the Contacts Folder
- •Summary
- •Advanced Array Topics
- •Sorting Arrays
- •Searching Arrays
- •Other Array Operations
- •Array Limitations
- •The ArrayList Collection
- •Creating an ArrayList
- •Adding and Removing Items
- •The HashTable Collection
- •VB.NET at Work: The WordFrequencies Project
- •The SortedList Class
- •The IEnumerator and IComparer Interfaces
- •Enumerating Collections
- •Custom Sorting
- •Custom Sorting of a SortedList
- •The Serialization Class
- •Serializing Individual Objects
- •Serializing a Collection
- •Deserializing Objects
- •Summary
- •Handling Strings and Characters
- •The Char Class
- •The String Class
- •The StringBuilder Class
- •VB.NET at Work: The StringReversal Project
- •VB.NET at Work: The CountWords Project
- •Handling Dates
- •The DateTime Class
- •The TimeSpan Class
- •VB.NET at Work: Timing Operations
- •Summary
- •Accessing Folders and Files
- •The Directory Class
- •The File Class
- •The DirectoryInfo Class
- •The FileInfo Class
- •The Path Class
- •VB.NET at Work: The CustomExplorer Project
- •Accessing Files
- •The FileStream Object
- •The StreamWriter Object
- •The StreamReader Object
- •Sending Data to a File
- •The BinaryWriter Object
- •The BinaryReader Object
- •VB.NET at Work: The RecordSave Project
- •The FileSystemWatcher Component
- •Properties
- •Events
- •VB.NET at Work: The FileSystemWatcher Project
- •Summary
- •Displaying Images
- •The Image Object
- •Exchanging Images through the Clipboard
- •Drawing with GDI+
- •The Basic Drawing Objects
- •Drawing Shapes
- •Drawing Methods
- •Gradients
- •Coordinate Transformations
- •Specifying Transformations
- •VB.NET at Work: Plotting Functions
- •Bitmaps
- •Specifying Colors
- •Defining Colors
- •Processing Bitmaps
- •Summary
- •The Printing Objects
- •PrintDocument
- •PrintDialog
- •PageSetupDialog
- •PrintPreviewDialog
- •PrintPreviewControl
- •Printer and Page Properties
- •Page Geometry
- •Printing Examples
- •Printing Tabular Data
- •Printing Plain Text
- •Printing Bitmaps
- •Using the PrintPreviewControl
- •Summary
- •Examining the Advanced Controls
- •How Tree Structures Work
- •The ImageList Control
- •The TreeView Control
- •Adding New Items at Design Time
- •Adding New Items at Runtime
- •Assigning Images to Nodes
- •Scanning the TreeView Control
- •The ListView Control
- •The Columns Collection
- •The ListItem Object
- •The Items Collection
- •The SubItems Collection
- •Summary
- •Types of Errors
- •Design-Time Errors
- •Runtime Errors
- •Logic Errors
- •Exceptions and Structured Exception Handling
- •Studying an Exception
- •Getting a Handle on this Exception
- •Finally (!)
- •Customizing Exception Handling
- •Throwing Your Own Exceptions
- •Debugging
- •Breakpoints
- •Stepping Through
- •The Local and Watch Windows
- •Summary
- •Basic Concepts
- •Recursion in Real Life
- •A Simple Example
- •Recursion by Mistake
- •Scanning Folders Recursively
- •Describing a Recursive Procedure
- •Translating the Description to Code
- •The Stack Mechanism
- •Stack Defined
- •Recursive Programming and the Stack
- •Passing Arguments through the Stack
- •Special Issues in Recursive Programming
- •Knowing When to Use Recursive Programming
- •Summary
- •MDI Applications: The Basics
- •Building an MDI Application
- •Built-In Capabilities of MDI Applications
- •Accessing Child Forms
- •Ending an MDI Application
- •A Scrollable PictureBox
- •Summary
- •What Is a Database?
- •Relational Databases
- •Exploring the Northwind Database
- •Exploring the Pubs Database
- •Understanding Relations
- •The Server Explorer
- •Working with Tables
- •Relationships, Indices, and Constraints
- •Structured Query Language
- •Executing SQL Statements
- •Selection Queries
- •Calculated Fields
- •SQL Joins
- •Action Queries
- •The Query Builder
- •The Query Builder Interface
- •SQL at Work: Calculating Sums
- •SQL at Work: Counting Rows
- •Limiting the Selection
- •Parameterized Queries
- •Calculated Columns
- •Specifying Left, Right, and Inner Joins
- •Stored Procedures
- •Summary
- •How About XML?
- •Creating a DataSet
- •The DataGrid Control
- •Data Binding
- •VB.NET at Work: The ViewEditCustomers Project
- •Binding Complex Controls
- •Programming the DataAdapter Object
- •The Command Objects
- •The Command and DataReader Objects
- •VB.NET at Work: The DataReader Project
- •VB.NET at Work: The StoredProcedure Project
- •Summary
- •The Structure of a DataSet
- •Navigating the Tables of a DataSet
- •Updating DataSets
- •The DataForm Wizard
- •Handling Identity Fields
- •Transactions
- •Performing Update Operations
- •Updating Tables Manually
- •Building and Using Custom DataSets
- •Summary
- •An HTML Primer
- •HTML Code Elements
- •Server-Client Interaction
- •The Structure of HTML Documents
- •URLs and Hyperlinks
- •The Basic HTML Tags
- •Inserting Graphics
- •Tables
- •Forms and Controls
- •Processing Requests on the Server
- •Building a Web Application
- •Interacting with a Web Application
- •Maintaining State
- •The Web Controls
- •The ASP.NET Objects
- •The Page Object
- •The Response Object
- •The Request Object
- •The Server Object
- •Using Cookies
- •Handling Multiple Forms in Web Applications
- •Summary
- •The Data-Bound Web Controls
- •Simple Data Binding
- •Binding to DataSets
- •Is It a Grid, or a Table?
- •Getting Orders on the Web
- •The Forms of the ProductSearch Application
- •Paging Large DataSets
- •Customizing the Appearance of the DataGrid Control
- •Programming the Select Button
- •Summary
- •How to Serve the Web
- •Building a Web Service
- •Consuming the Web Service
- •Maintaining State in Web Services
- •A Data-Driven Web Service
- •Consuming the Products Web Service in VB
- •Summary
910 Chapter 20 DATABASES: ARCHITECTURE AND BASIC CONCEPTS
Now you’ll specify that we want the sum the quantities. Right-click the Quantity field in the Grid pane and select the Group By option from the context menu. A new column will be inserted after the Sort Order column. This column is set automatically to Group By for all the fields.
Now select the Group By cell of the Quantity row, expand the drop-down list, and select the Sum option. You have just specified that the field Quantity must be summed. The Group By option tells the Query Builder to group together all the rows that refer to the same product. This ensures that the sum will include all the products, because the rows of the Order Details table that refer to the same product are grouped together).
Notice that the Alias cell of the Quantity row has become Expr1 (it’s no longer a column, but an aggregate). Set the alias to Total Items. Something has changed in the Diagram pane too (see Figure 20.16). The summation symbol has appeared next to the Quantity field (even though this field isn’t selected to appear in the output of the query), and the grouping symbol has appeared next to the ProductName field.
Figure 20.16
A query with totals
Run the query now and see the results in the lower pane. Each product name appears only once, and the number next to it is the total number of items sold.
If you close the Query Builder window now, you’ll be prompted as to whether you want to save the new view and to specify a name for it. The definition will be saved to the Northwind database, along with the other objects of the database.
SQL at Work: Counting Rows
Let’s say you want to find out the number of orders in which each product appears. Go back to the Server Explorer and open the previous view (or the Query Analyzer). Add the Orders table, which will be automatically related to the Order Details table with the OrderID field. Click the OrderID
Copyright ©2002 SYBEX, Inc., Alameda, CA |
www.sybex.com |
THE QUERY BUILDER 911
field in the Orders table. A new line will be added to the Grid pane, and its Group By column will be set automatically to Group By. Set it to Count Distinct and its alias to “# Of Orders.” We’re going to sum the orders in which each product appears. The Count Distinct aggregate function is similar to the Count function, but it will not include the same order twice (if the same product appears in two rows of the same order). Run the query. This time you’ll get one line per product. The Alice Mutton item has been ordered 37 times, and the total items sold are 978.
Alice Mutton |
978 |
37 |
Aniseed Syrup |
328 |
12 |
Boston Crab Meat |
1103 |
41 |
Camembert Pierrot |
1577 |
51 |
The SELECT statement generated by the SQL Builder is the following. Notice that the Orders table isn’t involved in the query. All the information we need resides in the Order Details table. The Products table is included so that we can display product names instead of product IDs.
SELECT |
TOP 100 PERCENT dbo.Products.ProductName, |
|
SUM(dbo.[Order Details].Quantity) AS [Total Items], |
|
SUM(dbo.[Order Details].OrderID) AS [# Of Orders] |
FROM |
dbo.Products |
|
INNER JOIN dbo.[Order Details] ON |
|
dbo.Products.ProductID = dbo.[Order Details].ProductID |
GROUP BY |
dbo.Products.ProductName |
ORDER BY |
dbo.Products.ProductName |
The phrase TOP 100 PERCENT tells SQL Server to return all qualifying rows and is optional. The Query Builder inserted it so that you can change the value and limit the number of selected rows. Change the default aliases of the two calculated columns and execute the query again by clicking the button with the exclamation mark.
Limiting the Selection
So far, we’ve extracted data from all rows. Practically, we never work with all the rows in the data- base—we select a subset based on chronological, geographical, or other criteria. In this section we’ll modify the previous query so that it retrieves the totals over a time period. As you can guess, we’ll use the WHERE clause to limit the selected rows.
Our selection will be chronological. We’ll sum the items sold in a year (or any other interval you wish). This will introduce a little additional complexity to our query, because the information on which the selection will be based doesn’t appear in the Order Details table. The date of each order is stored in the Orders table, so we must add this table to our query.
Select the OrderDate field to the Grid pane. We want to specify two criteria for the date: it must be after the starting date and before the ending date. So, add the Orders.OrderDate field twice. To add a second instance of the same field, expand the first empty cell in the left column and, from the drop-down list, select its name. Then move to the Group By column of the row of the OrderDate field. Change its value to WHERE and, in the Criteria column, enter the following:
>= ‘1/1/1998’
Copyright ©2002 SYBEX, Inc., Alameda, CA |
www.sybex.com |
912 Chapter 20 DATABASES: ARCHITECTURE AND BASIC CONCEPTS
In the second instance of the same field, expand the Group By column, set it to WHERE, and then enter the following string in the Criteria column:
<= ‘1/1/1999’
The Query Builder has generated the following SQL statement:
SELECT |
TOP 100 PERCENT dbo.Products.ProductName, |
|
SUM(dbo.[Order Details].Quantity) AS [Total Items], |
|
SUM(dbo.[Order Details].OrderID) AS [# Of Orders] |
FROM |
dbo.Products |
|
INNER JOIN dbo.[Order Details] ON |
|
dbo.Products.ProductID = dbo.[Order Details].ProductID |
|
INNER JOIN dbo.Orders ON |
|
dbo.[Order Details].OrderID = dbo.Orders.OrderID |
WHERE |
(dbo.Orders.OrderDate >= |
|
CONVERT(DATETIME, ‘1998-01-01 00:00:00’, 102)) |
|
AND (dbo.Orders.OrderDate <= |
|
CONVERT(DATETIME, ‘1999-01-01 00:00:00’, 102)) |
GROUP BY dbo.Products.ProductName
ORDER BY dbo.Products.ProductName
As you can see, the Query Builder inserted the appropriate statements to convert your values to dates. You can make this statement a little more compact by using the BETWEEN operator. Remove the cells corresponding to the OrderDate field from the first column. Then add the OrderDate field again, set its Group By column to WHERE, and in the Criteria columns, enter the expression BETWEEN ‘1/1/1998’ AND ‘1/1/1999’. When no time is specified, it’s assumed that it’s the first second of the specified date. The date 1/1/1998 includes the first day of the year. The date 12/31/1998 doesn’t include the last day of the year, because it will be converted to 1998-12-31 00:00:00. If you specify the first and last day of the year, the totals will be calculated over a period of 364 days, not 365 days (assuming the year is not leap). So, you must either specify the following date, or add a time part to the date to take into consideration the 24 hours of the final day: 12/31/1998 23:59:59.
Execute the query and you will see the following lines at the top of the Results pane:
Alice Mutton |
217 |
11 |
Aniseed Syrup |
108 |
4 |
Go back to the Grid pane and change the dates to calculate the same results for the year 1997. The two criteria should be:
>= ‘1/1/1997’ <= ‘1/1/1998’
Execute the new query and you will see the same product names, only with different totals. Here’s the revised query’s code:
SELECT TOP 100 PERCENT dbo.Products.ProductName,
SUM(dbo.[Order Details].Quantity) AS [Total Items],
SUM(dbo.[Order Details].OrderID) AS [# Of Orders]
FROM dbo.Products
INNER JOIN dbo.[Order Details] ON
Copyright ©2002 SYBEX, Inc., Alameda, CA |
www.sybex.com |
THE QUERY BUILDER 913
dbo.Products.ProductID = dbo.[Order Details].ProductID INNER JOIN dbo.Orders ON
dbo.[Order Details].OrderID = dbo.Orders.OrderID WHERE (dbo.Orders.OrderDate BETWEEN
CONVERT(DATETIME, ‘1997-01-01 00:00:00’, 102) AND CONVERT(DATETIME, ‘1998-1-1 00:00:00’, 102))
GROUP BY dbo.Products.ProductName ORDER BY dbo.Products.ProductName
Parameterized Queries
How about running the same query with different dates? Let’s modify our query once again, and make the two dates parameters of the queries. Each time you’ll be executing the new query, you’ll be prompted to specify the starting and ending dates.
Replace the two dates in the Criteria column of the Grid pane with a question mark. The revised expression should now read:
Between ? And ?
If you run the query, you’ll get an error message telling you that parameters aren’t supported for this type of query. We’re designing a view; that’s why you can’t use parameters. Click OK to get rid of the message, and you’ll be prompted to enter the values of the two parameters (Figure 20.17). A question mark in a query corresponds to a parameter, and you must supply the values for the parameters in the order in which they appear in the query. Enter the two dates in Define Query Parameters window and you’ll see its output in the Results pane.
Figure 20.17
Specifying the parameters for a query
In the following section, we’ll convert this statement to a stored procedure, and you’ll see how you can pass values for the query’s parameters. Because the behavior of the query depends on the values of its parameters, this is a parameterized query.
Calculated Columns
Let’s add yet another step of complexity to our query. We’ll modify our query so that it calculates the total revenues generated by each product. Move down in the Field column of the Grid pane, and in the first free cell, enter the following expression:
Quantity * UnitPrice * (1 – Discount)
Copyright ©2002 SYBEX, Inc., Alameda, CA |
www.sybex.com |