Parse JBuilder database applications

A database application is a program that accesses and stores data and allows you to view, modify, or operate the data. In most cases, data is stored in a database. However, data can also be stored in files as text or in other formats. JBuilder allows you to access the data and operate on the data in the dataexpress component library together with the attributes, methods, and events defined in the datasan Component Library (jbcl) dataset package and dbswing package.

A database application that requests information from a data source (such as a database) is called a client application. A Database Management System (DBMS) that processes data requests from various clients. It is called a database server.

The dataexpress architecture of JBuilder is mainly to build Java-only client/server applications and applets for the Internet or intranet. Because the applications you create in JBuilder are pure Java, they are cross-platform.

The JBuilder application communicates with the database server through the jdbc api. Jdbc api is a standard description for connecting to the javasoft database. JDBC is a pure Java industrial standard API for accessing and operating database data. The JBuilder database application can be connected to any database with a JDBC driver.

　　Main Components of database applications

Dataset

Dataset is an abstract class. A large number of public APIs of all dataset appear in this class; All dataset navigation, data access, and updated APIs appear in this class; the support for master-slave relationships, row sorting, and row filtering appear in this class. All data recognition jbcl and dbswing controls have a dataset attribute. This means that grid control or jdbtable can set its dataset attribute to various extensions of Dataset: DataSet view, query dataset, procedure dataset, and table dataset.

Storagedataset

Storagedataset can use the memory storage space (memorystore) to buffer its data. The storagedataset store attribute can also be set to a datastore component to provide persistence for dataset data ). Storagedataset manages the storage of dataset data to maintain the index of the Data Change view and the persistent column status. All structured APIs (Add/delete/change/move columns) appear in this class. Because data is managed, it can automatically record the update, insert, and delete of all rows. Because all changes to storagedataset are tracked, we know exactly what needs to be done to save the changes that occurred during the operation to the data source.

Datastore

Datastore components are dataexpress dataset, arbitrary files, and Java objects, providing high-performance data caching and compression for persistent storage. The datastore component uses a single file to save one or more data streams. The datastore file has a hierarchical directory structure. It associates a name and directory status with a specific data stream.

Datasetview

This component can be used to provide independent navigation (cursors ). Its row sorting and filtering methods are different from those used by the Basic Dataset. To use this component, you must set the storage dataset attribute of the datasetview component. When multiple controls need to be dynamically converted to the new dataset, you can use this component control to connect to the same datasetview. To force them to view the new dataset, you can change the properties of the datasetview storage dataset.

Querydataset

This is a dataset specified by JDBC. It manages a JDBC data provider. The data to be provided is specified in the query attribute. The query attribute specifies an SQL statement.

Proceduredataset

This is a dataset specified by JDBC. It manages a JDBC data provider. The data to be provided is provided using the procedure attribute. The procedure attribute specifies a stored procedure.

Tabledataset

This is a general dataset component without a built-in supplier mechanism. Although it does not have a default provider, it can still be used to parse its modifications back to the data source. Tabledataset, column, and data can be imported through the dataset method or by using a data file component like text data file to add data.

Dataexpress architecture of JBuilder

The dataexpress component is designed as a module to allow the separation of key functions. This design allows the dataexpress component to process more applications. The modular features of dataexpress architecture include:

Core dataset (core dataset) Function

This is a collection of data processing functions available to dataexpress applications. You can use this function to declare attributes and set events. This function includes navigation, data access/update, Data Sorting/filtering, master-slave support, search, constraint, and default.

Data Source independence (data source independent)

Retrieving and updating data from a data source, such as oracle or Sybase, is separated into two key interfaces: supplier/Parser (Resolver ). By separating data acquisition from updates to two interfaces, it is easy to create a supplier/parser component for a new data source. Standard JDBC drivers have two Vendor/parser implementations that provide access to popular databases. For example, Oracle, Sybase, Informix, Interbase, DB2, ms SQL Server, paradox, dBase, Foxpro, access, and other popular databases are supported. In the future, borland.com and third parties will be able to create client provider/parser component Execution Code for ejbs, application servers, SAP, Baan, IMs, and CICs.

Pluggable Storage)

When data is obtained from a supplier, it is buffered in dataset. All edits made to the buffered dataset are tracked so that the parser code segment knows what needs to be updated to the data source. Dataexpress provides two options for this buffer storage: memorystore (default) and Data Store. Memorystore caches all data and data editing to the memory. Datastore uses a pure Java, small-scale, high-performance, and embedded database to buffer data and edit data. Datastore is suitable for non-connection/mobile computing, asynchronous data replication, and small-scale database applications.

Data Binding support for visual component (data binding support for visual components)

The dataexpress dataset component provides a powerful programming interface and supports direct data binding for the data identification component. For example, you can set the grid, list, and field in the visualization designer through the navigation of the vertex and click Properties. JBuilder is provided together with Java jfc based on visual components. These visual components are directly bound to dataset components.

Advantages of modular dataexpress Architecture

　　Network Computing

As mentioned above, the supplier/parser method isolates the interaction with any data source from two irrelevant modules. This method has two other advantages:

1. The supplier/parser can easily be divided into an intermediate layer. Because the supplier/parser logic is generally subject to the nature of transactions, it is ideal to divide it into an intermediate layer.

2. This is a stateless computing model that is ideal for network computing. The connection between dataset component customers and data sources can be closed after use. To save the changes to the data source, you only need to re-establish the connection during the transaction.

　　Rapid development of user interfaces

Because dataset can be bound to a data identification component through simple attribute settings, they are very suitable for quickly building database application user interfaces.

　　Mobile Computing

With the introduction of datastore components, dataexpress applications have a persistent and portable database. Datastore can contain multiple dataset, arbitrary files, and Java objects. This allows an application to be completely stored in a single file bucket. Dataset has a built-in data replication technology that can be used to edit, save, and adjust the copied data to a data source.

　　Embedded applications

Small-scale and high-performance datastore databases are ideal for embedded applications and support all functions and semantics of dataset components.