Unit III

Preparing for OCP Exam 3: Building Forms I

Chapter 11

Introduction to Oracle Developer/2000

In this chapter, you will cover the following areas of introduction to Oracle Developer/2000:

• Overview of the Developer/2000 package
• Introduction to Developer/2000 tools
• Customizing your Developer/2000 session

This unit covers materials that are tested in OCP Exam 3, Building Forms I. The first section of this chapter, gives a high-level overview of Oracle Developer/2000 features, along with the benefits of using it. The next section provides a first look at the components that make up the Developer/2000 package. The final section describes how you can tune the Developer/2000 application so it more closely matches the way you like to work.

In this section, you will cover the following points about the Developer/2000 package:

• Features and benefits of using Developer/2000
• Component groups in Developer/2000

Oracle Developer/2000 is comprised of several powerful tools enabling developers to create robust, highly scalable client/server applications more quickly than would be possible using a programming language such as C, Visual Basic, or Java. With it, developers can use tools (known as Builders in Developer/2000) to create the different parts of an application, such as forms, reports, charts, queries, database objects, and procedures.

Developer/2000 is a sophisticated, and some might say complicated, program. That is true of any application designed to do as many things as Developer/2000. Learning it well takes time, but that investment will be rewarded with a broad array of powerful, time-saving features. Some of these benefits include enhanced productivity, ability to design scalable applications, adherence to Oracle’s standard of openness between applications, creation of usable and reusable applications, dynamic visualization, and Web deployment of applications to take advantage of recent advances in Internet/Web technology.

For individual developers, Oracle Developer/2000 speeds application design by employing object orientation, rapid application design (RAD) techniques, a unified client-server architecture, and online computer-based training modules. It allows components to be reused, and to be grouped into classes whose characteristics can be inherited by subclasses. You can use wizards—special interfaces that prompt you to specify values for certain components that then configure objects according to parameters you defined—to create application components quickly and easily. If you use Oracle’s Designer/2000 CASE tool, you can have Developer/2000 base an application on a Designer/2000 model. In addition, Developer/2000 forms can interface with programs written in other languages (C, for instance) utilizing the Open API. The Open API can also be used to create or modify form modules.

For team development, Developer/2000’s Project Builder can manage all of the Developer/2000 components, as well as components from third-party sources, such as documentation or multimedia files. When a project includes components created by programs other than Developer/2000, Project Builder is intelligent enough to use the correct third-party tools to edit and compile those components. Project Builder also provides facilities to interface with several other companies’ version-control systems. When it is time to distribute an application, Developer/2000 can package the application’s parts into a .zip or .tar file, and it can create customized installation scripts for the Oracle Installer program.

Because Oracle Developer/2000 is designed to accommodate a multi-tiered client/server architecture, it has many features that help an application scale up to handle large quantities of data. At the server, it provides array data manipulation, such as array inserts and deletes. Available without writing a line of code, this feature can dramatically improve application performance, because the application sends inserts, updates, and deletes to the server in a batch. In addition, Developer/2000 can base forms on data returned from stored procedures run on the server, and when the user changes data your Developer/2000 application can recompute subtotals at the client, without having to run another server query. All of these features reduce network traffic, thereby increasing the number of users a given server can accommodate with reasonable performance. Developer/2000 provides a simple drag-and-drop interface to determine whether an object runs on the client or the server.

Developer/2000 provides a rich set of features for interacting with other applications. It accommodates OCX/ActiveX controls, Object Linking and Embedding (OLE), and Dynamic Data Exchange (DDE). In addition to its native Oracle database, Developer/2000 can work with data stored in SQL Server, Sybase, Informix, Rdb, and DB/2, as well as any database accessible via ODBC or the Oracle Gateway. It can even work with data from multiple databases simultaneously.

In addition, numerous third-party companies have created interfaces between their products and Developer/2000. Available from members of the Open Tools Initiative, these interfaces allow Developer/2000 to interact with CASE and modeling tools, configuration management (version control) tools, workflow engines, and transaction-processing (TP) monitors, among many others.

Developer/2000 provides a variety of features enabling you to create applications that are extremely easy to use. You can build intuitive drag-and-drop user interfaces; incorporate image and sound files that are stored either within the database or as individual files; call dynamic link library (.dll) files to take advantage of platform-specific features within your applications; and incorporate animations, tooltips, and pop-up menus.

