A data processing method, apparatus and device

Abstract

A data processing method, device and equipment, in the present application, a relational database is deployed on a data processing device, the data processing device receives a first query instruction triggered by a first user, the first query instruction is an instruction based on an object query language (OQL), and the first query instruction indicates that a first operation is performed on a first object. The data processing device converts the first query instruction into a second query instruction based on SQL, and the second query instruction is used to indicate that the first operation is performed on a target table, and the target table is a data table in the relational database which stores the first object. The data processing device executes the second query instruction. Facing the user, the data processing device supports OQL, and the first user can inform the data processing device of the first operation to be performed and the first object to be operated through OQL. Compared with SQL, OQL has more abundant semantics and simple expression, and the efficiency of accessing the database by using OQL is higher.

Description

Technical Field

[0001] This application relates to the field of databases, and more particularly to a data processing method, apparatus, and device. Background Technology

[0002] Databases (DBs) enable efficient management and storage of data. Users store their own data in databases and can perform data processing operations such as adding, deleting, querying, and modifying existing data through the database.

[0003] The most common type of database is the relational database. Users can use Structured Query Language (SQL) to query data in relational databases to perform data processing operations such as adding, deleting, querying, and modifying data. SQL is a mature and widely used query language.

[0004] Users querying relational databases using SQL are required to have a clear understanding of the database's internal data organization, such as table names and the fields within each table. This places high demands on users. Furthermore, for complex data processing operations, the SQL expression becomes even more intricate, making it easy for users to make mistakes when describing these operations using SQL. Therefore, querying relational databases using SQL is inefficient. Summary of the Invention

[0005] This application provides a data processing method, apparatus, and device to improve the efficiency of data querying for databases.

[0006] In a first aspect, embodiments of this application provide a data processing method. This method can be performed by a data processing device, which has a relational database deployed on it. In this method: the data processing device receives a first query instruction triggered by a first user. The first query instruction is an instruction based on the Object Query Language (OQL), that is, the first query instruction is an instruction using the OQL language. The first query instruction instructs the execution of a first operation against a first object.

[0007] Upon receiving the first query instruction, the data processing device converts it from OQL to SQL, transforming it into a second query instruction. This second query instruction is an SQL instruction that instructs the execution of a first operation on a target table, which is a relational database table storing the first object. The data processing device then executes the second query instruction.

[0008] When executing a second query instruction, the data processing device performs a first operation on the target table and obtains a first query result. If the first operation is an insert operation, the first query result indicates whether the insert was successful or failed. If the first operation is a query operation, the first query result indicates the data retrieved. The data processing device can then provide feedback on the first query result to the first user.

[0009] Using the above method, the data processing device supports OQL for users. The first user can use OQL to inform the data processing device of the first operation to be performed and the first object to be operated on. Compared to SQL, OQL has richer semantics and simpler expression, making database access more efficient. Furthermore, the database deployed in the data processing device is a widely used relational database, and the data processing device itself has OQL-to-SQL conversion capabilities. That is, the relational database and the OQL-to-SQL conversion capability are integrated into the same data processing device. This deployment method only requires a corresponding upgrade to the data processing device where the relational database resides, making implementation simpler. Moreover, integrating the relational database and the OQL-to-SQL conversion capability avoids deploying a separate device for implementing OQL-to-SQL conversion outside the database device, reducing deployment complexity and effectively avoiding latency caused by information interaction between the device and the database device.

[0010] In one possible implementation, the data processing device supports multi-user data queries, meaning it provides OQL-based database services to multiple users. For example, the data processing device can receive a third query instruction triggered by a second user. This third query instruction is an OQL-based instruction that instructs the execution of a first operation on a second object. The data processing device then converts the third query instruction into a fourth query instruction, which is an SQL-based instruction. The third query instruction instructs the execution of the first operation on a target table that stores the second object. The data processing device executes the fourth query instruction, obtains the second query result, and can then provide the second query result back to the second user.

[0011] Using the methods described above, the data processing device can provide database services to multiple different users. This means different users can access the database and perform data queries based on OQL, broadening the application scenarios. Within the data processing device, data from different users (such as the first object and the second object) can be stored in the same data table, effectively saving storage space and facilitating the management of data from different users.

[0012] In one possible implementation, the data processing device includes object metadata of at least one user, where each object indicates a mapping relationship between an object and a data table in a relational database. When converting a first query instruction into a second query instruction, the data processing device obtains the object metadata of the first user from the object metadata of the at least one user. The data processing device converts the first query instruction into the second query instruction based on the object metadata of the first user.

[0013] Using the above method, the data processing device stores the object metadata of the first user, ensuring that the data processing device can accurately convert the first query instruction into the second query instruction.

[0014] In one possible implementation, the first query instruction carries information about the first user. Thus, upon receiving the first query instruction, the data processing device uses the first user's information to determine the first user's object metadata from stored object metadata indicating a user.

[0015] In one possible implementation, the first query instruction carries an identifier that identifies it as an OQL-based instruction. Thus, upon receiving the first query instruction, the data processing device can quickly determine that it is an OQL-based instruction by recognizing this identifier. Of course, the data processing device can also determine that the first query instruction is an OQL-based instruction in other ways. For example, the data processing device may have syntax analysis capabilities and be able to determine that the OQL is OQL-based by analyzing the syntactic structure of the first query instruction.

[0016] In one possible implementation, the data processing device can store the first query instruction and the second query instruction.

[0017] When the data processing device receives a sixth query instruction triggered by the first user, the sixth query instruction is an OQL-based instruction used to instruct the first operation to be performed on the first object.

[0018] If the sixth query instruction is consistent with the first query instruction, the data processing device does not need to convert the sixth query instruction, but instead obtains and executes the saved second query instruction.

[0019] Using the above method, the data processing device can save the converted second query instruction. When the same query instruction is received subsequently, there is no need to perform a conversion operation. The saved second query instruction can be directly retrieved and executed, reducing the time consumption caused by the conversion operation and improving the query efficiency for the database.

[0020] In one possible implementation, the object metadata of the first user may include a variety of information. For example, the object metadata of the first user may include some or all of the following: the target table where the first object is located, the correspondence between each attribute of the first object and each field in the target table, and the length and / or precision of each attribute of the first object.

[0021] It should be noted that in this application, "A and / or B" represents three possibilities: A, B, and A and B respectively.

[0022] Using the above method, the object metadata of the first user includes a variety of information types, which makes it easier for the data processing device to use the object metadata of the first user to determine the target table where the first object is located, as well as the various fields corresponding to the first object in the target table.

