Free Tutorials
Learn HTML
Learn CSS
Learn XML
Learn WML
Learn Access
Learn Data-VB
Learn Oracle
Learn SQL
Learn C++
Learn JavaScript
Learn Vbscript
Learn VisualBasic

Chapter 15

Visual Basic Database Basics

Rarely do Visual Basic programmers use the file-related controls that you see on the toolbox such as the File List Box control. More often, programmers use the File Open and File Save dialog boxes you can produce from the Common Dialog Box control (refer to Hour 12, "Dialog Box Basics"). The dialog box gives users the ability to select files and link to other networked computers and files.

You must make additional file-related decisions besides which controls to use to select files. In addition to the controls you display for the user, you must decide if you want to write file-access routines yourself or use database controls that come with Visual Basic. The file routines are tedious and old-fashioned and difficult to debug; the database controls are sometimes overkill, especially if you don't use an external database or if your application uses only a small data file.

This lesson gives you the best of both worlds. You will learn how to write file-access routines for small file-related data and you'll master the database control as well. Even if you don't work with files at the file-access level, the first part of this lesson prepares you for the concepts you need to use the Data control.

The highlights of this hour include

  • What file terms you need to master

  • When you open and close files

  • How to write to a file

  • How to read from a file

  • When to use the Data control

  • What bound controls offer

  • How to use the Data Form Wizard

File Concepts

If you've collected data from the user and stored that data in variables and arrays, you can save the data to the disk for later retrieval. Also, you can access disk files from within Visual Basic for product inventory codes, amounts, customer balances, and whatever else your program needs from the long-term data file storage. Visual Basic supports several ways you can store and retrieve information to and from disk files. This section introduces several new file-related terms.

Several database access controls exist that read and write the data you've put in databases using products such as Microsoft Access and Paradox. Even though these controls provide more power and ease than you can get by programming alone, you'll still need to understand fundamental disk access routines. Once you learn the more primitive disk access statements taught in the next several sections, you will more quickly understand the internal workings of the Data control that the last part of this lesson teaches.

New Term: A file is a collection of related data as well as programs that you buy and write, documents from your word processor, and data your applications write to disk.

Although you already know what a file is, this lesson works with data files and it often helps to understand specific terminology as soon as possible. Actually, your application can read any file whether or not the file is a data file, but the file's format determines how you'll read that file, as you'll learn here. Generally, you'll use Visual Basic to create and access data and text files stored on the disk.

NOTE: Although you can use Visual Basic to write utility programs that read other kinds of files such as system and program files, this guide does not cover such file I/O.

New Term: A data file holds data on the disk.

The files this lesson discusses are data files and those data files may be textual or stored in a database format. Every file is stored under a unique filename to its folder (often called a directory) and disk drive. Therefore, there can't be two or more files with the same filename unless the files reside in different folders or on different disks.

Data files can take on all kinds of formats. Generally, newcomers to Visual Basic should stick with data files that are textual in nature. Reading and writing text files is rather simple using standard statements that have existed in BASIC-like languages for many years. Once you learn these fundamental file statements, you can begin to use more advanced database files to add power to your applications.

Text files are readable by virtually any kind of program, and virtually any program can produce text files. Sometimes, text files are called ASCII files because text files consist of strings of ASCII characters, as opposed to binary files, which are only readable by special programs and system utilities.

Before Visual Basic can access a file, you or the user will have to direct Visual Basic to the exact location on the exact disk where the file is stored. If your user is selecting a file, you can display the File Open dialog box to give the user the ability to easily change drives, folders, and filenames. When your program accesses a file that the user doesn't know about, such as a data file that holds temporary program data, your program will have to supply the drive, folder, and filename.

Opening Files

The Open statement performs various tasks such as locating a file, making sure the file exists if needed, and creating some folder entries that manage the file while the file is open. A Visual Basic program always has to open a file, using Open, before the program can read or write data to the file (unless you use the Data control described later in this lesson).

TIP: Think of the Open statement as doing for Visual Basic what an open file drawer does for you when you want to retrieve a file from a filing cabinet. The Open statement locates the file and makes the file available to Visual Basic.