With a sophisticated feature called Dynamic Visualization, Developer/2000 enables you to create applications in which data and the graphics depicting the data can interact. This allows you to create features such as runtime chart editing, seamless Web reporting, graphical drill-down from overview to line-item detail, visual selection of data based on a graphic display, and conditional formatting of the display based on the content of the data within it.

Developer/2000 Release 2 provides features enabling you to deploy your application on the Internet or an intranet with a minimum of effort. Data entry forms, graphics, and reports can all utilize a Web browser as the "client" portion of a client/server system. This feature utilizes Java, bringing with it the many benefits of platform independence. Using a Java-enabled browser, your application can run in any environment, including the Network Computing Architecture. This eliminates the need to install a runtime client, or to learn a new language to create applications for different environments.

Developer/2000 comes with a set of powerful tools for client/server development. It includes tools to manage the development project and develop the application’s components. Developer/2000 includes capabilities to manage a development project from the top down. The Project Builder component keeps track of the individual pieces of the project, so you have a single point from which to work on your project, compile it for use, and package it for delivery to users. Individual pieces of the project don’t even need to be Oracle-related—they can be code files from other languages such as C, documentation files, and dynamic link library files, as well as others. For version control, there is a facility for integrating Developer/2000 with other source code management systems like ClearCase, PVCS, and Tuxedo. In situations where an application needs to be deployed in more than one language, the Translation Builder stores translated text between any number of languages supported by Oracle. It will then apply prior translation decisions to later versions of the application, thereby making subsequent translations very easy to do.

The major front-end development components of Developer/2000 are Forms, Reports, and Graphics. These components provide the front-end capabilities of an application: inserting and querying data, reporting on data, and displaying information in graphical formats. Client/server development is accomplished using other Developer/2000 components that allow manipulation of code and objects at the client and server level. The Reports Server and Reports Queue Manager components handle running reports on the application server, which can speed up their processing substantially. Developer/2000 Release 2 supports three-tier architecture: the database server, an application server, and the client computer. Queue Manager, in conjunction with Reports Server, typically resides on the middle tier.

Special features exist in Developer/2000 for back-end server development and for deployment of applications to the Web as well. For back-end development, Developer/2000 offers the Procedure Builder, Schema Builder, and Query Builder. These tools are designed to speed up the nuts-and-bolts work needed to put an application’s essential infrastructure into place. Developer/2000 handles Web transactions and publishing through its Web components as well. In Release 2.0, the Developer/2000 Application Server allows applications to be accessed through any browser on the Web. Release 2.0’s Graphics and Reports components also facilitate publishing data and reports on the Web.

In this section, you will cover the following points about Developer/2000 Builder tools:

• Builder tools for project management
• Builder tools for front-end development
• Builder tools for back-end development

When you install Developer/2000, you have the option to install some or all the components. The following tools are the major components in the Developer/2000 package: Project Builder, Form Builder, Report Builder, Graphics Builder, Procedure Builder, Query Builder, Schema Builder, and Translation Builder. Project Builder, Query Builder, and Schema Builder are new components of Developer/2000 release 2.0. The Developer/2000 designers in versions before 2.0 have been renamed Form Builder, Report Builder, and Graphics Builder for release 2.0. The various Builders in Developer/2000 can be grouped into several categories. These include project management (Project Builder, Translation Builder), application front-end management (Form Builder, Report Builder, Graphics Builder), and application back end management (Procedure Builder, Schema Builder, Query Builder). These components work together in a hierarchy that is depicted in Figure 11-1.

There are two tools for project management in Developer/2000, Project Builder and Translation Builder. The Project Builder gives you a single place to manage all the pieces of your Developer/2000 application. It starts by keeping track of the individual files that make up a project. Project Builder allows you to segregate the files into logical groups, such as Form Builder files, Report Builder files, word processing or spreadsheet files, and SQL scripts. It stores information about the project’s files and database connections in one of two Registries: a Global Registry for information that is consistent for an entire development team, and one or more User Registries for information that is specific to an individual developer’s files. A Project Wizard is available to walk you through the steps in defining a project. Figure 11-2 displays the Project Builder main screen.

The Translation Builder provides the means for developers to translate an application’s text into other languages, and to store those translations in a repository to be used automatically when future versions of the application are translated. The Translation Editor performs the actual translation, and it also manages the translation strings so future translations can be accomplished more quickly. Figure 11-3 displays an example screen from Translation Builder to aid your understanding.