[0023] Secondly, embodiments of this application also provide a data processing apparatus. This data processing apparatus has the function of implementing the behavior in the method example of the first aspect described above. The beneficial effects can be found in the description of the first aspect and will not be repeated here. The function can be implemented by hardware or by hardware executing corresponding software. The hardware or software includes one or more modules corresponding to the above functions. In one possible design, the structure of the data processing apparatus includes a receiving module, a processing module, and an execution module. These modules can execute the corresponding functions in the method example of the first aspect described above, as detailed in the method example description, and will not be repeated here.

[0024] Thirdly, this application also provides a computing device, which includes a processor and a memory, and may further include a communication interface. The processor executes computer program instructions stored in the memory to perform the method provided in the first aspect or any possible implementation thereof. The memory is coupled to the processor and stores computer program instructions and data necessary for metadata access. The communication interface is used for communication with other devices.

[0025] Fourthly, this application provides a computing device system including at least one computing device. Each computing device includes a memory and a processor. The processor of at least one computing device is used to access computer program instructions in the memory to execute the methods provided in the first aspect or any possible implementation thereof.

[0026] Fifthly, this application provides a computer-readable storage medium that, when executed by a computing device, allows the computing device to perform the method provided in the first aspect or any possible implementation thereof. The storage medium stores computer program instructions. The storage medium includes, but is not limited to, volatile memory, such as random access memory, and non-volatile memory, such as flash memory, hard disk drive (HDD), and solid-state drive (SSD).

[0027] Sixthly, this application provides a computing device program product, which includes computer program instructions. When executed by a computing device, the computing device performs the methods provided in the first aspect or any possible implementation thereof. The computer program product can be a software installation package, and when it is necessary to use the methods provided in the first aspect or any possible implementation thereof, the computer program product can be downloaded and executed on the computing device.

[0028] In a seventh aspect, this application also provides a computer chip connected to a memory, the chip being used to read and execute computer program instructions stored in the memory, and to execute the methods described in the first aspect and various possible implementations of the first aspect.

[0029] For the technical effects that can be achieved in the second to seventh aspects mentioned above, please refer to the description of the technical effects that can be achieved by the corresponding design scheme in the first aspect mentioned above. This application will not repeat them here. Attached Figure Description

[0030] Figure 1 This is a diagram illustrating a database deployment.

[0031] Figure 2 This application provides a schematic diagram of a data processing system structure.

[0032] Figures 3A-3B This application provides a schematic diagram of an OQL engine deployment;

[0033] Figure 4 A schematic diagram of a data processing method provided in this application;

[0034] Figure 5 A schematic diagram of an instruction conversion method provided in this application;

[0035] Figure 6 A schematic diagram of the structure of a data processing device provided in this application;

[0036] Figures 7-8This is a schematic diagram of the structure of a computing device provided in an embodiment of this application. Detailed Implementation

[0037] Before describing a data processing method, apparatus, and device in the embodiments of this application, some basic concepts related to databases in the embodiments of this application will be introduced first.

[0038] A database (DB) is a repository used to organize, store, and manage data; it can also be called a database management system. The existence of a database enables data to be stored and managed in an orderly and organized manner. Users can easily store their own data in a database and retrieve data from it, performing data processing operations such as adding, deleting, querying, and modifying data.

[0039] Query languages ​​have always been an important part of the database field. A query on a database is equivalent to applying a function to the database, returning data that meets the given conditions.

[0040] Common query languages ​​include Structured Query Language (SQL) and Object Query Language (OQL).

[0041] SQL is used in relational databases, which are database management systems based on the relational model. In a relational database, data is organized in the form of tables. Each table (also called a data table) consists of rows and columns, with each column being a field in the data table. Simply put, the relational schema is a two-dimensional table model.

[0042] SQL primarily describes what you want to do, rather than the specifics of how to do it in an imperative language. Also known as a fourth-generation language, SQL is supported by most modern relational database systems. At its core, SQL operates on "relationships."

[0043] Using SQL to query a database (i.e., a relational database) requires users to understand the relationships between tables within the database and the organization of data within each table. Furthermore, when performing complex data processing operations on the database, corresponding query commands (simply referred to as SQL commands, SQL-based commands, or SQL-based query commands) are generated based on SQL and transmitted to the database. Since the data processing operations are complex, the SQL commands themselves become even more complex, which undoubtedly places higher demands on the user's skills.

[0044] OQL is a standardized language that combines high-level, descriptive SQL programming with object-oriented programming paradigms. OQL brings the "advantages" of SQL into the object-oriented world; that is, it combines the advantages of SQL's descriptive programming model with object-oriented programming. OQL can be applied to object-oriented databases. An "object" can be understood as a data entity with multiple attributes, each attribute having corresponding data, which can be understood as the specific value of that attribute. For example, in company employee management information, each employee can be considered an object with attributes such as age, phone number, home address, and gender. Compared to relational models, this object-oriented approach, to a certain extent, shields the specific organization and storage format of data. For users, they only need to understand the object and its attributes, without needing to concern themselves with the underlying organization and storage methods of the object and its attributes. Furthermore, because OQL incorporates some language features of SQL, it has stronger expressive power and richer semantics.