Here is Open's format:

Open strFileName [For Mode] As [#]intFileNumber

strFileName must be a string value or string variable that holds a filename. The filename must reside on the default drive or folder unless you specify the full path to the file in strFileName. Visual Basic includes a CurDir() function that returns the current directory folder as a string; you can append this folder name or specify the full path inside the strFileName string argument.

The Mode value must be a named value from Table 15.1. Visual Basic supports additional mode values, but this guide does not cover the more advanced or esoteric Mode values. The Mode tells Visual Basic exactly what your program expects to do with the file once Visual Basic opens the file.

Table 15.1. Open's Mode values.
Mode Description
Append Tells Visual Basic that your program needs to write to the end of the file if it already exists. If the file doesn't exist, Visual Basic creates the file so your program can write data to the file.
Input Tells Visual Basic that your program needs to read from the file. If the file doesn't exist, Visual Basic issues an error message. As long as you use a file-selection frame properly, Visual Basic will never issue an error because the file-selection frame forces the user to select a file or cancel the selection operation.
Output Tells Visual Basic that your program needs to write to the file. If the file doesn't exist, Visual Basic creates it. If the file does exist, Visual Basic first erases the existing file and creates a new one under the same name, thereby replacing the original one.

The pound sign (#) is optional, although most Visual Basic programmers specify it out of habit (some previous versions of the BASIC language required the pound sign). The intFileNumber value represents a number from 1 to 255 and associates the open file with that number. After you open a file successfully (assuming that there are no errors such as a disk drive door being left open), the rest of the program uses file I/O commands and functions to access the file. The file number stays with the file until you issue a Close command (see the next section) that releases intFileNumber and makes the number available to other files.

NOTE: The file number is sometimes called the file channel.

As with all DOS and Windows file descriptions, you can specify the drive, directory, and filename using uppercase or lowercase characters.

If your application uses multiple files, you can open more than one file simultaneously within a single application. Each command that accesses one of the files directs its activity toward a specific file using that file's intFileNumber. The following Open statement creates and opens a data file on the disk drive and associates the file to file number 1:

Open "d:\data\myfile.dat" For Output As #1

If you knew that the file already existed and you needed to add to that data file, you could use the Append mode to add to the file with this Open statement:

Open "d:\data\myfile.dat" For Append As #1

NOTE: As you can see, the Open statement's mode prepares the file for the type of processing your application will perform.

One Visual Basic program can have more than one file open at the same time. If the #1 intFileNumber argument were in use by another file that you had opened earlier in the application, you could assign the open file to a different number like this:

Open "d:\data\myfile.dat" For Append As #5

Any currently unused intFileNumber works; you can't associate more than one file at a time to the same intFileNumber value.

The following Open statement opens the same file for input if another application needs to use the data:

Open "d:\data\myfile.dat" For Input As #2

Visual Basic supplies a helpful built-in function named FreeFile() that accepts no arguments. FreeFile() returns the next available file number value. For example, if you've used #1 and #2 for two open files already in the application, without closing one of them, the next value returned from FreeFile() will be 3. FreeFile() is most helpful when you write general-purpose subroutine and function procedures that need to open files, and the procedures may be called from more than one place in an application. Each calling location might open a different number of files at the time. Any procedure can determine the value of the next available file number like this:

intFileNum = FreeFile()

Subsequent Open (and Close) statements could use the file number returned. No matter how many files are open, the procedure will always use the next file number in line to open its file.

The Open command associates files using file numbers with which the rest of the program will access the file. The three Mode values determine how Visual Basic uses the file. If you want to write to a file, you can't use the Input mode, and if you want to read from a file, you can't use Output or Append.

Closing Files

The Close statement performs the opposite job from Open. Close closes the file by writing any final data to the file, releasing the file to other applications, and giving the file's number back to your application in case you want to use that number in a subsequent Open statement. Eventually, every program that opens files should close those files. Use Close to close files.

Here are Visual Basic's two formats for Close:

Close [[#]intFileNumber] [, ..., [#]intFileNumber]



The first Close format closes one or more open files, specifying the files by the file numbers you used to open the files. The pound sign is optional in front of any of the file numbers. The second form of Close closes all files that are currently open. Close closes any open file, no matter what mode you used to open the file.

If you create a file by opening the file with the Output mode, and then close the file, you can reopen the same file in the same program in the Input mode to read the file.

The following statement closes the two open files that were opened and attached to file numbers 1 and 3:

Close 1, 3   ` Closes 2 files

The following statement closes all files, no matter how many are open:

Close   ` Closes ALL files

Deleting Files

You can use Visual Basic's Kill command to delete one or more files. If you want to delete a file from within a Visual Basic program, follow Kill with a string that contains the filename, including an optional disk and drive path. For example, Kill "C:\Dat\MyData.DAT" erases the file named MyData.DAT located on drive C: within the Dat folder. Kill does not perform the same action as Close; Close puts the file away in a safe area and releases the file from its I/O link; Kill permanently erases the file from your disk.

Writing to Files with Write#

The Write# command is perhaps the easiest command to use for writing data to a file. Write# writes data of any data type to a file. Using corresponding input statements that you'll learn here, you'll be able to read data that you sent to a file with the Write# command.

Write# lets you write data of any format to any disk file opened in the Output or Append modes. Write# writes strings, numbers, constants, and variables in any and all combinations to a disk file.

Here is the format of Write#:

Write #intFileNumber [, ExpressionList]

intFileNumber must be a file number associated with a file opened for output. If you don't specify variables or values to write, Write# writes a carriage return and line feed character (an ASCII 13 followed by an ASCII 10) to the file, putting a blank line in the file. If you specify more than one value in ExpressionList, Visual Basic writes that data to the file using the following considerations:

  • Write# separates multiple items on the same line by adding commas between the values.

  • Write# always adds a carriage return and line feed character to the end of each line written.

  • Write# adds quotation marks around all strings in the file. The quotation marks make for easy reading of the strings later.

  • Write# writes date and time values using the following format:
#yyyy-mm-dd hh:mm:ss#
  • Write# writes #NULL# to the file if the data contains a null value (a VarType() value of 1).

  • Write# writes logical values using the following format:

  • Write# writes nothing when the data value is empty (a VarType() of 0), but does separate even empty values with commas if you write more than one value on a single line.

The following statement writes five values to the disk file opened on file number 3:

Write #3, intAge, blnChecked, curSal, dteEnd, strName

This Write# statement writes a single line to the open disk file. The line might look like this:

47, #True#, 17423.61, #1-5-1998 14:21:10#, "Mary Sue"

If the application contained multiple Write# statements, or if the Write# statement appeared inside a loop, a new line would write to the file each time Write# executed.

TIP: End the Write# with a semicolon (;) if you want the next Write# to continue on the same line in the data file.

New Term: Append means to add to the end of something.

If you open a file using the Append mode, Write# adds to the end of the file. If the file were open in Output mode, the first Write# would overwrite the file's contents and start a new file.

You can write data to files from variables as well as from controls on the form. Wherever you've got data that needs to be written, Visual Basic's Write# command will write that data to a disk file that you've opened.

Listing 15.1 contains a subroutine procedure that accepts four arrays of four different data types and writes that array data to a disk file named Values.Dat opened in the procedure. Notice how you can use a simple For loop to write large amounts of data to a data file. The fifth argument sent to the subroutine is assumed to contain the total number of elements defined for the arrays so that the procedure can properly step through the entire array.

Listing 15.1. Writing array data to a file.

Private Sub WriteData (CNameso As String, CBalc() As _

   Currency, CDate() As Variant, CRegion() As Integer)

   ` Writes array data to a file

   Dim intCtr As Integer   ` For loop control


   ` Assumes that each array has the

   ` same number of elements defined

   Dim intMax As Integer

   intMax = UBound(CNames)   ` The maximum subscript

   ` Write intMax lines to the file

   ` with four values on each line

   Open "c:\Mktg.dat" For Output As #1

   For intCtr = 1 To intMax

      Write #1, CNames(intCtr), CBalc(intCtr), _

                CDate(intCtr), CRegion(intCtr)

   Next intCtr

   Close #1

End Sub 

Here are six lines from Mktg.dat that the program in Listing 15.1 might write:

"Adams, H", 123.41, #1998-11-18 11:34:21#, 6

"Enyart, B", 602.99, #21:40:01#, 4

"Powers, W", 12.17, #1999-02-09#, 7

"O'Rourke, P", 8.74, #1998-05-24 14:53:10#, 0

"Grady, 0", 154.75, #1999-10-30 17:23:59#, 6

"McConnell, I", 9502.32, #1999-07-12 08:00:03#, 9

The pound signs around the date and time Variant values help Visual Basic when you subsequently read the data values back into variant variables. As you can see, the date may have a missing time or the time may have a missing date. Write# still writes as much of the date and time as is available within that Variant value.

Inputting with Input#

Input# reads data from files and stores the file data in your program's variables and controls. Input# is the mirror-image statement to Write#. You use Input# to read any data that you send to a file with Write#. The Input# statement reads data into a list of variables or controls. Here is the format of Input#:

Input #intFileNumber [, ExpressionList]

Again, the bottom line to using Input# is that Input# is the mirror image of the Write# statement that produced the file data. When you write a program that must use data from a data file, locate the program's Write# statement that originally created the data file, and use that same format for the Input# statement.

The following Input# statement would read one line of values written with Listing 15.1's Write# statement:

Input #1, CNames(intCtr), CBalc(intCtr), _

          CDate(intCtr), CRegion(intCtr)

New Term: A record is a row in a file.

When reading data from a file, you can easily cause an error by attempting to read more data than the file holds. For data files that hold data such as customer balances and employee pay values, the number of records varies because you'll add and remove records as transactions take place.

Use the built-in Eof() function to test Visual Basic's end-of-file function that senses when an input reaches the end of the file. Here is the format of Eof():


Eof() returns True if the most recent reading of the input file just reached the end of the file and returns False if the input file still has data left to be read. Most data input programs loop until the Eof() function returns True. Perhaps the best way to use Eof() is with a Do Until-Loop that follows this general format:

Input #1, VariableList      ` Read first record

Do Until (Eof (intFileNumber) = True)

   ` Process the record just read

   Input #1, VariableList   ` Get more data


If there are 0, 1, 10, or 400 records in the file, this format of Do Until will keep reading, but will stop as soon as the end of the file is reached. Many programmers often increment an integer counter variable inside the loop to count the number of records read. The counter is useful later if you're reading the file's data into arrays. If you read file data into arrays, be sure to dimension more than enough array elements to hold the maximum number of records expected.

Line Input# Records

Line Input# reads data from open data files. Unlike Input#, Line Input# reads each line of data in the file into a string variable. You don't have to specify separate variable names after a Line Input# because Line Input# requires a single string value. Line Input# reads data from any file whose lines end with a carriage return and line feed sequence. (Most file records end this way.)

The Line Input# command is simple to use for reading entire records into a single variable. Whereas Input# reads each record's values individually, Line Input# reads an entire record, including all data, commas, quotation marks, and everything else. The string receives the record's contents. Here is the format of Line Input#:

Line Input #intFileNumber, strVariableName

No matter how many record values appear in the file associated with file number 3, the following Line Input# statement reads an image of the record into the String variable named strARecord:

Line Input #3, strARecord

Introduction to Database Processing

New Term: A database system is a program that organizes, manipulates, retrieves, and reports data.

If you use a database for your data, you can take advantage of Visual Basic's Data control to access the database from within your Visual Basic applications. The Data control makes it easy for you to retrieve data and display values from a database file without using any of Visual Basic's specific file-related commands that you learned about in the first part of this lesson.

NOTE: An organization's information is more likely stored these days in a database than in a file readable by the file commands you learned about in the previous sections. Nevertheless, the file commands are useful for simple files, especially text files your Visual Basic application creates and manages. Also, some data files that other applications create do not appear in a database format but in a record format you can read with those file statements. In addition, the file concepts you learned will help you master the Data control faster and appreciate the Data control more because the Data control takes so much work out of your hands by automating database access.

The Data Control

If you use any of the following database applications, you'll be able to write a Visual Basic application that accesses the data within your database without resorting to the file-related commands described earlier in this lesson:

  • Microsoft Access

  • dBASE

  • Excel

  • FoxPro

  • Lotus

  • Paradox

  • Text-based data files

The Data control makes database access simple.

New Term: A field is a column of data inside a file.

A database application manages your data in a record and field format. The database, however, does not necessarily store your data in records and fields in a table-like format, but the database makes the data appear to your program in that format. Visual Basic takes advantage of this format and retrieves data in the record and field format no matter how the database physically stores the data.

One challenge when using database access is that you must often describe parts of the database to Visual Basic. Visual Basic cannot magically understand your database structure. When you place the Data control on your form, you'll have to tell the control the structure of your data and tell the Data control which parts of the data to access so that the control can properly retrieve data. For example, by setting appropriate property values, you must tell the Data control the name of your database, the table, and the fields to access.

New Term: A table is a file in a database. A database might contain several tables.

Some databases, such as Microsoft Access, store all the related database files in a single global file called the database file. Inside the database, the individual groups of records and fields are called tables. Other database systems, such as dBASE, keep track of an application's files separately and each file that contains data in rows and fields is a database file. When you use a database such as Microsoft Access, as this lesson does, you must describe both the overall database and the individual table name within the database that the Data control is to track.

This lesson does not provide you with a table of Data control property descriptions because too many of the descriptions are database related and too advanced for this discussion. You may not need to know more properties than described in the small data application at the end of this lesson in most cases. You will probably be surprised at the amount of power the Data control gives you.

Figure 15.1 illustrates a Data control in use. Notice that the Data control works a lot like a VCR's series of buttons. You can step through the database one record at a time. The control itself does not display data. Instead, the control simply lets you regulate the access of data. You'll have to supply other controls, such as labels or text boxes, to display and collect data for the database. In other words, if you want the user to be able to move to a particular record, you'll supply a Data control that the user can push to get the record in the database. Then your application can display the data on the form using label controls.

Figure 15.1. The Data control sends database data to your application.

New Term: A bound control is a control you can link to a database, via the Data control, that displays and updates the database if the user modifies the data in the bound control.

The Data control is a two-way street; not only does the Data control display database data, but your user can modify the data that the data control displays, and the Data control makes sure that the changes get made to the underlying database through bound controls. If you don't want the user to be able to change data displayed from a Data control, you can use a label and not a text box to display the database data. You can bind several other controls to the Data controls and make the control read-only so that the user cannot change the underlying database.

A Simple but Powerful Application

Figure 15.1's text boxes are bound to the Data control on the form. Therefore, if the user changes the data in any text box that displays a value from the database, the underlying record's field value changes as well. The application is required to do nothing.

Figure 15.1 shows an application that you are about to build. Do you want to be really shocked? The application will contain no code whatsoever. The entire database access and update can be done just with the controls on the form!

WARNING: In most database applications, code is required. If the user is to add new records and delete old ones, for example, code is needed. For simple displaying and updating of existing data, however, the Data control, labels, and text boxes can do all the work.

Figure 15.1's guide publisher application uses a database that comes with Visual Basic named Biblio.mdb. The database is a Microsoft Access database and contains computer guide titles and publishers.

Perform these steps to build Figure 15.1's application:

1. Create a new project and name the form frmData and add a caption that reads Database Sample. Resize the form to a Height property of 5775 and a Width property of 7170.

Add a label with these properties: Name: lblAnnounce, Alignment: 2-Center, BorderStyle: 1-Fixed Single, Caption: Computer guide Publishers, Font: Bold 14 points, Height: 855, Left: 2160, Top: 360, and Width: 2895.

Add five additional field labels as follows: (1) Name: lblPub, Alignment: 1-Right Justify, Caption: Publisher:, Font: 12 points, Left: 720, Top: 1800, and Width: 1215; (2) Name: lblAddress, Alignment: 1-Right Justify, Caption: Address:, Font: 12 points, Left: 720, Top: 2400, and Width: 1215; (3) Name: lblCity, Alignment: 1-Right Justify, Caption: City:, Font: 12 points, Left: 840, Top: 3000, and Width: 495; (4) Name: lblState, Alignment: 1-Right Justify, Caption: State:, Font: 12 points, Left: 3360, Top: 3000, and Width: 735; (5) Name: lblZip, Alignment: 1-Right Justify, Caption: Zip:, Font: 12 points, Left: 4800, Top: 3000, and Width: 495.

Before adding the text boxes, add the Data control. To begin with, double-click the Data control to send the control to the center of the form. Change these property values: Name: dtaBiblio, Caption: Click to control data display, Left: 1920, Top: 4200, and Width: 3255.

The text that appears in the center of the Data control is the caption and never data. The Data control does not display data. Instead, the Data control regulates the display of data and you use other fields to hold the displayed data. The text boxes that you place in the next two steps will display the data. You will bind the text boxes to the Data control, and the Data control will be connected to the database. You must now make that connection; click the DatabaseName property and then click the ellipsis that appears. Select the Biblio.mdb database from VB's folder (you may have to locate the folder from the file list that appears). Now that the Data control is connected to the database, you can add the text boxes.

The database named Biblio.mdb, now connected to the dtaBiblio Data control, contains several tables. Therefore, not only must you tell the Data control which database to use, but you must also specify the table source for the data. Select Publishers from the RecordSource property's drop-down list box. The Data control will now produce records only from Biblio.mdb's Publishers table.

Add a text box to the form with these properties: Name: txtPublisher, BackColor: (select the tooltip color for a pale yellow text box), BorderStyle: 1-Fixed Single, Left: 2040, Top: 1800, and Width: 4215.

Now you must inform the text box that its data source is the Data control named dtaBiblio. Set the DataSource property to dtaBiblio by selecting dtaBiblio from the DataSource property's pull-down list box. (dtaBiblio is the only item that appears, but if the form contained additional Data controls, you would have to select the proper one for the text box's data source.) The table named Publishers, controlled by the Data control, contains several fields. Therefore, not only must you tell the text box which Data control to connect to, but you must also specify the field. Change the DataField property to Company Name. Company Name is the database's field name that holds the publisher name. Set Font to 12.

Add the following four text box controls: (1) Name: txtAddress, BackColor: ToolTip yellow, BorderStyle: 1-Fixed Single, DataField: Address, DataSource: dtaBiblio, Font Size: 12, Left: 2040, Top: 2400, and Width: 4215; (2) Name: txtCity, BackColor: ToolTip yellow, BorderStyle: 1-Fixed Single, DataField: City, DataSource: dtaBiblio, Font Size: 12, Left: 1440, Top: 3000, and Width: 1815; (3) Name: txtState, BackColor: ToolTip yellow, BorderStyle: 1-Fixed Single, DataField: State, DataSource: dtaBiblio, Font Size: 12, Left: 4200, Top: 3000, and Width: 555; (4) Name: txtZip, BackColor: ToolTip yellow, BorderStyle: 1-Fixed Single, DataField: Zip, DataSource: dtaBiblio, Font Size: 12, Left: 5400, Top: 3000, and Width: 1055.

7. Add a separating line with the Line control that has these properties: X1: 0, X2: 7080, Y1: 3720, and Y2: 3720.

Run the application, and you'll be looking at the first record in the database. Click the Data control's buttons to move through the database records. If you change a value, you will be changing the actual database itself because of the bound text box controls. Despite the fact that the application requires a lot of controls, no code is required due to the Data control's powerful database retrieval and update abilities.

NOTE: Once you master the Data control, you can learn Visual Basic's powerful Data control methods that, with code alone, let your application step through database records, update fields, and compute values from tables. In addition, the Visual Basic language supports special industry-standard database instructions called SQL (pronounced "see-quel") that you can apply to data to select and sort information from within a database. Professional and Enterprise Edition users have the ability to move beyond the Data control and master the DAO (which stands for Data Access Objects), which give you extended power to control database records.

The Data Form Wizard

Visual Basic comes with a tool called the Data Form Wizard that you can use to access a database and generate a form. The Data Form Wizard analyzes a database, locates the fields for you (you don't have to know the format of the database ahead of time), and automatically builds a form that contains an appropriate title, field names, Text Box controls for the fields, and the Data control you can use to move between the records.

New Term: An add-in application is a tool that extends Visual Basic's development environment.

To access the Data Form Wizard, select the Add-Ins | Data Form Wizard menu option. Visual Basic displays the Data Form Wizard's opening window. When you click Next, you see the database-selection dialog box shown in Figure 15.2.

Figure 15.2. The Data Form Wizard's database selection tool.

Continue following the wizard's requests to create the form. For example, you will have to tell the wizard the kind of database you want to create a form. Once you select a database, the next dialog box asks you for the database name (which you can browse for) and a data source such as a table or query. Select the kind of form and then on the Record Source dialog box you must select a table and then copy all the fields you want from that table to the final form. You then can click the options you want and click Finish to generate the form.

The form that the Data Form Wizard generates may not be as unique as the one you create yourself, but the form does include buttons that let the user not only change the database data but add and delete records as well, as Figure 15.3 shows.

NOTE: You can insert the Data Form Wizard's form into another application and then display the form with the Show method.

Figure 15.3. The Data Form Wizard creates a nice form.


In this hour you have learned about two important aspects of files and Visual Basic. You have learned about regular data files that your applications can create, append to, and read. Also you have learned how to use the Data control and its bound controls such as the Text Box control to give the user a way to change the data in an underlying database.

Although the Data control is easy to use, most programmers have access to a database. If you have yet to select a database product, consider Microsoft's Access because of its close ties to Office and Visual Basic. Using Microsoft's Access, you will need to do only a minimal amount of work to make Visual Basic work with your Access database. Access now includes Visual Basic for Applications, a VB-like language.

The next hour describes how your application can access the printer to produce output.


Q What if I don't have a database?

If you don't have a database and if you don't see a need for one, you may not need the Data control. You can perhaps get by with the file-related statements in Visual Basic's language such as Write# and Input#. If you feel adventuresome, check out VB's Add-Ins | Visual Data Manager. This add-in application gives you the ability to use Visual Basic to design, create, and analyze database files in several formats even if you don't have a database program available. Although the Visual Data Manager does not at all take the place of a full-functioned database management system such as Microsoft Access, you can begin using the Data control to access a database that you create with the Visual Data Manager.

Q What if I don't know the fields or tables in my database?

If you write an application that manages and updates a database that you did not create and with which you are not familiar, you can still use Visual Basic because the Data control and bound controls are able to interpret most database formats. Therefore, once you select a database for the Data control, the Data control will display a list of tables from that database when you open the Data control's RecordSource drop-down list box. In addition, any bound controls, such as text boxes or labels, that you connect to the Data control, will display an available list of fields which you want to bind to those controls.


The quiz questions and exercises are provided for your further understanding. See Appendix C, "Answers," for answers.


1. What is the difference between a file and a database?

What is the difference between a record and a field?

What is the difference between a table and a file?

What happens if you open an existing file in Output mode?

What happens when you write to a file in Append mode?

Which files does the following statement close?
7. True or false: Your form must contain a different Data control for every table in the database.

What advantage does a bound text box provide for the programmer who wants to write an application that lets the user update a database field?

A database field is a Yes/No Access data field that can only take one of two values. Which Visual Basic control would best serve to represent that field?

What's the simplest way to create a form based on a database?


1. Write an application that stores the titles of your five favorite friends, their ages, and their phone numbers in five records in a disk file. Use Write# to write each three-value record and Input# to read each record. Call the data-entry and file-writing procedures from one procedure and the file-reading and display procedure from another procedure.

Write a database application that displays the Biblio.mdb's guide title table's first three fields. Don't let the user update the fields; you must be careful what kind of controls you use to display the field data.

Use the Data Form Wizard to generate a table based on the entire Biblio.mdb's guide title table. Connect the generated form to a command button's Click() event on the main form so that the data form appears for the user when the user clicks the command button.

|  About us | Categories | New Releases | Most Popular | Web Tutorial | Free Download | Drivers |

2013 Soft Lookup Corp. Privacy Statement