Several other Builder components assist in building your GUI front end in Developer/2000. These tools include Form Builder, Report Builder, and Graphics Builder. The Form Builder simplifies the creation of data-entry screens, also known as forms. Forms are the applications that connect to a database, retrieve information requested by the user, present it in a layout specified by the form’s designer, and allow the user to modify or add information. Form Builder allows you to build forms quickly and easily. Like the Project Builder, Form Builder works with a set of wizards to step you through various tasks. Figure 11-4 displays the Form Builder example screen to assist in your understanding.

The Report Builder is the tool you use to create reports in a Developer/2000 application. Reports display data from a database in a layout specified by the report’s designer, often including subtotals, summaries, and graphics to help give the report’s reader the "big picture." Report Builder includes a wizard that walks you through creating a report very quickly. Completed reports can be viewed in the Reports Live Previewer, which allows you to change facets of a report and immediately see the results. Reports can be created on remote servers using Developer/2000’s Reports Server application. When Reports Server is used with a Reports Web Cartridge, reports can be run dynamically from a Web browser. Figure 11-5 displays the main screen in Report Builder.

The Graphics Builder allows you to create interactive graphical displays of the data in a database. These graphics can then be embedded in forms and reports. Graphics Builder provides a complete set of drawing and editing tools, along with a Chart Wizard to simplify the process of using the tools. Graphics created with Graphics Builder can be designed to change based on user interaction at run time. The program also allows you to import and export a wide range of image formats. Figure 11-6 displays the Graphics Builder main screen.

Back-end server development is a task covered by Developer/2000 as well. Developing PL/SQL stored procedures, functions, and packages are not tasks that should be handled using flat files and SQL*Plus alone, as any seasoned developer who’s struggled through it the hard way can attest. Instead, use Procedure Builder. In the last unit, you already saw how Procedure Builder allows manipulation of PL/SQL code for use by forms and reports. You can use this tool to work on code for either client-side or server-side execution. It incorporates a broad set of features to aid in creating, testing, and debugging PL/SQL code in program units, libraries, and triggers. Figure 11-7 displays an example screen from Procedure Builder.

Schema Builder is another useful tool that allows you to define the tables, views, snapshots, synonyms, constraints, and relationships that will make up your database. It lets you visualize a database design, including the tables, columns, data types, and relationships, and then execute that design. This tool is useful to both developers and DBAs, in that it manages all aspects of Oracle database object creation and then displays all those components with ease. Figure 11-8 displays an example screen from Schema Builder.

One final aspect of back-end server development in Developer/2000 is the creation of SQL statements. Building complex forms, reports, and graphics can require writing complicated SQL programming. Query Builder facilitates writing SQL code by providing a visual interface to the database objects being linked. Query Builder constructs SQL Data Manipulation Language (DML) queries that modify data in the database. Using this tool, an efficient query can be designed based on its performance in several scenarios. Figure 11-9 displays a sample screen from the Query Builder tool. Note also that Query Builder is accessible from within several other tools, such as Procedure Builder and Report Builder.

In this section, you will cover the following points on customizing your Developer/2000 session:

• Navigating the Developer/2000 interface
• Customizing Project Builder

Developer/2000 offers a variety of ways for you to customize how its programs look and operate. To learn about these features, you will first learn the rudiments of navigating the Project Builder interface. These basic navigational techniques apply to all of the Developer/2000 Builders. Next, you will learn how to customize Project Builder so it displays information and operates in a way that is tailored to your preferences. Your mastery of these two topics will be useful for your overall development efforts in the Developer/2000.

The Project Builder can serve as the starting point for the most-used tools within Developer/2000. Using the large buttons on the left side of Project Builder’s screen—known as the Launcher—you can start the Builders for forms, reports, graphics, procedures, and queries. These buttons are indicated in the Project Builder toolbar that is shown in Figure 11-10.

Note that you can change the contents of the Launcher. You can add buttons to start any other program you wish; change the order of the buttons; change the label that appears when your mouse pointer hovers over a button; and change the icon a button displays. These features will be covered in detail a little later in this section. Above the Launcher toolbar, you will see another toolbar. This one contains shortcuts to often-used features of Project Builder. The features offered by these buttons include creating new Project Builder files, opening existing Project Builder files, and starting the Project Wizard. Other buttons include Undo, Cut, Copy, and Paste. There are buttons for adding to and removing files from projects, as well as a button for compiling selections and incremental compiles. Finally, if you need assistance, you can use the Project Builder Help button.