[0045] Given the advantages of OQL, we attempted to combine OQL with relational databases, that is, to provide users with a database client that supports OQL, while deploying a relational database in the backend. For example... Figure 1 The diagram illustrates one database deployment method, in which at least one client (e.g., ...) is provided to users. Figure 1 Client 1 and Client 2 in the middle), different users (e.g. Figure 1 Users A, B, and C can access the relational database deployed in the backend through clients located close to them.

[0046] The client supports OQL, meaning it allows users to access relational databases using OQL. To establish the mapping between "objects" and "relationships," object metadata needs to be built. This metadata describes the mapping between objects and data tables. For example, using company employee management information, the employee is the object, and this employee contains three attributes: age, phone number, and gender. The object metadata records the attributes contained in the object, the data table recording the object, and information such as the fields corresponding to each attribute in the data table.

[0047] exist Figure 1In the database deployment method described above, the object metadata can be stored on the client side. Since different users define different objects, each user has corresponding object metadata. For example, taking company employee management information as an example, user A's defined object only contains three attributes: age, phone number, and gender. User B's defined object contains four attributes: age, phone number, department, and position. Because the object definitions are different, the object metadata is also different; therefore, user A and user B each have their own object metadata. Figure 1 In the database deployment method described above, the object metadata of different users can be stored on the client side.

[0048] When a user needs to perform data processing operations on data in the database, the user can send an OQL-based query command to the client. Upon receiving the query command, the client determines the user's object metadata from the stored object metadata for different users, and transforms the query command into an SQL-based query command—that is, converting a query operation targeting objects into a data query operation targeting data tables (or even fields within data tables). The client then transmits the transformed query command to the backend relational database. Because the transformed query command is based on SQL, the relational database can process it upon receipt, return the processing result to the client, and the client then presents the result to the user.

[0049] In this database deployment method, users no longer need to use complex SQL to query the database. Instead, they can use the richer and easier-to-learn OQL language, which can effectively improve the user experience. Furthermore, since the client-side can store object metadata for different users, this deployment method is suitable for multi-user query scenarios. However, this deployment method also has some drawbacks. First, each client needs to have the ability to convert from OQL to SQL, which consumes client-side computing resources. Second, each client needs to store object metadata for different users, which consumes client-side storage resources, and since each client needs to store this object metadata, there is some waste of storage resources.

[0050] In this embodiment, a relational database is deployed on a data processing device. The data processing device can receive and process a first query instruction based on OQL triggered by a first user. The data processing device converts the first query instruction into a second query instruction based on SQL according to the first user's object metadata, executes the second query instruction, accesses the relational database according to the second query instruction, obtains the first query result, and returns the first query result to the first user. Since the data processing device with the relational database deployed inherently possesses the capability to convert from OQL to SQL, it can provide OQL-based database services. Furthermore, the data processing device can receive and process a third query instruction based on OQL triggered by a second user. The execution method of the third query instruction is similar to that of the first query instruction; please refer to the foregoing description for details, which will not be repeated here. The data processing device stores object metadata for different users, thus supporting multi-user query scenarios.

[0051] like Figure 2 The diagram shown is a structural schematic of a data processing system provided in an embodiment of this application. The data processing system includes one or more clients 100 and a data processing device 200.

[0052] (1) Client 100.

[0053] The client 100 is deployed close to the user and can interact directly with the user. The data processing device 200 is equipped with a relational database that stores user data. The data processing device 200 can provide OQL-based database services, such as instructing basic data processing operations (e.g., the first operation mentioned in this embodiment) on data in the database via OQL-based query commands (hereinafter referred to as OQL commands, or OQL-based instructions, or OQL-based query commands). It can also instruct data calculations on the database, such as data aggregation and data statistics, for more complex data processing operations (e.g., the first operation mentioned in this embodiment). The client 100 can be understood as the user-facing "front end" of the data processing device 200. A first user can trigger a first OQL-based query command by operating the client 100. This first query command instructs the execution of a first operation on a first object. The client 100 transmits this first query command to the data processing device 200, which then processes it. A second user can also trigger a third query command based on OQL by operating client 100. Client 100 transmits the third query command to data processing device 200, which then processes the third query command.

[0054] This data processing system supports multi-user scenarios. The term "multi-user" here has two meanings: Meaning 1: Client 100 can interact with multiple users, each of whom can trigger query commands (such as the aforementioned first and third query commands) by operating client 100. Meaning 2: The data processing system includes multiple clients 100, each of which can serve as a front-end for the data processing device 200, allowing different users (especially those in different geographical locations) to access database services.

[0055] In this embodiment of the application, the client 100 generates and sends a first query instruction to the data processing device 200 under the trigger of the user. The first query instruction is used to instruct the data processing operation to be performed on the data in the database. The first query instruction is based on the object query language (OQL), that is, the first query instruction uses OQL to describe the data processing operation to be performed and the object to which the data processing operation is targeted.

[0056] This application does not limit the specific form of the client 100. The client 100 can be a hardware device, such as a server, a portable computer, a mobile device, or a smart home device. The client 100 can also be a software module, such as an application deployed on a server, or an application installed on a mobile device.

[0057] (2) Data processing equipment 200.

[0058] The data processing device 200 is equipped with a relational database. It can receive and process a first query instruction, which can then be converted into a second query instruction based on SQL. This second query instruction directs a first operation to be performed on a target table. Based on this second query instruction, the data processing device 200 queries the relational database, performs the first operation on the target table, and obtains a first query result. Similarly, the data processing device 200 can receive and process a third query instruction, which can be converted into a fourth query instruction based on SQL. Based on this fourth query instruction, the data processing device 200 queries the relational database and obtains a second query result.

[0059] Data processing device 200 has the following two functions:

[0060] Function 1: Ability to convert from OQL to SQL.

[0061] The data processing device 200 can perform conversion from OQL to SQL, such as converting a first query instruction into a second query instruction and a third query instruction into a fourth query instruction.

[0062] Taking the conversion of the first query instruction into the second query instruction by the data processing device 200 as an example, the data processing device 200 stores the object metadata of the first user, which describes the mapping relationship between the first user's object and the target table in the relational database.

[0063] Based on the object metadata of the first user, the data processing device 200 converts a first query instruction into a second query instruction. During the conversion process, using the first user's object metadata, it determines the target table containing the object whose first operation is required indicated by the first query instruction, as well as the fields corresponding to each attribute of that object in the target table. The data processing device then converts the first operation on the object into a first operation on the target table, and constructs the second query instruction according to the SQL syntax structure.

[0064] Similarly, the data processing device 200 stores the object metadata of the second user and uses the object metadata of the second user to convert the third query instruction into a fourth query instruction.

[0065] Because the data processing device 200 has the capability to convert OQL to SQL, it supports OQL-based data queries. Users only need to use a simple OQL description of the objects and operations to perform data queries. The client 100, located closer to the user, does not need this conversion capability, reducing the computational resource consumption on the client 100. Furthermore, the data processing device 200 can store object metadata for multiple users, eliminating the need to store this metadata on each client 100. This ensures the data processing device 200 is suitable for multi-user data query scenarios and avoids the user's object metadata consuming the client 100's storage resources.

[0066] For ease of explanation, the module in the data processing device 200 that implements the conversion from OQL to SQL is referred to as the OQL engine. This application embodiment does not limit the specific presentation of the OQL engine in the data processing device 200. Two presentation methods are listed here:

[0067] Presentation Method 1: The OQL engine can be installed in the data processing device 200 as a plug-in.

[0068] like Figure 3A As shown, the OQL engine is installed as a plug-in in the data processing device 200. A first management device is deployed outside the data processing device 200, which performs the installation and upgrade of the plug-in.

[0069] When the maintenance personnel of the data processing equipment 200 need to install the OQL engine on the data processing equipment 200, they can provide the first management device with the OQL engine plug-in installation package. The first management device then sends the OQL engine plug-in installation package (which is the computer program code required to install the OQL engine as a plug-in) to the data processing equipment 200 via a first management command. Upon receiving the first management command, the data processing equipment 200 installs the OQL engine according to the OQL engine plug-in installation package.

[0070] Specifically, within the data processing device 200, an agent module is deployed. This agent module interacts with the first management device to process the first management command sent by the first management device. Upon receiving the first management command, the agent module in the data processing device 200 installs the OQL engine.

[0071] When the maintenance personnel of the data processing equipment 200 need to upgrade the OQL engine installed on the data processing equipment 200 (such as improving the capabilities of the OQL engine or patching its defects), the maintenance personnel can provide the first management device with the OQL engine plug-in upgrade package. The first management device sends the OQL engine plug-in upgrade package to the data processing equipment 200 via a second management command (the OQL engine upgrade package is the computer program code required to upgrade the OQL engine). After receiving the second management command, the data processing equipment 200 upgrades the OQL engine according to the OQL engine plug-in upgrade package.

[0072] Specifically, within the data processing device 200, the agent module interacts with the first management device to process the second management command sent by the first management device. Upon receiving the second management command, the agent module in the data processing device 200 upgrades the OQL engine.

[0073] The OQL engine is installed as a plug-in in the data processing device 200, meaning it can be invoked by processes or software modules within the device. For example, when a process needs to process a first query instruction, and it determines that the first query instruction is based on OQL, the process can invoke the OQL engine, transmitting the first query instruction to it. The OQL engine then converts the first query instruction into a second query instruction and transmits it back to the process; the process then processes the second query instruction.

[0074] Presentation Method 2: The OQL engine is deployed independently in the data processing device 200, and the OQL engine runs in the data processing device 200 as a process.

[0075] like Figure 3B As shown, in the data processing device 200, the OQL engine can operate as a standalone process, and this OQL engine can exchange messages with other processes within the data processing device 200. For example, the data processing device 200 may also contain an SQL engine used to execute SQL-based query commands; this SQL engine can also operate as a standalone process.

[0076] Similarly, a second management device is deployed outside the data processing device 200, which manages the OQL engine.

[0077] When the maintenance personnel of data processing equipment 200 need to install the OQL engine on data processing equipment 200, they can provide the OQL engine installation package to the second management device. The second management device then sends the OQL engine plug-in installation package (the OQL engine installation package is the computer program code required to install the OQL engine as a standalone component) to data processing equipment 200 via a third management command. After receiving the third management command, data processing equipment 200 installs the OQL engine according to the installation package, and the OQL engine runs as a separate process within data processing equipment 200.

[0078] Specifically, within the data processing device 200, an agent module is deployed. This agent module interacts with the second management device to process the third management commands sent by the second management device. Upon receiving the third management command, the agent module in the data processing device 200 installs the OQL engine.

[0079] When the maintenance personnel of data processing equipment 200 need to upgrade the OQL engine installed on data processing equipment 200 (such as improving the capabilities of the OQL engine or patching its defects), the maintenance personnel can provide the second management device with the upgrade package for the OQL engine. The second management device sends the upgrade package (the upgrade package for the OQL engine is the computer program code required to upgrade the OQL engine) to data processing equipment 200 through a fourth management command. After receiving the fourth management command, data processing equipment 200 upgrades the OQL engine according to the upgrade package.

[0080] Specifically, within the data processing device 200, the agent module interacts with the second management device to process the fourth management command sent by the second management device. Upon receiving the fourth management command, the agent module in the data processing device 200 upgrades the OQL engine.

[0081] Taking the execution process of the first query instruction as an example, after receiving the first query instruction, the OQL engine converts the first query instruction into a second query instruction and transmits the second query instruction to the SQL engine. The SQL engine processes the second query instruction, accesses the relational database based on the second query instruction, and obtains the first query result.

[0082] Function 2: Database management capabilities.

[0083] The data processing device 200 is equipped with a relational database, which can manage the relational database, such as creating data tables, writing data into the data tables, modifying data in the data tables, or deleting the data tables or data in the data tables.

[0084] Since the database deployed on the data processing device 200 is a relational database, the management of this relational data block by the data processing device 200 is based on SQL. Therefore, the data processing device 200 can directly process SQL-based query commands (such as the second query command, the fourth query command, etc.).

[0085] The following is combined Figure 4 This application describes a data processing method provided in an embodiment. In this method, only the processing of the first query instruction triggered by the first user is described. The processing of the second query instruction triggered by the second user is similar to that of the first query instruction triggered by the first user. The difference lies in the user who triggers the query instruction and the object metadata used in the conversion process from OQL to SQL.

[0086] Step 401: The first user triggers the client 100 to generate and send a first query instruction. The first query instruction is an OQL-based instruction that instructs the execution of a first operation on the first object.

[0087] Client 100, acting as the "front end" of data processing device 200, can interact with the first user. Client 100 provides an interface to the first user to perform data processing operations on an object. The first user can use OQL through this interface to inform the user of the object to be processed (i.e., the first object) and the data processing operation to be performed (i.e., the first operation). In other words, OQL is used to describe the first object to be processed and the first operation to be performed.

[0088] When the client 100 learns about the first object to be processed and the first operation to be performed through the interface, it generates a first query instruction. The first query instruction is used to instruct the first operation to be performed on the first object. The first query instruction is an OQL-based instruction, that is, the first query instruction uses OQL to describe the first object to be processed and the first operation to be performed.

[0089] Furthermore, the first query instruction also carries information about the first user, such as the first user's identifier. By carrying this first user information, the first query instruction identifies that the first object it targets originates from the first user, or in other words, that the first object is defined by the first user. This application embodiment does not limit the method by which the client 100 obtains the first user's information. For example, the first user can first provide their own information to the client 100 (e.g., the first user logs in using their own information, and the client 100 can detect the first user's login operation and thus identify the first user's information), and then the first user informs the client of the first object to be processed and the first operation to be performed through the interface. Alternatively, the first user can inform the client of the first object to be processed and the first operation to be performed through the interface using OQL, and then transmit the first user's information to the client through the interface.

[0090] Here, the interface provided by client 100 to the user represents the functionality offered by client 100 to the user, that is, client 100 supports users in querying data using OQL. This application embodiment does not limit the specific presentation form of the interface. For example, the interface can be a user-visible interface where the user can use input / output devices such as a keyboard and mouse to describe the first object to be processed and the first operation to be performed using OQL. Alternatively, the interface can be a command with a defined format, containing fields for describing the first object and fields for describing the first operation. The user transmits a command conforming to the defined format to client 100. After receiving the command transmitted by the user, client 100 determines the first object to be processed and the first operation to be performed from the fields describing the first object and the fields describing the first operation.

[0091] It should be noted that in step 401, in a specific implementation, the first user only needs to specify the first object to be queried and the first operation to be performed. That is, the first user does not need to transmit OQL-based information through the interface; the construction of the first query instruction can be implemented by the client 100. For example, the client 100 displays multiple objects (including the first object) and multiple supported operations (such as filtering, deleting, counting, etc.) to the user through a visual interface. The first user can select the first object from the multiple objects and the first operation from the multiple operations in the visual interface, and trigger the client 100 to generate and send the first query instruction by clicking the "Execute" option in the visual interface. After detecting the user's operation, the client 100 generates the first query instruction. In this case, only the meaning of each object and each operation needs to be understood; even mastering OQL is not required.

[0092] Step 402: The data processing device 200 receives the first query instruction and determines that the first query instruction is an OQL-based instruction.

[0093] After generating the first query instruction, the client 100 sends the first query instruction to the data processing device 200. After receiving the first query instruction, the data processing device 200 can first determine whether the received first query instruction is an OQL-based instruction.

[0094] There are many ways for the data processing device 200 to determine whether the received first query instruction is an OQL-based instruction. One method is listed here:

[0095] The first query instruction carries an identifier that identifies it as an OQL-based instruction.

[0096] For client 100, when generating any OQL-based query instruction, it includes an identifier in the query instruction to indicate that the query instruction is OQL-based. Therefore, when generating the first query instruction, client 100 includes this identifier in the first query instruction. For example, if the identifier is / *OQL, the header of the first query instruction will contain / *OQL to indicate that it is an OQL-based instruction.

[0097] After receiving the first query instruction, the data processing device 200 parses the first query instruction and determines whether the identifier exists in the first query instruction. If the identifier exists in the first query instruction, it means that the first query instruction is an OQL-based instruction. If the identifier does not exist in the first query instruction (the first query instruction does not carry the identifier), it means that the first query instruction is not an OQL-based instruction.

[0098] Step 403: The data processing device 200 determines the object metadata of the first user according to the first query instruction.

[0099] When the first query instruction is an OQL-based instruction, the data processing device 200 needs to convert the first query instruction into an SQL-based query instruction, that is, use SQL to describe the first object to be operated on and the first operation to be performed.

[0100] based on Figure 1 As described, the conversion from OQL to SQL requires the use of user object metadata to clarify the mapping relationship between the user-defined first object and the data table in the relational database. Furthermore, since different users may define different first objects, the object metadata of the first user needs to be determined before converting the first query command.

[0101] The data processing device 200 stores object metadata of different users. The first query instruction carries the information of the first user. The data processing device 200 can obtain the object metadata of the first user from the stored object metadata of different users based on the information of the first user.

[0102] In other words, the data processing device 200 stores object metadata for multiple users and information for each user, using the information for each user to identify that the stored object metadata belongs to that user. After obtaining the information of the first user from the first query instruction, the data processing device 200 uses the information of the first user to query the information of each user stored therein, thereby obtaining the object metadata of the first user.

[0103] The following uses the first user as an example to introduce the information contained in the object metadata of the first user: The object metadata of the first user may contain:

[0104] ① The data table containing the first object, which can be called the target table.

[0105] As described above regarding the first object, it can be understood as a user-defined data entity with multiple attributes. "User-defined" means configured by the user based on their own needs. Users can configure a type of object according to their requirements, such as configuring the identifier of the first object and one or more attributes that the first object must possess. For example, a user defines a first object as "employee," whose identifier (also called the first object name) is "employee," and defines that an employee needs to have three attributes: name, age, gender, and mobile phone number.

[0106] For any specific first object, such as employee A, the name, age, gender, and mobile phone number of employee A are the data contained in that specific first object.

[0107] A first type of user-defined first object can be stored in a data table; that is, the data contained in this type of first object can be stored in a data table. The embodiments of this application do not limit the number of data tables containing the first object; that is, the first object can be stored in one or more data tables.

[0108] The object metadata of the first user can record the data table where the first object is located, so as to determine the data table where the first object is located based on the identifier of the first object (which can be carried in the first query instruction).

[0109] ② The correspondence between the attributes of the first object and the fields of the target table.

[0110] The first object is stored in the target table, and the attributes of any specific first object will be stored in this table. Each attribute of the first object can correspond to a field in the database.

[0111] ③ The correspondence between the data types of each attribute of the first object and the data types of each field in the data table.

[0112] For any given data table, the data types of its fields are typically fixed, such as strings, integers, and floating-point numbers. The attributes of a primary object, as a form of data, also have their own data types. However, because the attributes of a primary object are diverse, their data types may not be the same as the data types of the fields in the data table. Therefore, when storing a specific attribute of a primary object, it is necessary to convert the attribute's data type to a data type provided by the data table. For example, taking the primary object "employee" as an example, one attribute of this employee is their date of employment. There is no data type in the data table that directly represents year and month. Therefore, when storing the employee's date of employment, it can be converted to a string format and recorded as a string.

[0113] ④ The length and / or precision of each attribute of the first object.

[0114] The length and / or precision of each attribute of the first object are also the length and / or precision of each field corresponding to the attribute in the data table. Length represents the total length of the field, and precision represents the accuracy of the field, such as the fourth decimal place.

[0115] ⑤ Extension Mode: Describes how the extended attributes of the first object are stored. Extension modes include, but are not limited to: unified extension table extension, independent extension table extension, and local table extension.

[0116] This section introduces two concepts: "extended attributes." The "extended attributes" of the first object are its special attributes. Extended attributes are user-defined attributes that the first object may use. Extended attributes can be understood as supplementary information about the first object. This information is only used in certain special cases. To distinguish the different attributes of the first object and the data tables they reside in, the attributes of the first object other than extended attributes are called the general attributes of the first object. Correspondingly, the data table storing the general attributes of the first object is called the standard table. The target table mentioned earlier is the standard table, and the table that only stores extended attributes is called the extended table. The attributes involved in ② and ③ are general attributes.

[0117] As extended attributes of the first object, they also need to be stored in a relational database. This requires using the extended schema of the first object to store the extended attributes of the first object. Three extended schemas are provided here, which will be introduced below.

[0118] Extension Mode 1: Unified Extension Table Extension.

[0119] Unified extension table extension refers to storing the extended attributes of various objects belonging to the first user in one or more data tables. These one or more data tables can be called extension tables. In other words, the extension tables can record the extended attributes of various different objects belonging to the first user (including the first object). For example, the first user defines two types of objects: a company and an employee. The extended attributes of the company and the extended data of the employee are both stored in the extension table.

[0120] Extension Mode 2: Independent Extended Table Extension.

[0121] Unified extension table expansion refers to storing the extended attributes of each object of the first user in one or more separate extension tables. Extended attributes of different object categories are stored in different tables; that is, for any given object, its extended attributes occupy a dedicated extension table. In other words, an extension table can record only the extended attributes of one type of object from the first user. For example, if the first user defines two types of objects—company and employee—the company's extended attributes are stored in one extension table, and the employee's extended attributes are stored in another.

[0122] Extended Mode 3: This table is extended.

[0123] This table extension refers to storing the extended attributes of the first user's object in the standard table where the first object resides. In other words, the standard table records both the general attributes and the extended attributes of the first object.

[0124] The above only lists the information that may be contained in the object metadata of the first user. In practical applications, the object metadata of the first user may also contain other information. For example, the object metadata of the first user may also record data table relationships. This data table reference relationship is used to characterize the relationship between the data table (i.e., the standard table) where the first object resides and other data tables. This relationship includes, but is not limited to, master-slave relationships and reference relationships. Among them, a master-slave relationship means that one data table is a child table of another data table, that is, one data table contains another data table. A reference relationship means that one data table references the content of another data table.

[0125] Step 404: The data processing device 200 converts the first query instruction into a second query instruction, which is an SQL-based instruction.

[0126] After acquiring the object metadata of the first user, the data processing device 200 can determine the data table where the first object resides, as well as the correspondence between the attributes of the first object and the fields in the data table. Based on this, the first operation on the first object is converted into a first operation on the target table (or the fields in the target table).

[0127] For example, still taking the first object of the first user as "employees", the first query instruction instructs to count the number of employees aged 35 and above. This first query instruction carries the object name "employee" for the first object of the "employees" category and indicates that the number of people aged > 35 is being retrieved.

[0128] After the data processing device 200 converts the first query instruction into a second query instruction, the second query instruction carries the data table where the employee is located and indicates the number of employees whose age field is greater than 35.

[0129] This section briefly describes the process of converting the first query instruction into the second query instruction, that is, the conversion process from OQL to SQL. Figure 5 As shown:

[0130] Step 0: Parse the first query command to determine the information of the first user, and then determine the object metadata of the first user. Step 0 is a preparatory step for the conversion process from OQL to SQL, and its specific execution process can be found in step 403.

[0131] Step 1: Convert the first query command into an OQL abstract syntax tree (AST). An abstract syntax tree is a tree-like representation of the abstract syntax structure of source code, where each node in the tree represents a structure in the source code.

[0132] Step 2: Analyze the OQL abstract syntax tree to determine if it meets the OQL syntax specification. If it does, proceed to Step 3; otherwise, stop the conversion process and notify the user of the first query command error via client 100.

[0133] Step 3: Rewrite the OQL abstract syntax tree based on the object metadata of the first user, and convert the OQL abstract syntax tree into an SQL abstract syntax tree.

[0134] Step 4: Generate the second query instruction based on the SQL abstract syntax tree.

[0135] For example, a relational database pre-configures a table named `t_order` for recording e-commerce orders. The pre-configured extension mode is a unified extension table extension, and the corresponding extension table is named `t_strl_entilty_extend`. A first user can define a first object—an order. An order has two general attributes: order number and order quantity, and two extended attributes: order type and order mode. The first user's information is user A. The first user's object metadata indicates: the order is stored in the `t_order` table, its extended attributes are stored in the `t_strl_entilty_extend` table, the correspondence between the order's general attributes and fields in the `t_order` table, and the object relationship between the order's extended attributes and fields in the `t_strl_entilty_extend` table.

[0136] When it is necessary to filter the orders with order number t from the first user, the first query command is: / *OQL:{"rid":"User A"}* / select t.orderNumber,t.orderAmount,t.#from order t, where *OQL is an identifier used to indicate that the first query command is an OQL command, and "rid":"User A" is the information of the first user.

[0137] The second query command obtained after conversion is: select t.order_number as orderNumber,t.order_amount as orderAmount,t1.v1 as carType,t1.v2 as carModel from t_ordert left join t_strl_entity_extend t1 on t1.id=t1.master_id and t1.renter_id=#tenantA'where t.renter_id=tenantA.

[0138] When a new order needs to be inserted into the first user's order, the first query command is: / *OQL:{"rid":"User A"}* / Ainsert into order(id,orderNumber,orderAmount,carType,carModel)|values(id1,"09-123","123","Type 1","Model1").

[0139] The second query instruction obtained after conversion includes:

[0140] The command for the data table t_order is insert into t_order(id,order_number,order_amount,retenter_id)values(id1,09-123","123","User A").

[0141] The command for the extended table t_strl_entilty_extend is insert into t str entityextend(master id,v1,v2,retenter id)values(id1,"Type1""Model1".“User A").

[0142] When it is necessary to modify the order with order number 09-123 in the first user, the first query command is: / *OQL:{"rid":"User A"}* / update order set orderNumber="09-123",carType="Type1"whereid=id1.

[0143] The second query instruction obtained after conversion includes:

[0144] The command for the data table t_order is update t_order set order_number="09-123"where id=id1 and retent_id="User A".

[0145] The command for the extended table t_strl_entilty_extend is update t_str_entity_extend setv1 = "Type1" where master_id = id1 and renter_id = "User A".

[0146] When it is necessary to delete the order with order number id1 from the first user's order list, the first query command is: / *OQL:{"rid":"User A"}* / delete from order t where t.id=id1.

[0147] The second query instruction obtained after conversion includes:

[0148] The command for the data table t_order is delete from t_order t where t.id=id1 and t.retent_id="User A".

[0149] The command for the extended table t_strl_entity_extend is delete from t_str_entity_extend t where t.master_Id = 1d1 and t.renter id = "user A".

[0150] In some scenarios, when executing step 404, the data processing device can save the second query instruction, that is, save each converted SQL-based query instruction and record the original OQL-based query instruction. This way, when any subsequent OQL-based query instruction is received, the device first checks the recorded pre- and post-conversion query instructions to determine if the received query instruction has been converted. If it has been converted, the saved converted SQL-based query instruction is directly retrieved and executed, avoiding additional conversion operations and improving the execution efficiency of the query instruction.

[0151] Step 405: The data processing device 200 executes the second query instruction and obtains the first query result.

[0152] When the data processing device 200 receives the second query instruction, which is an SQL query instruction, and the database deployed by the data processing device 200 is a relational database, the data processing device 200 can directly execute the second query instruction on this relational database, thereby obtaining the first query result.

[0153] Taking the second query instruction as an example, which carries the data table where the employees are located and indicates the number of rows in the data table where the age field is greater than 35, each row in the data table represents one employee. Therefore, the number of rows in the data table where the age field is greater than 35 is the number of rows in the data table where the age field is greater than 35.

[0154] Step 406: The data processing device 200 sends the first query result to the user through the client 100.

[0155] After obtaining the first query result, the data processing device 200 can provide feedback on the first query result to the user. For example, the data processing device 200 transmits the first query result to the client 100, which provides feedback on the first query result through a user-facing interface.

[0156] Based on the same inventive concept as the method embodiments, this application also provides a data processing apparatus 600, which is used to execute the method executed by the data processing device 200 in the above method embodiments. For example... Figure 6As shown, the data processing device 600 is equipped with a relational database and includes a receiving module 601, a conversion module 602, and an execution module 603. Specifically, in the interface management device 600, the modules are connected through a communication path.

[0157] The receiving module 601 is used to receive a first query instruction triggered by a first user. The first query instruction is an OQL-based instruction and is used to instruct the execution of a first operation for a first object.

[0158] The conversion module 602 is used to convert the first query instruction into a second query instruction. The second query instruction is an SQL-based instruction and is used to instruct the execution of the first operation on the target table, which is a data table in a relational database that stores the first object.

[0159] Execution module 603 is used to execute the second query instruction.

[0160] Although not shown, the data processing device 600 may also include a feedback module for providing query results (such as a first query result or a second query result) to the user.

[0161] In one possible implementation, the receiving module 601 receives a third query instruction triggered by a second user. This third query instruction is an OQL-based instruction and instructs the execution of a first operation on a second object. The conversion module 602 converts the third query instruction into a fourth query instruction. This fourth query instruction is an SQL-based instruction, and the third query instruction instructs the execution of the first operation on a target table that stores the second object. The execution module 603 executes the fourth query instruction.

[0162] In one possible implementation, the data processing device 600 stores object metadata of at least one user, where each object indicates a mapping relationship between an object and a data table in a relational database. When the conversion module 602 converts the first query instruction, it obtains the object metadata of the first user from the object metadata of the at least one user. Based on the object metadata of the first user, the conversion module 602 converts the first query instruction into a second query instruction.

[0163] As one possible implementation, the first query instruction carries information about the first user.

[0164] As one possible implementation, the first query instruction carries an identifier that identifies the first query instruction as an OQL-based instruction.

[0165] In one possible implementation, the execution module 603 stores the first query instruction and the second query instruction. The receiving module 601 receives a sixth query instruction triggered by the first user. The sixth query instruction is an OQL-based instruction used to instruct the execution of a first operation against the first object.

[0166] If the sixth query instruction matches the first query instruction, the execution module 603 executes the second query instruction.

[0167] As one possible implementation, the object metadata of the first user includes some or all of the following:

[0168] The target table containing the first object;

[0169] The correspondence between the attributes of the first object and the fields in the target table;

[0170] The length and / or precision of each attribute of the first object.

[0171] The module division in this application embodiment is illustrative and only represents one logical functional division. In actual implementation, other division methods may be used. Furthermore, the functional modules in the various embodiments of this application can be integrated into a single processor, exist as separate physical entities, or be integrated into a single module. The integrated modules described above can be implemented in hardware or as software functional modules.

[0172] If the integrated module is implemented as a software functional module and sold or used as an independent product, it can be stored in a computer-readable storage medium. Based on this understanding, the technical solution of this application, in essence, or the part that contributes to the prior art, or all or part of the technical solution, can be embodied in the form of a software product. This computer software product is stored in a storage medium and includes several instructions to cause a terminal device (which may be a personal computer, mobile phone, or network device, etc.) or processor to execute all or part of the steps of the methods in the various embodiments of this application. The aforementioned storage medium includes various media capable of storing program code, such as USB flash drives, portable hard drives, read-only memory (ROM), random access memory (RAM), magnetic disks, or optical disks.

[0173] This application also provides, for example Figure 7 The computing device 700 shown includes a bus 701, a processor 702, a communication interface 703, and a memory 704. The processor 702, the memory 704, and the communication interface 703 communicate with each other via the bus 701.

[0174] The processor 702 can be a central processing unit (CPU) or other specific integrated circuits. The processor 132 can also be other general-purpose processors, digital signal processors (DSPs), application-specific integrated circuits (ASICs), field-programmable gate arrays (FPGAs), or other programmable logic devices, discrete gate or transistor logic devices, discrete hardware components, etc.

[0175] The memory 704 can be dynamic random access memory (DRAM). Besides DRAM, the memory 704 can also be other types of random access memory, such as static random access memory (SRAM). Additionally, the memory 704 can also be read-only memory (ROM). For example, read-only memory can be programmable read-only memory (PROM) or erasable programmable read-only memory (EPROM). The memory 704 can also be flash memory, hard disk drive (HDD), or solid-state drive (SSD).

[0176] The memory 704 stores computer program instructions, and the processor 702 executes these computer program instructions to perform the aforementioned tasks. Figure 4 The steps performed by the data processing device 200. The memory 704 may also include other software modules required for running processes, such as an operating system (e.g., multiple modules in the data processing device 600). The operating system may be LINUX. TM UNIX TM WINDOWS TM wait.

[0177] This application also provides a computing device system, the computing device system including at least one such as Figure 8The computing device 800 shown includes a bus 801, a processor 802, a communication interface 803, and a memory 804. The processor 802, memory 804, and communication interface 803 communicate with each other via the bus 801. At least one computing device 800 in the computing device system communicates with each other via a communication path.

[0178] The specific types of processor 802 and memory 804 can be found in the relevant descriptions of processor 702 and memory 704, and will not be repeated here. Processor 802 executes the computer program instructions stored in memory 804 to perform the aforementioned tasks. Figure 4 The described method includes some or all of the steps performed by the data processing device 200. The memory may also include other software modules required for the running processes, such as an operating system. The operating system may be Linux. TM UNIX TM WINDOWS TM wait.

[0179] At least one computing device 800 in the computing device system establishes communication with each other through a communication network, and each computing device 800 runs any one or any multiple modules of the data processing device 600.

[0180] The descriptions of the processes corresponding to the above-mentioned figures each have their own emphasis. For parts of a process that are not described in detail, please refer to the relevant descriptions of other processes.

[0181] In the above embodiments, implementation can be achieved, in whole or in part, through software, hardware, firmware, or any combination thereof. When implemented using software, it can be implemented, in whole or in part, in the form of a computer program product. A computer program product includes computer program instructions, which, when loaded and executed on a computer, generate, in whole or in part, the product according to the embodiments of the present invention. Figure 4 The process or function described.

[0182] The computer may be a general-purpose computer, a special-purpose computer, a computer network, or other programmable device. The computer instructions may be stored in a computer-readable storage medium or transmitted from one computer-readable storage medium to another. For example, the computer instructions may be transmitted from one website, computer, server, or data center to another via wired (e.g., coaxial cable, fiber optic, digital subscriber line) or wireless (e.g., infrared, wireless, microwave, etc.) means. The computer-readable storage medium may be any available medium that a computer can access or a data storage device such as a server or data center that integrates one or more available media. The available medium may be a magnetic medium (e.g., floppy disk, hard disk, magnetic tape), an optical medium (e.g., DVD), or a semiconductor medium (e.g., SSD).

[0183] Obviously, those skilled in the art can make various modifications and variations to this application without departing from the scope of this application. Therefore, if such modifications and variations fall within the scope of the claims of this application and their equivalents, this application also intends to include such modifications and variations.

Claims

1. A data processing method, characterized in that, The method is applied to a data processing device, on which a relational database is deployed, and the method includes: Receive a first query instruction triggered by a first user, wherein the first query instruction is an instruction based on Object Query Language (OQL), and the first query instruction is used to instruct the execution of a first operation against a first object; The first query instruction is converted into a second query instruction, which is an instruction based on the Structured Query Language (SQL). The second query instruction is used to instruct the execution of the first operation on the target table, which is a data table in the relational database that stores the first object. Execute the second query instruction.

2. The method as described in claim 1, characterized in that, The method further includes: Receive a third query instruction triggered by a second user, the third query instruction being an OQL-based instruction, the third query instruction being used to instruct the first operation to be performed on a second object; The third query instruction is converted into a fourth query instruction, which is an SQL-based instruction. The third query instruction is used to instruct the execution of the first operation on the target table, which stores the second object. Execute the fourth query instruction.

3. The method as described in claim 1 or 2, characterized in that, The data processing device includes object metadata for at least one user, the object indicating the mapping relationship between the object and a data table in the relational database, and the step of converting the first query instruction into a second query instruction includes: Obtain the object metadata of the first user from the object metadata of the at least one user; Based on the object metadata of the first user, the first query instruction is converted into a second query instruction.

4. The method according to any one of claims 1 to 3, characterized in that, The first query instruction carries the information of the first user.

5. The method according to any one of claims 1 to 4, characterized in that, The first query instruction carries an identifier, which is used to identify that the first query instruction is an OQL-based instruction.

6. The method according to any one of claims 1 to 5, characterized in that, The method further includes: Save the first query instruction and the second query instruction; Receive a sixth query instruction triggered by the first user, the sixth query instruction being an OQL-based instruction, the sixth query instruction being used to instruct the first operation to be performed on the first object; If the sixth query instruction is consistent with the first query instruction, the second query instruction is executed.

7. The method according to any one of claims 3 to 6, characterized in that, The object metadata of the first user includes some or all of the following: The target table containing the first object; The correspondence between each attribute of the first object and each field in the target table; The length and / or precision of each attribute of the first object.

8. A data processing apparatus, characterized in that, The device is equipped with a relational database, and the device includes: The receiving module is configured to receive a first query instruction triggered by a first user, wherein the first query instruction is an instruction based on the Object Query Language (OQL), and the first query instruction is used to instruct the execution of a first operation for a first object; A conversion module is used to convert the first query instruction into a second query instruction, wherein the second query instruction is an instruction based on the structured query language SQL, and the second query instruction is used to instruct the execution of the first operation on a target table, wherein the target table is a data table in the relational database that stores the first object; The execution module is used to execute the second query instruction.

9. The apparatus as claimed in claim 8, characterized in that, The receiving module is further configured to: receive a third query instruction triggered by a second user, the third query instruction being an OQL-based instruction, the third query instruction being used to instruct the execution of the first operation for the second object; The conversion module is further configured to: convert the third query instruction into a fourth query instruction, wherein the fourth query instruction is an SQL-based instruction, and the third query instruction is used to instruct the execution of the first operation on the target table, wherein the target table stores the second object; The execution module is further configured to: execute the fourth query instruction.

10. The apparatus as claimed in claim 8 or 9, characterized in that, The device stores object metadata for at least one user, the objects indicating mapping relationships between objects and data tables in the relational database. The conversion module is used for: Obtain the object metadata of the first user from the object metadata of the at least one user; Based on the object metadata of the first user, the first query instruction is converted into a second query instruction.

11. The apparatus according to any one of claims 8 to 10, characterized in that, The first query instruction carries the information of the first user.

12. The apparatus according to any one of claims 8 to 11, characterized in that, The first query instruction carries an identifier, which is used to identify that the first query instruction is an OQL-based instruction.

13. The apparatus according to any one of claims 8 to 12, characterized in that, The execution module is further configured to: Save the first query instruction and the second query instruction; The receiving module is further configured to: receive a sixth query instruction triggered by the first user, the sixth query instruction being an OQL-based instruction, the sixth query instruction being used to instruct the first operation to be performed on the first object; The execution module is further configured to: execute the second query instruction if the sixth query instruction is consistent with the first query instruction.

14. The apparatus according to any one of claims 10 to 13, characterized in that, The object metadata of the first user includes some or all of the following: The target table containing the first object; The correspondence between each attribute of the first object and each field in the target table; The length and / or precision of each attribute of the first object.

15. A computing device, characterized in that, The computing device includes a memory and a processor; The memory stores metadata indexes; The processor is used to perform the method as described in any one of claims 1 to 7.

16. A computer-readable storage medium, characterized in that, When the computer-readable storage medium is executed by a computing device, the computing device performs the method as described in any one of claims 1 to 7.

Images