Developing database applications
Installing and setting up JBuilder for database applications
Installing JBuilder, JDBC, and the JDBC-ODBC bridge
Installing JDBC and the JDBC-ODBC bridge
Connecting to databases
Installing JBuilder sample files
Installing Local InterBase Server
Tips on using InterBase
Using DataGateway
Using InterClient
Troubleshooting JDBC database connections in the tutorials
Unable to load dll 'JdbcOdbc.dll'
java.sql.SQLException: No suitable driver
Data source name not found
Connection failed java.sql.SQLException: [...] unavailable database
Understanding JBuilder database applications
Understanding JBuilder's DataExpress architecture
The Borland database-related packages
Connecting to a database
Adding a Database component to your application
Setting Database connection properties
Using the Database component in your application
Accessing data
An introductory database tutorial using a text file
Creating the application structure
Adding UI components to your application
Displaying the UI design tools
Adding a UI component
Adding DataExpress components to your application
Setting properties to connect the components
Setting properties of DataExpress components
Setting properties of UI components
Compiling, running, and debugging a program
Storing data locally
Summary
Querying a database
Tutorial: Querying a database using the JBuilder UI
Populating a data set
Creating the UI
Opening and closing data sets
Ensuring that a query is updatable
Setting properties in the query dialog
The Query page
The Parameters page
SQL Builder
Place SQL text in resource bundle
Using parameterized queries to obtain data from your database
Tutorial: Parameterizing a query
Using parameters
Re-executing the parameterized query with new parameters
Binding parameters
Parameterized queries in master-detail relationships
Establishing a master-detail relationship
Defining a master-detail relationship
Fetching details
Fetching all details at once
Fetching selected detail records on demand
Editing data in master-detail data sets
Steps to creating a master-detail relationship
Tutorial: Creating a master-detail relationship
Obtaining data through a stored procedure
Tutorial: Accessing data through a stored procedure
Creating tables and procedures for the tutorial
Adding the DataSet components
Adding visual controls
Discussion of stored procedure escape sequences, SQL statements, and server-specific procedure calls
Creating tables and procedures for the tutorial manually
Example: using InterBase stored procedures
Example: using parameters with Oracle PL/SQL stored procedures
Using Sybase stored procedures
Storing data locally
Importing data from a text file
Tutorial: Importing data from a text file
Storing data locally
Adding columns to a TableDataSet in the editor
Importing formatted data from a text file
Writing a custom data provider
Separating database access logic and business rules from the user interface
Creating a data module
Adding data components to the data module
Adding business logic to the data module
Using a data module
Understanding the Use Data Module dialog
Persisting and storing data in a DataStore
Using a DataStore with StorageDataSets
Tutorial: Off-line editing with DataStore
Saving changes to the SQL database on the server
Expanding the tutorial to include a connection option
Usage recommendations
Restructuring DataStore StorageDataSets
Persistent column editing
When to use a DataStore
Undeleting DataStore streams
Capacity
Working with Columns
Column properties and metadata
Metadata and how it is obtained
Non-metadata Column properties
Setting column properties
Setting Column properties using JBuilder's visual design tools
Setting properties in code
Persistent columns
Creating persistent Columns explicitly in code
Combining live metadata with persistent columns
Suppressing the initial metadata query
Removing persistent columns
Using persistent columns to add empty columns to a DataSet
Controlling column order in a DataSet
Specifying required data in your application
Making columns persistent
Using variant data types
Storing Java objects
Saving changes back to your data source
Basic resolving
Saving changes back to your data source with a stored procedure
Tutorial: Saving changes with a NavigatorControl
Coding stored procedures to handle data resolution
Tutorial: Saving changes with a ProcedureResolver
Example: Using InterBase stored procedures with return parameters
Resolving data from multiple tables
Considerations for the type of linkage between tables in the query
Table and column references (aliases) in a query string
Controlling the setting of the column properties
What if a table is not updatable?
How can the user specify that a table should never be updated?
Saving changes in a master-detail relationship
Resolving master-detail data sets to a JDBC data source
Exporting data
Tutorial: Exporting data from a TableDataSet to a text file
Tutorial: Using patterns for exporting numeric, date/time, and text fields
Exporting data from a QueryDataSet to a text file
Saving changes from a TableDataSet to a SQL table
Streaming data
Example: Using streamable data sets
Using streamable DataSet methods
Customizing the default resolver logic
Adding a QueryResolver component
Resolver events
Common database applications tasks
Providing data
Filtering data
Tutorial: Adding and removing filters
Example: Filtering with a restrictive clause in a query
Sorting data
Sorting data in a GridControl
Sorting data using the JBuilder visual design tools
Sorting data in code
Locating data
Locating data with the LocatorControl
Locating data programmatically
Locating data using a DataRow
Working with locate options
Locates that handle any data type
Column order in the DataRow and DataSet
More database applications tasks
Presenting an alternate view of the data
Adding an Edit or Display Pattern for data formatting
Display masks
Edit masks
Using masks for importing and exporting data
Data type dependent patterns
Patterns for numeric data
Patterns for date and time data
Patterns for string data
Patterns for boolean data
Using calculated columns
Tutorial: Creating a calculated column in the designer
Aggregating data with calculated fields
Tutorial: Aggregating data with calculated fields
The AggDescriptor
Creating a custom aggregation event handler
Creating lookups
Tutorial: Creating a lookup using a calculated column
Tutorial: Looking up choices with a picklist
Displaying or hiding navigator buttons at run time
Example: Sharing a visual control between two data sets
Using data-aware components
Synchronizing visual controls
Accessing data and model information from a UI Control
Displaying status information
Building an application with a StatusBar control
Running the StatusBar application
Creating a distributed database application
Database administration tasks
Using JBuilder for Database Administration tasks
Creating the SQL data source
Populating a SQL table with data using JBuilder
Deleting tables in JBuilder
Using SQL Explorer for database administration tasks
Monitoring database connections
JDBC Monitor controls
The Source control
The Traces control
The Output control
Using the JDBC Monitor in a running application
Adding the MonitorButton to the Palette
Using the MonitorButton Class from code
Understanding MonitorButton properties
Moving data between databases
Handling errors and exceptions
Overriding default DataSetException handling on controls
Sample database application
Sample international database application
Servlets
Creating a servlet in JBuilder
Tutorial: Creating and running a servlet
Deploying the servlet onto a Web server
Picking The Servlet Apart
Other sample servlets
How do I
Learn more about creating database applications?
Connect to a remote database?
Query a database?
Link two tables on a common field?
Run a stored procedure in JBuilder?
Work with data off-line?
Save changes to a database table?
Filter data in a table?
Hide rows in a table?
Sort data in a visual control?
Use patterns for editing, viewing, and exporting data?
Calculate data?
Aggregate data?
Look up a specific record in a table?
Create a picklist to set values in one table based on values in another table?
Create a distributed database application?
Monitor database connections?
Move data between databases?
Create and run a servlet in JBuilder?