In the central portion of the screen you will see a tree containing groups that Project Builder calls nodes. The nodes are labeled: Global Registry, User Registry, Connections, and Projects. The Global Registry contains settings that affect all developers on your project. These settings can include:

• File extension used to indicate a particular type of file
• Whether the file type is version controlled
• Whether the file type should be included in a delivered package
• What programs to use to open, edit, print, view, version control, and deliver the file type
• What database connection to link to the file type

If you elect to override any of the global settings, your changes will be stored as a personal configuration in the User Registry node. The Connections node contains information about each database connection your project uses, including the database name, the username and password required to make the connection, and your own comments about the connection. Finally, the Projects node stores the actual project information. You will do most of your interaction with Project Builder within the Projects node. Each of these four nodes has a square to its left that is either empty or, if the node contains information, displays a plus or a minus. The plus indicates that there is information in that node’s category, and that the information is not yet being shown. If you click on the plus once, that node’s items will display, and the plus changes to a minus to denote that the node is showing its contents.

Project Builder allows many of its settings to be altered to suit your preferences. To see what settings can be changed, use the Tools | Preferences menu bar option. When you choose this option, you will see a dialog box like the one shown in Figure 11-11. The Preferences dialog box includes three tabbed pages: Display, Projects, and Launcher. The tab named Display contains a page that is divided into two groups: Environment and Project Navigator. Within the Environment group, the Show Launcher option enables you to turn the display of the Launcher toolbar on or off. The Show Toolbar option provides the same type of control over the standard toolbar located beneath the Project Builder menu bar. The Show initial "Welcome" dialog option turns on or off the display of the initial "Welcome" screen when you start Project Builder. This screen is shown in Figure 11-12.

The Show Project Wizard "Welcome" screen option provides similar control over whether you see the screen shown in Figure 11-13 each time you start the Project Wizard. The Show Status bar option determines whether Project displays a line at the bottom of its screen identifying your current database connection and project name. The Show Help hints option enables a feature than uses the middle portion of the status bar (at the bottom of the Project Builder screen) to display helpful information about projects, file types, and menu and toolbar items.

In the Project Navigator group, some installations of Developer/2000 will have options called Show Global Registry and Show Local Registry. These turn on and off the display of the Global and User Registry nodes, respectively. All installations will display a Show types in Project View option, which causes Project Builder to group project files by file type when it displays them in "project view" mode (the default). This means that when you open a project, you will initially see a list of file types, instead of the individual filenames themselves. In order to see individual files, you have to click on the plus sign to the left of the desired file type. This may be unnecessary for projects with a small number of different file types, but it is very handy for projects with enough different types of files that having an additional layer of organization—by type—helps you find files more quickly.

The last option on this dialog box page, Show implicit items, instructs Project Builder to include implicit items in its display when you have changed its view to Dependency View with the Navigator | Dependency View menu command. An implicit item is a file that will exist, even if it does not yet. For instance, when you create a Form Builder document, Project Builder also adds an entry for a Form Builder executable file, even if one does not yet exist. It does this because it knows that an executable version must be created before the form can be used. Project Builder displays the names of real files in a bold font, and implicit files in a standard font.

The Preferences dialog tab named Projects contains fields allowing you to specify default values for a project’s author, database connection, and comments. This dialog is shown in Figure 11-14. The third and final Preferences dialog tab, Launcher, divides its options into three frames: Entries, Display, and Layout. It is shown in Figure 11-15.

The Entries frame is where you control the items in your Launcher toolbar. This allows you to add buttons for other useful programs, like the Oracle Schema Manager, SQL*Plus, or other tools. You can also change an entry’s parameters by clicking on it and then clicking the Edit button beneath the list. (You can also right-click on it and select Edit Entry from the context menu that appears.) In the dialog box that follows, you can specify whether the button controls a single item or a group of items; whether it is visible or hidden; what command it runs if the button invokes a single item; what label should appear as a tooltip if you hover your mouse pointer over the button; what helpful description should appear in the status bar for the button; and what icon to display on the button.

