- 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?