You can change the order of the entries in the Launcher list by clicking on an entry and dragging it up or down to the new location. In the Display group, you can select whether the Launcher buttons should display both the button name and its icon, or only the icon. Beneath that, in the Layout group, you can specify whether you want the Launcher toolbar to be docked on the left side of your screen, docked at the top of the screen, or free-floating in a separate, movable toolbar. If you choose the latter option, the shape of the toolbar can be changed from horizontal to vertical by dragging any of the toolbar’s borders with your mouse.

The Form Builder, Report Builder, Graphics Builder, and Query Builder all have preference functions offering very similar features for display customization, along with other options relevant to each Builder’s respective functions. You can use the approach you learned in this chapter to customize the preferences of those programs, as well. The commands to invoke the Preferences dialog box are a bit different from Builder to Builder. In Form Builder and Report Builder, the menu bar command is Tools | Preferences. In the Graphics Builder, the command is Tools | Tool Options. In the Query Builder, it is Edit | Preferences.

This chapter provided an overview of the Developer/2000 Builder programs. It began by introducing the features and benefits you can enjoy by using Developer/2000. These features include productivity resulting from an object-oriented rapid application design (RAD) environment. Your productivity also benefits from reusable components, a unified client/server architecture, component classes whose characteristics can be inherited by subclasses, and wizards to quickly guide you through many common tasks. In addition, productivity is enhanced by having Project Builder as a single point from which you can manage all development projects, and by having direct links to Oracle’s Designer/2000 CASE tool and third-party version-control systems.

The next feature is the scalability that comes from being able to easily specify whether objects execute on the client or the server, as well as bandwidth-saving features such array data manipulation for performing batch inserts, updates, and deletes without writing code. Scalability is also enhanced by the ability to base forms on server-run stored procedures, as well as the ability to recalculate aggregate values on the client without having to requery the server.

Another benefit of Developer/2000 is the openness resulting from support for OXC/ActiveX controls, Object Linking and Embedding (OLE), and Dynamic Data Exchange (DDE) to interact with other programs. Adding to Developer/2000’s openness is its ability to work with data in many other databases, and its ability to interact with programs written by companies in the Open Tools Initiative, whose products provide CASE and modeling functions, configuration management (version control), and transaction-processing (TP) monitoring.

The next benefit is the high degree of usability you can build into your Developer/2000 applications. You can incorporate pop-up menus, tooltips, and animations to make your applications easier to use. You can build easy-to-understand drag-and-drop user interfaces, and you can have your apps include image and sound files, with the files being stored either within the database or as separate files. If your project prioritizes performance over portability, you can employ .dll files to access platform-specific features within your applications.

The next benefit is visualization, which enables you to create such handy features as runtime chart editing, graphical drill-down from overview to line-item detail, conditional formatting of a display based on its content, and visual selection of data based on a graphic display. Finally, Developer/2000 provides Web deployment features enabling you to create Web-browser–based applications with minimal effort. Without having to learn Java, your applications can run in any environment in which a browser is available, including the Network Computing Architecture.

Next, you learned about Developer/2000’s two groups of components: management components and development components. The management components include the Project Builder and the Translation Builder. Project Builder’s features for organizing your project’s files give you the "big picture" when you need it, while still letting you get into individual files quickly just by double-clicking on them. Translation Builder keeps track of text strings within your application that you translate from one language to another, and when you have a future revision of that application to translate, Translation Builder automatically translates any strings that match those translated before. The development components include the Form Builder, Report Builder, Graphics Builder, Procedure Builder, Schema Builder, and Query Builder.

The next section covered Developer/2000’s Builders in more detail. This section divided the development components of Developer/2000 into two subgroups: front-end development (items the user sees and interacts with) and back-end development (behind-the-scenes objects). Developer/2000 expedites front-end development with its Form Builder, Report Builder, and Graphics Builder. For the back end, Developer/2000 helps you get work done quickly by offering the Procedure Builder, Schema Builder, and Query Builder.

The last section discussed two areas: how to navigate the Developer/2000 interface, and how to customize the appearance and operation of the programs. The Project Builder serves as the central point for your project navigation, because it allows you to launch other programs, store group and individual settings in the Global Registry and User Registry, and include project modules by adding them to nodes in the Project Builder project tree. You also learned how to set preferences within many of the Developer/2000 Builders. This feature lets you control the balance between convenient one-button access to all your tools and maximum screen real estate for your project tree. You also learned how to control the ways in which Developer/2000 tries to help you as you create and work with your projects; how to set default values that will be used as the starting point for new projects; and how to control the contents of the Launcher toolbar in the Project Builder.