CN118092972A - Thermal updating method, thermal updating device, computer equipment and storage medium - Google Patents
Thermal updating method, thermal updating device, computer equipment and storage medium Download PDFInfo
- Publication number
- CN118092972A CN118092972A CN202410283807.4A CN202410283807A CN118092972A CN 118092972 A CN118092972 A CN 118092972A CN 202410283807 A CN202410283807 A CN 202410283807A CN 118092972 A CN118092972 A CN 118092972A
- Authority
- CN
- China
- Prior art keywords
- data
- statement
- hot update
- configuration file
- target
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Pending
Links
- 238000000034 method Methods 0.000 title claims abstract description 49
- 238000003860 storage Methods 0.000 title claims abstract description 43
- 238000013515 script Methods 0.000 claims abstract description 78
- 238000004590 computer program Methods 0.000 claims abstract description 28
- 230000004044 response Effects 0.000 claims description 11
- 230000001960 triggered effect Effects 0.000 claims description 2
- 238000010586 diagram Methods 0.000 description 10
- 238000007726 management method Methods 0.000 description 6
- 230000008569 process Effects 0.000 description 6
- 230000008859 change Effects 0.000 description 5
- 238000004458 analytical method Methods 0.000 description 4
- 238000011161 development Methods 0.000 description 4
- 230000006870 function Effects 0.000 description 4
- 238000004891 communication Methods 0.000 description 3
- 230000002085 persistent effect Effects 0.000 description 3
- 238000012545 processing Methods 0.000 description 3
- 230000008901 benefit Effects 0.000 description 2
- 238000004364 calculation method Methods 0.000 description 2
- 238000013500 data storage Methods 0.000 description 2
- 230000000694 effects Effects 0.000 description 2
- 238000005516 engineering process Methods 0.000 description 2
- 239000000945 filler Substances 0.000 description 2
- 238000002347 injection Methods 0.000 description 2
- 239000007924 injection Substances 0.000 description 2
- 230000002688 persistence Effects 0.000 description 2
- 239000000243 solution Substances 0.000 description 2
- 230000003068 static effect Effects 0.000 description 2
- OKTJSMMVPCPJKN-UHFFFAOYSA-N Carbon Chemical compound [C] OKTJSMMVPCPJKN-UHFFFAOYSA-N 0.000 description 1
- 230000006978 adaptation Effects 0.000 description 1
- 230000006399 behavior Effects 0.000 description 1
- 230000005540 biological transmission Effects 0.000 description 1
- 238000004422 calculation algorithm Methods 0.000 description 1
- 230000015556 catabolic process Effects 0.000 description 1
- 238000004883 computer application Methods 0.000 description 1
- 238000006731 degradation reaction Methods 0.000 description 1
- 229910021389 graphene Inorganic materials 0.000 description 1
- 238000004519 manufacturing process Methods 0.000 description 1
- 238000012986 modification Methods 0.000 description 1
- 230000004048 modification Effects 0.000 description 1
- 230000003287 optical effect Effects 0.000 description 1
- 238000005457 optimization Methods 0.000 description 1
- 238000012360 testing method Methods 0.000 description 1
Classifications
-
- Y—GENERAL TAGGING OF NEW TECHNOLOGICAL DEVELOPMENTS; GENERAL TAGGING OF CROSS-SECTIONAL TECHNOLOGIES SPANNING OVER SEVERAL SECTIONS OF THE IPC; TECHNICAL SUBJECTS COVERED BY FORMER USPC CROSS-REFERENCE ART COLLECTIONS [XRACs] AND DIGESTS
- Y02—TECHNOLOGIES OR APPLICATIONS FOR MITIGATION OR ADAPTATION AGAINST CLIMATE CHANGE
- Y02D—CLIMATE CHANGE MITIGATION TECHNOLOGIES IN INFORMATION AND COMMUNICATION TECHNOLOGIES [ICT], I.E. INFORMATION AND COMMUNICATION TECHNOLOGIES AIMING AT THE REDUCTION OF THEIR OWN ENERGY USE
- Y02D10/00—Energy efficient computing, e.g. low power processors, power management or thermal management
Landscapes
- Information Retrieval, Db Structures And Fs Structures Therefor (AREA)
Abstract
The present application relates to a method, an apparatus, a computer device, a storage medium and a computer program product for hot updating. The method comprises the following steps: determining a target hot update version; acquiring a configuration file corresponding to the target hot update version, wherein the configuration file comprises a statement configuration file and an interface information configuration file; generating an operation script according to the statement configuration file, and creating an initial hot update data table of the target application program under the target hot update version according to the operation script; obtaining data to be cached according to the interface information configuration file, and generating a data caching statement according to the data to be cached and the statement configuration file; executing the data caching statement, and writing the data to be cached into the initial hot update data table to obtain a target hot update data table of the target application program under the target hot update version. The method can be used for dynamically and flexibly realizing real-time thermal updating.
Description
Technical Field
The present application relates to the field of computer technology, and in particular, to a method, an apparatus, a computer device, a storage medium, and a computer program product for hot update.
Background
With the continuous progress of science and technology in recent years, persistent cache data in mobile application programs is widely used. Persistent caching refers to the storage of data in a local storage medium in a mobile application for reuse in subsequent application starts or sessions, which allows the application to directly retrieve the cached data from local storage without having to request the server again or recalculate the data. This has the advantage that it can provide faster data access speeds, offline access capabilities and better user experience.
However, in the current data persistence caching method in the mobile application program, once the field or table data is newly added subsequently, the corresponding code of the mobile application program is always required to be synchronously modified to ensure that the data object and the data table structure in the application program are consistent, then the modified code is also required to be compiled and packaged, and finally the update is pushed to the user side through the version-sending process, so that the data persistence caching of the new version is realized. And are not flexible enough to meet the frequently changing demand response.
Disclosure of Invention
In view of the foregoing, it is desirable to provide a thermal update method, apparatus, computer device, computer readable storage medium, and computer program product that enable dynamic real-time thermal update.
In a first aspect, the present application provides a method of thermal updating. The method comprises the following steps:
Determining a target hot update version;
acquiring a configuration file corresponding to the target hot update version, wherein the configuration file comprises a statement configuration file and an interface information configuration file;
generating an operation script according to the statement configuration file, and creating an initial hot update data table of the target application program under the target hot update version according to the operation script;
Obtaining data to be cached according to the interface information configuration file, and generating a data caching statement according to the data to be cached and the statement configuration file;
and executing the data caching statement, and writing the data to be cached into the initial hot update data table to obtain a target hot update data table of the target application program under the target hot update version.
In a second aspect, the application further provides a thermal updating device. The device comprises:
a determining module for determining a target hot update version;
The acquisition module is used for acquiring a configuration file corresponding to the target hot update version, wherein the configuration file comprises a statement configuration file and an interface information configuration file;
The creation module is used for generating an operation script according to the statement configuration file and creating an initial hot update data table of the target application program under the target hot update version according to the operation script;
the generation module is used for acquiring data to be cached according to the interface information configuration file and generating a data caching statement according to the data to be cached and the statement configuration file;
And the execution module is used for executing the data caching statement, writing the data to be cached into the initial hot update data table, and obtaining a target hot update data table of the target application program under the target hot update version.
In a third aspect, the present application also provides a computer device. The computer device comprises a memory storing a computer program and a processor which when executing the computer program performs the steps of:
Determining a target hot update version;
acquiring a configuration file corresponding to the target hot update version, wherein the configuration file comprises a statement configuration file and an interface information configuration file;
generating an operation script according to the statement configuration file, and creating an initial hot update data table of the target application program under the target hot update version according to the operation script;
Obtaining data to be cached according to the interface information configuration file, and generating a data caching statement according to the data to be cached and the statement configuration file;
and executing the data caching statement, and writing the data to be cached into the initial hot update data table to obtain a target hot update data table of the target application program under the target hot update version.
In a fourth aspect, the present application also provides a computer-readable storage medium. The computer readable storage medium having stored thereon a computer program which when executed by a processor performs the steps of:
Determining a target hot update version;
acquiring a configuration file corresponding to the target hot update version, wherein the configuration file comprises a statement configuration file and an interface information configuration file;
generating an operation script according to the statement configuration file, and creating an initial hot update data table of the target application program under the target hot update version according to the operation script;
Obtaining data to be cached according to the interface information configuration file, and generating a data caching statement according to the data to be cached and the statement configuration file;
and executing the data caching statement, and writing the data to be cached into the initial hot update data table to obtain a target hot update data table of the target application program under the target hot update version.
In a fifth aspect, the present application also provides a computer program product. The computer program product comprises a computer program which, when executed by a processor, implements the steps of:
Determining a target hot update version;
acquiring a configuration file corresponding to the target hot update version, wherein the configuration file comprises a statement configuration file and an interface information configuration file;
generating an operation script according to the statement configuration file, and creating an initial hot update data table of the target application program under the target hot update version according to the operation script;
Obtaining data to be cached according to the interface information configuration file, and generating a data caching statement according to the data to be cached and the statement configuration file;
and executing the data caching statement, and writing the data to be cached into the initial hot update data table to obtain a target hot update data table of the target application program under the target hot update version.
The above-described thermal update method, apparatus, computer device, storage medium, and computer program product, by determining a target thermal update version; acquiring a configuration file corresponding to the target hot update version, wherein the configuration file comprises a statement configuration file and an interface information configuration file; generating an operation script according to the statement configuration file, and creating an initial hot update data table of the target application program under the target hot update version according to the operation script; obtaining data to be cached according to the interface information configuration file, and generating a data caching statement according to the data to be cached and the statement configuration file; executing the data caching statement, and writing the data to be cached into the initial hot update data table to obtain a target hot update data table of the target application program under the target hot update version. The adaptation capability of the persistent cache data in the mobile application program to the database structure adjustment or the newly added field is enhanced, the dynamic real-time thermal update is more flexibly realized, the more flexible query capability is provided, the data transmission quantity is reduced, and the response speed of cache data reading is increased, so that the frequently-changed demand response is met.
Drawings
FIG. 1 is an application environment diagram of a thermal update method in one embodiment;
FIG. 2 is a flow diagram of a thermal update method in one embodiment;
FIG. 3 is a flow diagram of the acquisition of a configuration file in one embodiment;
FIG. 4 is a flow diagram of the execution of a data cache statement in one embodiment;
FIG. 5 is a schematic diagram of dynamic querying in one embodiment;
FIG. 6 is a flow chart of a thermal update method according to another embodiment;
FIG. 7 is a block diagram of the structure of a thermal update apparatus in one embodiment;
FIG. 8 is a block diagram showing the structure of a thermal updating apparatus according to another embodiment;
fig. 9 is an internal structural diagram of a computer device in one embodiment.
Detailed Description
The present application will be described in further detail with reference to the drawings and examples, in order to make the objects, technical solutions and advantages of the present application more apparent. It should be understood that the specific embodiments described herein are for purposes of illustration only and are not intended to limit the scope of the application.
The thermal updating method provided by the embodiment of the application can be applied to an application environment shown in figure 1. Wherein the terminal 102 communicates with the server 104 via a network. The data storage system may store data that the server 104 needs to process. The data storage system may be integrated on the server 104 or may be located on a cloud or other network server. The terminal 102 generates a thermal update request and then sends the thermal update request to the server 104 to cause the server 104 to generate a target thermal update data table. The terminal 102 may be, but not limited to, various personal computers, notebook computers, smart phones, tablet computers, internet of things devices, and portable wearable devices, where the internet of things devices may be smart speakers, smart televisions, smart air conditioners, smart vehicle devices, and the like. The portable wearable device may be a smart watch, smart bracelet, headset, or the like. The server 104 may be implemented as a stand-alone server or as a server cluster of multiple servers.
In one embodiment, as shown in fig. 2, a method for hot update is provided, which is illustrated by using the method applied to the server 104 in fig. 1 as an example, and includes the following steps:
Step 202, a target hot update version is determined.
The target application program in the application refers to an application program which a user logs in at a terminal. The target hot update version is the version of the configuration file that is used to update the data table. It will be appreciated that the hot update version comprises a plurality of versions, each version having a unique identity, optionally distinguishable by a combination of different user identities and dataset identities. For example, the user identification and dataset identification corresponding to the hot update version 1.0.0 is Zhang san. 1213812138; the user identification and dataset identification corresponding to the hot update version 2.0.0 is Zhang San 1314159265. In the present application, the data set may be a ledger, which refers to a data set specifically set up for a particular accounting entity, which contains all accounting business data and setup information related to the entity. The core function of the account cover is to record and manage the financial information of the enterprise, and support the activities of accounting, cost calculation, financial statement establishment, relevant decision analysis and the like of the enterprise. It is to be readily understood that the manner of triggering the hot update operation for the target application program is not particularly limited in the present application, and may be set according to actual needs.
Specifically, after a user logs in a certain application program of the terminal, a user identifier and an account cover identifier corresponding to the hot update operation are determined in response to the hot update operation performed by the user in the application program, and then the version of the configuration file for updating the data table is determined according to the determined user identifier and account cover identifier.
Alternatively, the application program may name the configuration files by unique user identification and account id, for example, by using a login user id of the application program and an account id selected by a user in the application program, where field information of each user is different, and may provide configuration files of different versions of the user through a back end API (application programming interface), and then create a unique data table for each user in a user dimension, so as to ensure that query data is dynamically changed along with fields of the user data table.
Step 204, obtaining a configuration file corresponding to the target hot update version, wherein the configuration file comprises a statement configuration file and an interface information configuration file.
The SOL configuration file is mainly used for dynamically creating table data; the interface information configuration file is a Config configuration file (a computer file mainly used for storing and organizing configuration information and parameter settings of application programs, system services or hardware components, wherein the file contains various key data influencing program operation, such as an API key, database connection parameters, interface language selection, performance optimization options, security settings and the like.
Specifically, after determining the version of the configuration file (i.e., the target hot update version), the configuration file corresponding to the version of the configuration file is obtained according to the version of the configuration file, and it can be understood that the configuration file includes two types, namely an SQL configuration file and a Config configuration file. The configuration file is obtained by directly obtaining the configuration file from the local and downloading the configuration file from the cloud.
Optionally, when the version of the configuration file is 1.0.0, firstly detecting whether the file which is already decompressed exists locally and the version of the configuration file in the file is 1.0.0, then judging whether the configuration file in the file is good, if the file which is already decompressed does not exist locally or the file which is already decompressed but exists internally is not good, downloading the configuration file with the version of 1.0.0 at the cloud, and decompressing to the appointed directory of the application program after the downloading is successful.
And 206, generating an operation script according to the statement configuration file, and creating an initial hot update data table of the target application program under the target hot update version according to the operation script.
The main function of the operation script is to read the operation script into the memory of the terminal and then execute the operation script, so as to achieve the purpose of dynamically creating the data table. An initial hot update data table refers to a data table with a certain format and no specific data information entered. Multiple table fields are typically included in the initial hot update data table. In database designs, a data table is a data set for storing information about a certain type of entity, and each data table is composed of a series of columns (i.e., table fields) with specific names and data types, and it should be noted that the specific names in the initial hot update data table are determined at this time, but the columns of the data types are blank, i.e., no data, and automatic filling is required in the subsequent steps.
Specifically, the busd.sys information (an encrypted or compressed DDL script file may include SQL statements required for creating a database table structure or other schema objects) is extracted from the statement configuration file, and the extracted busd.sys information is decrypted and restored to obtain the running script. And then the operation script is read into a memory of the terminal, and after the memory is read, the operation script is finally executed, so that the purpose of dynamically creating the data table is realized, namely, according to the operation script, an initial hot update data table corresponding to the operation script is determined, wherein the initial hot update data table comprises a series of columns with specific names and data types, the specific names in the initial hot update data table are determined at the moment, but the columns with the data types are blank, namely, no data is needed, and automatic filling is needed in the subsequent steps.
Step 208, obtaining the data to be cached according to the interface information configuration file, and generating a data caching statement according to the data to be cached and the statement configuration file.
The interface information configuration file is a Config configuration file, and is used for reading and accessing corresponding application programming interface information, and then acquiring JSON data to be cached through an application programming interface reflected by the application programming interface information. The data cache statement is an SQL statement, and the SQL statement for writing the JSON data into the database table is dynamically generated according to a specific JSON structure and the structure of the target database table.
Specifically, corresponding application programming interface information is read from the Config configuration file, and then JSON data to be cached is obtained from the application programming interface reflected by the application programming interface information. And generating a data cache statement which is used for executing filling the JSON data to be cached into the SQL statement in the initial hot update data table according to the JSON format of the initial hot update data table according to the JSON data and the initial hot update data table obtained in the last step.
Step 210, executing a data caching statement, and writing the data to be cached into the initial hot update data table to obtain a target hot update data table of the target application program under the target hot update version.
The target thermal update data table is a data table after thermal update operation is generated in response to thermal update operation performed by a user in an application program of the terminal after the user logs in the application program.
Specifically, the initial hot update data table, the data caching statement and the JSON data to be cached acquired in the previous step are required to be used, and the JSON data to be cached is filled into the initial hot update data table according to the JSON format of the initial hot update data table by executing the data caching statement, namely the SOL statement, so that the generated hot update data table is the target hot update data table.
In one embodiment, at least one candidate data set identification is presented upon triggering a hot update login operation for a target application; responding to the identification determining operation aiming at least one candidate data set identification to obtain a target data set identification; determining a current grouping environment according to the current login account and the target data set identifier; when the current grouping environment is switched, a version data table corresponding to the current login account and the target data set identifier is displayed; the version data table includes at least one candidate data version; a target hot-updated version is obtained in response to a version determination operation for at least one candidate data version.
Wherein, the data set refers to an independent and complete database set for storing all accounting business data and related information of a specific accounting object in enterprise accounting management and financial management. The data set identifier is an identifier for distinguishing and marking different data sets, the specific form of the data set identifier is not limited, and the data set identifier can be set according to actual needs. For example, the dataset identification may be a sequence number consisting of digits, symbols, and letters. It will be appreciated that a user may have multiple data set identifiers under its name, where all the data set identifiers belong to candidate data set identifiers of the user, the user selects one of the multiple candidate data set identifiers as a target data set identifier, different data set identifiers may determine different packet environments of the user, after the user selects a certain target data set identifier, and after determining the current packet environment, if the user wants to switch the current packet environment to another packet environment under the current target data set identifier, the thermal update scheme described in the present application is triggered. It is to be understood that the present application is not particularly limited to the form of the data set, and may be set according to actual needs. Alternatively, the data set may be a ledger, which refers to a data set specifically set up for a particular accounting entity, which contains all accounting business data and setup information associated with that entity. The core function of the account cover is to record and manage the financial information of the enterprise, and support the activities of accounting, cost calculation, financial statement establishment, relevant decision analysis and the like of the enterprise. Accordingly, the dataset identification may be a ledger identification and the target dataset identification may be a target ledger identification.
Specifically, first when the user logs into the target application, the system displays a plurality of different candidate ledgers for the user to select. Each of the ledgers may correspond to an independent data environment or business rule configuration. And then after the user selects one of the account jacket identifiers according to actual needs, the system records the selection and determines the grouping environment corresponding to the current login account according to the selected account jacket identifier. "grouping environment" herein may be understood as an application deployment environment associated with a particular ledger, such as a development environment, a testing environment, or a production environment. And then when the user switches to a new grouping environment, the system dynamically loads and displays a version data table corresponding to the current login account number and the target account cover identification. This version data table records the version information of the different applications in the environment, possibly including different revisions of the software, update packages of the functional modules, etc. Finally, the user may see at least one candidate version of the data in the version data table, which may be a hot update package available for immediate application. When the user makes a selection from these candidate versions, the system designates the selected candidate version as the target hot update version in response to the user's operation.
Due to the fact that a flexible mode is provided, when a user logs in, according to the data set and the environment requirements of the user, the user can automatically select a proper application version to carry out hot update, the whole application program does not need to be redeployed or the user does not need to wait for unified upgrade, and the customizable and real-time response capability of the system are improved.
In one embodiment, determining a local storage space corresponding to the hot update version, and determining whether the local storage space already stores a configuration file corresponding to the hot update version; if the configuration script file corresponding to the hot update version is stored in the local storage space, extracting the configuration script file corresponding to the hot update version from the local storage space; if the configuration script file corresponding to the hot update version is not stored in the local storage space, the configuration script file corresponding to the hot update version is downloaded from the preset cloud.
Where local storage space refers to the space used by a device or browser to store data locally (i.e., on a user device) in the field of computer and Web application development. Configuration file refers in the present application to a series of parameters, settings or structured data files that are required for the running of an application program that define the relevant configuration information of a data table for storing specific data. The configuration script file refers to a script file generated according to configuration information for performing a series of actions for generating a data table storing specific data.
Specifically, when a hot update procedure is initiated first, a local storage area preset on a user device (for a computer application) or in a browser environment (for a Web application) is first located. This memory space is where the application program is to cache and access the configuration file. And secondly, the system checks whether a configuration script file corresponding to the local storage space exists or not according to the current target hot update version information. Then if the configuration script files matching the target hot update version are found locally, these files are directly extracted from the local storage space for use by the application. The configuration script file typically contains specific instructions that define the data table structure, initialize the data, or perform database schema changes. And when the local storage space does not find the required target version configuration script file, the system automatically connects to a preset cloud server, and downloads the corresponding configuration script file from the cloud server. Finally, the role of the configuration file in this scenario is to provide the application with a series of parameters and settings necessary for its operation, which detail how the particular data table structure and its associated configuration information is organized and managed. The configuration script file is an executable file further generated on the basis of configuration information, and can automatically generate or update a data table structure required by the application program and fill initial data according to configuration content, so that the program can normally operate in a new version environment after hot update.
The configuration script with the correct version is obtained in real time in the hot update flow, so that the hot update in the real sense is realized, namely, the version update and the data structure update of the application program are completed on the premise of not restarting or minimizing interrupt service. And part of the updated content can be read from the local area quickly without waiting for cloud downloading, so that the application starting or updating process can be accelerated, and the user experience is improved.
In one embodiment, structured query language encryption information is determined according to a statement configuration file; acquiring a preset secret key and determining an initialization vector; based on a preset secret key and an initialization vector, decrypting the structured query language encryption information to obtain structured query language decryption information; acquiring filling content used when generating the structured query language encryption information; and removing the filling content in the structured query language script decryption information to obtain an operation script.
The configuration file in the present application includes a statement configuration file, i.e., an SQL configuration file, which has busd.sys information (an encrypted or compressed DDL script file, which may include SQL statements required for creating a database table structure or other schema objects). Decrypting and restoring the busd.sys information in the statement configuration file into DDL script (a script file of a data definition language, which is used as an SQL statement set for defining and managing database schema structures including but not limited to creating, modifying or deleting database objects), then reading the script information into a memory, and executing the script file, thereby achieving the purpose of dynamically creating a data table.
Specifically, first, the system reads a statement configuration file containing key information, specifically referred to as busd.sys, which is an encrypted or compressed DDL script file that encapsulates the original SQL statements needed to create database tables and other schema objects. And secondly, identifying and extracting encryption information for encrypting the busd.sys file according to the instruction in the statement configuration file. In the decryption process, it is necessary to know the filler content used in encryption in order to ensure accurate restoration of the original data after decryption. A preset key and Initialization Vector (IV) are obtained, which are key parameters for decrypting the encrypted data to ensure the security and correctness of the data. And decrypting the encrypted information in the busd.sys by using a preset secret key and an initialization vector through a corresponding decryption algorithm to obtain the decrypted information of the structured query language. The decrypted SQL script may then further contain filler content added at the time of encryption, which needs to be precisely removed before actual execution to restore the true, executable SQL script. After the filling content is cleaned up, the operation script which can be directly used for creating the database table structure is obtained. The final step is to load the obtained running scripts into the memory and execute the scripts by the database management system, thereby achieving the aim of dynamically creating data tables and other mode objects according to the requirements.
Unauthorized access and tampering may be prevented by cryptographically storing the database table structure or the creation statement of the other schema object. Even if the configuration file is stolen or illegally obtained, an attacker cannot directly read out the original SQL script content. And the database structure is created by decrypting and executing the script in the running process, so that the application program can dynamically construct the database structure according to different environments, user rights or security policies, and the portability and adaptability of the system are enhanced.
In one embodiment, a data table name of an initial hot update data table is obtained and converted into an identifier; determining a table field in an initial hot update data table; converting the field name of the table field into a corresponding statement placeholder for each table field; and generating a data cache statement according to the identifier and the statement placeholder corresponding to each table field.
Wherein the data table name is the name of a specific table in the database, which is an identifier for uniquely representing a logical unit storing data in the database. The table field refers to the individual structured elements in the database table that represent different attributes or data items for each row of the record in the table. Each table field has a field name that identifies what type of data the field stores and its meaning in the business logic. An identifier refers to a name in programming or database management that is used to uniquely represent and reference a particular object, variable, or resource. The field names refer to column names in the database table. Each table field has a corresponding field name that identifies the meaning and content type of that column of data. Initial hot update data tables refer to those database tables that need to be updated in real time or frequently and whose contents are cached in faster storage media (e.g., memory cache, distributed cache system, etc.) in order to improve data access performance. The data table is characterized in that the data change is active and the time efficiency requirement is high. It will be appreciated that the specific form of the initial thermal update data table is not limited and may be set according to actual needs. Statement placeholders refer to a special symbol used to temporarily replace an actual value in a predefined or dynamically generated SQL (structured query language) statement. Typically, these placeholders are used to represent locations that will be replaced with specific data values when executed.
Specifically, the actual name thereof in the database, i.e., the data table name, is first obtained from the specified initial hot update data table. This data table name is converted into an identifier that can be identified and referenced in the programming or database management environment. For example, in an SQL query statement, it may be used as an object reference. The initial thermally updated data table structure is then analyzed to list all of the table fields therein, each table field representing a different attribute or data item for each row of records in the table. For each table field, its field name is specified, which is used to identify the type of data stored in the field and its meaning in the business logic. Next, for each determined table field, the field name is replaced by a statement placeholder in the SQL statement, and it is understood that the specific method of replacement is not limited in the present application, and can be set according to actual needs. For example, the primary purpose of the ORM tool is to simplify the operation of the database by a developer, to enable the developer to operate on the database in an object-oriented manner, rather than directly writing SQL query statements.
Because the cache update statement is dynamically generated according to the actual data table structure, the method can adapt to the change of the database table structure, does not need to manually write and maintain a large amount of SQL codes, and improves the development efficiency and the maintainability of the system. And because the scheme can automatically generate the caching strategy according to the structures of different tables, when the table fields are added, modified or deleted, only sentences are needed to be regenerated, and the whole caching machine is not required to be greatly changed. And SQL injection attacks can be prevented due to the use of placeholders instead of actual field values. The real data is transmitted in a parameterized query mode during execution, so that the safety of database operation is ensured.
In one embodiment, the order of the table fields in the initial hot update data table is determined; splicing the sentence placeholders corresponding to each table field according to the arrangement sequence of the table fields in the initial hot update data table to obtain an initial sentence; splicing the identifier to the head of the initial statement to obtain the data cache statement.
The initial statement is a part of SQL statement spliced by the field arrangement sequence of the database table and the corresponding placeholders. Since "insert or replace into (insert or replace enter)" is used, the write or overwrite update is automatically made according to the primary key uniqueness. The "initial statement" generated at this stage contains record-specific key information such as table names or primary keys (identifiers) that essentially describe how the various fields and their order are involved in choosing or updating data from the table. Wherein "insert or replace into" belongs to a variant of SQL, which combines the functions of insert and replace intro. When executing this statement, the database will attempt to insert a row of data into the table: if the inserted record has its primary key (or unique index) not already present in the table, the behavior is exactly the same as insert into, i.e., a new record will be added to the table. But if the value of the primary key (or any unique index field) is already present in the table, the statement behaves like a replace into, meaning that the original record will be deleted and then replaced with a new record. A data cache statement refers to a data operation statement generated from a database table structure and an identifier for updating or querying a particular record.
Specifically, the actual arrangement order of the various table fields in the initial hot update data table needs to be acquired first. This is because each record in the database table is stored in a particular column order, which must be followed when constructing SQL statements. And then, according to the field arrangement sequence, the SQL sentence placeholders corresponding to each table field are spliced together in sequence to form an initial sentence which does not contain an actual value. For example, if the table has fields id, name, and age, then a similar "? What is? What is? "such placeholder sequences". Finally, since the "initial statement" generated at this stage is a partially completed SQL clause, it only specifies which fields to manipulate and the order in which these fields are queried or updated. It is necessary to add identifier information to the header of the "initial statement" in order to be able to locate a specific record accurately. An identifier generally refers to a key field of a primary key or other uniquely identifying record. For example, if the primary key is an id, then operations on the id will be stitched before the SQL statement, thus generating a complete data cache statement, which may be, for example, for an update operation: "UPDATE table_name SET initial sentence WHERE id=? ".
Because SQL statements can be automatically generated according to the actual order and content of the table fields, when changes to the database table structure occur (e.g., fields are added, deleted or modified), the system can automatically adapt to these changes without manually modifying the SQL code. And the code logic is simplified, the database table structure is decoupled from the business logic, so that the change of the database layer can not directly influence the business layer code, and the maintainability and expansibility of the system are improved. Finally, the SQL sentence is constructed in a mode of using the placeholder, so that SQL injection attack is prevented. This reduces the risk of malicious users tampering with the SQL statement using vulnerabilities because the actual value is bound at runtime rather than written directly into the SQL string.
In one embodiment, creating a data filling template sentence corresponding to each sentence placeholder; matching the data filling template sentences with the data to be cached according to the arrangement sequence of the sentence placeholders in the data caching sentences to obtain the data to be cached, which are matched with each data filling template sentence; and filling the data to be cached into the table field corresponding to the matched data filling template statement to obtain the target hot update data table.
The data filling template statement refers to a pre-constructed SQL clause structure used for receiving and storing data to be cached. This template contains placeholders, which are locations to wait for the actual data to fill. The target hot update data table refers to the latest and effective data table under the target hot update version for the target application program, which is obtained after the data to be cached is written into the initial hot update data table by executing the data cache statement. This data table contains data content updated in accordance with the most recent hot update operation.
Specifically, first, according to a predefined SQL sentence structure (i.e. a data cache sentence), a corresponding data filling template sentence is constructed for each placeholder. For example, for an SQL statement of INSERT or UPDATE operation, the template might be INSERT INTO table _name (column 1, column 2) VALUES (? Is a placeholder. And secondly, matching the data to be cached with the templates in a one-to-one correspondence manner according to the arrangement sequence of the placeholders in the data caching statement. That is, the data to be cached corresponding to each placeholder is allocated to the corresponding template position. And then inserting the data filling value to be cached into the table field position corresponding to the matched data filling template statement. For example,? "placeholders". And then executing the filled actual SQL statement, and writing the data to be cached into the initial hot update data table. Finally, after the latest data to be cached is successfully written into the database by executing the steps, the initial hot update data table obtains the latest data content of the corresponding version, thereby forming the target hot update data table aiming at the target application program under the target hot update version. The new version of the data table reflects all valid data required by the current application state, and ensures that the application program can perform normal operation and service provision based on the data updated in real time.
Because template sentences are filled through the data of the placeholders, actual SQL execution sentences can be flexibly generated according to different data to be cached, and fixed SQL codes do not need to be written for each data combination. And ensure that the data used by the target application program under the target hot update version is up-to-date and consistent, and avoid business logic errors or user experience degradation caused by untimely data update.
In one embodiment, intercepting a server data query request, and determining a dynamic query condition according to a request parameter carried by the server data query request; generating a data query statement according to the dynamic query condition, and generating a local data query request according to the data query statement; based on the local data query request, the data is looked up from the local cache.
Specifically, the application also supports dynamic query, and specifically comprises the following steps: the first step is to create an interceptor: an interceptor is created to intercept the request before sending the server request. The second step is to parse the request parameters: in the interceptor, the request parameters are parsed to obtain conditions or parameters that require dynamic query. The third step is to construct a query statement: and dynamically generating a standard SQL query statement according to the request parameters obtained by analysis and the rules defined in advance. The fourth step is to query the local cache data: the generated query statement is used as an entry to locally send a network request to query the local cache data. The fifth step is to process the query result: if the query is successful and the data is returned, the data is directly returned to the user without sending a server request. If the inquiry fails, continuing to send a server request;
by the steps, the local cache data is queried before the server request is sent, so that query efficiency and development efficiency can be effectively improved.
In one embodiment, as shown in fig. 6, fig. 6 is a flow chart of a thermal update method in another embodiment, which includes the following steps:
Step 602, when triggering a hot update login operation for a target application program, displaying at least one candidate data set identifier; responding to the identification determining operation aiming at least one candidate data set identification to obtain a target data set identification; determining a current grouping environment according to the current login account and the target data set identifier; when the current grouping environment is switched, a version data table corresponding to the current login account and the target data set identifier is displayed; the version data table includes at least one candidate data version; obtaining a target hot update version in response to a version determination operation for at least one candidate data version;
Step 604, determining a local storage space corresponding to the target hot update version, and determining whether the local storage space already stores a configuration file corresponding to the target hot update version; if the configuration script file corresponding to the target hot update version is stored in the local storage space, extracting the configuration script file corresponding to the target hot update version from the local storage space; if the configuration script file corresponding to the target hot update version is not stored in the local storage space, downloading the configuration script file corresponding to the target hot update version from the preset cloud; the configuration file comprises a statement configuration file and an interface information configuration file;
Step 606, determining structured query language encryption information according to the sentence configuration file; acquiring a preset secret key and determining an initialization vector; based on a preset secret key and an initialization vector, decrypting the structured query language encryption information to obtain structured query language decryption information; acquiring filling content used when generating the structured query language encryption information; removing the filling content in the structured query language script decryption information to obtain an operation script;
Step 608, obtaining the data table name of the initial hot update data table, and converting the data table name into an identifier; determining a table field in an initial hot update data table; converting the field name of the table field into a corresponding statement placeholder for each table field; determining an arrangement order of table fields in an initial hot update data table; splicing the sentence placeholders corresponding to each table field according to the arrangement sequence of the table fields in the initial hot update data table to obtain an initial sentence; the identifier is spliced to the head of the initial statement to obtain a data cache statement;
Step 610, creating a data filling template sentence corresponding to each sentence placeholder; matching the data filling template sentences with the data to be cached according to the arrangement sequence of the sentence placeholders in the data caching sentences to obtain the data to be cached, which are matched with each data filling template sentence; filling the data to be cached into a table field corresponding to the matched data filling template statement to obtain a target hot update data table;
Step 612, intercepting the server data query request, and determining a dynamic query condition according to the request parameter carried by the server data query request; generating a data query statement according to the dynamic query condition, and generating a local data query request according to the data query statement; based on the local data query request, the data is looked up from the local cache.
It should be understood that, although the steps in the flowcharts related to the above embodiments are sequentially shown as indicated by arrows, these steps are not necessarily sequentially performed in the order indicated by the arrows. The steps are not strictly limited to the order of execution unless explicitly recited herein, and the steps may be executed in other orders. Moreover, at least some of the steps in the flowcharts described in the above embodiments may include a plurality of steps or a plurality of stages, which are not necessarily performed at the same time, but may be performed at different times, and the order of the steps or stages is not necessarily performed sequentially, but may be performed alternately or alternately with at least some of the other steps or stages.
Based on the same inventive concept, the embodiment of the application also provides a thermal updating device for realizing the thermal updating method. The implementation of the solution provided by the device is similar to the implementation described in the above method, so the specific limitation in one or more embodiments of the thermal updating device provided below may be referred to the limitation of the thermal updating method hereinabove, and will not be repeated here.
In one embodiment, as shown in FIG. 7, there is provided a thermal updating apparatus 700 comprising: a determination module 702, an acquisition module 704, a creation module 706, a generation module 708, and an execution module 710, wherein:
a determining module 702 for determining a target hot update version;
An obtaining module 704, configured to obtain a configuration file corresponding to the target hot update version, where the configuration file includes a statement configuration file and an interface information configuration file;
the creation module 706 is configured to generate an operation script according to the statement configuration file, and create an initial hot update data table of the target application program under the target hot update version according to the operation script;
The generating module 708 is configured to obtain data to be cached according to the interface information configuration file, and generate a data caching statement according to the data to be cached and the statement configuration file;
And the execution module 710 is configured to execute the data cache statement, and write the data to be cached into the initial hot update data table to obtain a target hot update data table of the target application program in the target hot update version.
In one embodiment, the determining module 702 is configured to, when triggering a hot update login operation for a target application, present at least one candidate data set identifier; responding to the identification determining operation aiming at least one candidate data set identification to obtain a target data set identification; determining a current grouping environment according to the current login account and the target data set identifier; when the current grouping environment is switched, a version data table corresponding to the current login account and the target data set identifier is displayed; the version data table includes at least one candidate data version; a target hot-updated version is obtained in response to a version determination operation for at least one candidate data version.
In one embodiment, the obtaining module 704 is configured to determine a local storage space corresponding to the target hot update version, and determine whether the local storage space already stores a configuration file corresponding to the target hot update version; if the configuration script file corresponding to the target hot update version is stored in the local storage space, extracting the configuration script file corresponding to the target hot update version from the local storage space; and if the configuration script file corresponding to the target hot update version is not stored in the local storage space, downloading the configuration script file corresponding to the target hot update version from the preset cloud.
In one embodiment, the creating module 706 is configured to determine the structured query language encryption information according to the sentence configuration file; acquiring a preset secret key and determining an initialization vector; based on a preset secret key and an initialization vector, decrypting the structured query language encryption information to obtain structured query language decryption information; acquiring filling content used when generating the structured query language encryption information; and removing the filling content in the structured query language script decryption information to obtain an operation script.
In one embodiment, a generation module 708 is configured to obtain a data table name of the initial hot update data table and convert the data table name into an identifier; determining a table field in an initial hot update data table; converting the field name of the table field into a corresponding statement placeholder for each table field; and generating a data cache statement according to the identifier and the statement placeholder corresponding to each table field.
In one embodiment, a generation module 708 is configured to determine an order of arrangement of the table fields in the initial hot update data table; splicing the sentence placeholders corresponding to each table field according to the arrangement sequence of the table fields in the initial hot update data table to obtain an initial sentence; splicing the identifier to the head of the initial statement to obtain the data cache statement.
In one embodiment, the execution module 710 is configured to create a data filling template sentence corresponding to each sentence placeholder; matching the data filling template sentences with the data to be cached according to the arrangement sequence of the sentence placeholders in the data caching sentences to obtain the data to be cached, which are matched with each data filling template sentence; and filling the data to be cached into the table field corresponding to the matched data filling template statement to obtain the target hot update data table.
In one embodiment, the thermal updating apparatus 700 further includes a query module 712, configured to intercept a server data query request, and determine a dynamic query condition according to a request parameter carried by the server data query request; generating a data query statement according to the dynamic query condition, and generating a local data query request according to the data query statement; based on the local data query request, the data is looked up from the local cache.
In another embodiment, as shown in fig. 8, fig. 8 is a block diagram of a thermal updating apparatus according to another embodiment, including: a determination module 702, an acquisition module 704, a creation module 706, a generation module 708, and an execution module 710. The thermal updating apparatus 700 further includes a query module 712, where the query module 712 is configured to intercept a server data query request, and determine a dynamic query condition according to a request parameter carried by the server data query request; generating a data query statement according to the dynamic query condition, and generating a local data query request according to the data query statement; based on the local data query request, the data is looked up from the local cache.
The various modules in the above-described thermal updating apparatus may be implemented in whole or in part by software, hardware, and combinations thereof. The above modules may be embedded in hardware or may be independent of a processor in the computer device, or may be stored in software in a memory in the computer device, so that the processor may call and execute operations corresponding to the above modules.
In one embodiment, a computer device is provided, which may be a server, and the internal structure of which may be as shown in fig. 9. The computer device includes a processor, a memory, an Input/Output interface (I/O) and a communication interface. The processor, the memory and the input/output interface are connected through a system bus, and the communication interface is connected to the system bus through the input/output interface. Wherein the processor of the computer device is configured to provide computing and control capabilities. The memory of the computer device includes a non-volatile storage medium and an internal memory. The non-volatile storage medium stores an operating system, computer programs, and a database. The internal memory provides an environment for the operation of the operating system and computer programs in the non-volatile storage media. The database of the computer device is used to store data related to the thermal update. The input/output interface of the computer device is used to exchange information between the processor and the external device. The communication interface of the computer device is used for communicating with an external terminal through a network connection. The computer program is executed by a processor to implement a method of thermal updating.
It will be appreciated by persons skilled in the art that the architecture shown in fig. 9 is merely a block diagram of some of the architecture relevant to the present inventive arrangements and is not limiting as to the computer device to which the present inventive arrangements are applicable, and that a particular computer device may include more or fewer components than shown, or may combine some of the components, or have a different arrangement of components.
In an embodiment, there is also provided a computer device comprising a memory and a processor, the memory having stored therein a computer program, the processor implementing the steps of the method embodiments described above when the computer program is executed.
In one embodiment, a computer-readable storage medium is provided, on which a computer program is stored which, when executed by a processor, carries out the steps of the method embodiments described above.
In an embodiment, a computer program product is provided, comprising a computer program which, when executed by a processor, implements the steps of the method embodiments described above.
It should be noted that, the user information (including but not limited to user equipment information, user personal information, etc.) and the data (including but not limited to data for analysis, stored data, presented data, etc.) related to the present application are information and data authorized by the user or sufficiently authorized by each party, and the collection, use and processing of the related data need to comply with the related laws and regulations and standards of the related country and region.
Those skilled in the art will appreciate that a computer program implementing all or part of the above-described methods of the embodiments may be implemented by means of hardware associated with instructions of the computer program, and may be stored on a non-volatile computer readable storage medium, where the computer program, when executed, may include the steps of the embodiments of the methods described above. Any reference to memory, database, or other medium used in embodiments provided herein may include at least one of non-volatile and volatile memory. The nonvolatile Memory may include Read-Only Memory (ROM), magnetic tape, floppy disk, flash Memory, optical Memory, high density embedded nonvolatile Memory, resistive random access Memory (ReRAM), magneto-resistive random access Memory (Magnetoresistive Random Access Memory, MRAM), ferroelectric Memory (Ferroelectric Random Access Memory, FRAM), phase change Memory (PHASE CHANGE Memory, PCM), graphene Memory, and the like. Volatile memory can include random access memory (Random Access Memory, RAM) or external cache memory, and the like. By way of illustration, and not limitation, RAM can be in various forms such as static random access memory (Static Random Access Memory, SRAM) or dynamic random access memory (Dynamic Random Access Memory, DRAM), etc. The databases referred to in the embodiments provided herein may include at least one of a relational database and a non-relational database. The non-relational database may include, but is not limited to, a blockchain-based distributed database, and the like. Alternatively, in a mobile application scenario, the SQLite database (a lightweight, embedded relational database management system) is used. The processor referred to in the embodiments provided in the present application may be a general-purpose processor, a central processing unit, a graphics processor, a digital signal processor, a programmable logic unit, a data processing logic unit based on quantum computing, or the like, but is not limited thereto.
The technical features of the above embodiments may be arbitrarily combined, and all possible combinations of the technical features in the above embodiments are not described for brevity of description, however, as long as there is no contradiction between the combinations of the technical features, they should be considered as the scope of the description.
The foregoing examples illustrate only a few embodiments of the application, which are described in detail and are not to be construed as limiting the scope of the application. It should be noted that it will be apparent to those skilled in the art that several variations and modifications can be made without departing from the spirit of the application, which are all within the scope of the application. Accordingly, the scope of the application should be assessed as that of the appended claims.
Claims (12)
1. A method of thermal updating, the method comprising:
Determining a target hot update version;
acquiring a configuration file corresponding to the target hot update version, wherein the configuration file comprises a statement configuration file and an interface information configuration file;
generating an operation script according to the statement configuration file, and creating an initial hot update data table of the target application program under the target hot update version according to the operation script;
Obtaining data to be cached according to the interface information configuration file, and generating a data caching statement according to the data to be cached and the statement configuration file;
and executing the data caching statement, and writing the data to be cached into the initial hot update data table to obtain a target hot update data table of the target application program under the target hot update version.
2. The method of claim 1, wherein the determining the target hot update version if a hot update operation for the target application is triggered comprises:
When triggering a hot update login operation for a target application program, displaying at least one candidate data set identifier;
Responding to the identification determining operation aiming at the at least one candidate data set identification to obtain a target data set identification;
determining a current grouping environment according to the current login account and the target data set identifier;
when the current grouping environment is switched, a version data table corresponding to the current login account and the target data set identifier is displayed; the version data table includes at least one candidate data version;
a target hot update version is obtained in response to a version determination operation for the at least one candidate data version.
3. The method of claim 1, wherein the obtaining a configuration file corresponding to the target hot update version comprises:
determining a local storage space corresponding to the target thermal update version, and determining whether the local storage space already stores a configuration file corresponding to the target thermal update version;
If the configuration script file corresponding to the target hot update version is stored in the local storage space, extracting the configuration script file corresponding to the target hot update version from the local storage space;
and if the configuration script file corresponding to the target hot update version is not stored in the local storage space, downloading the configuration script file corresponding to the target hot update version from a preset cloud.
4. The method of claim 1, wherein generating a running script from the statement configuration file comprises:
Determining structured query language encryption information according to the statement configuration file;
acquiring a preset secret key and determining an initialization vector;
Based on the preset key and the initialization vector, decrypting the structured query language encryption information to obtain structured query language decryption information;
Acquiring filling content used when the structured query language encryption information is generated;
and removing the filling content in the structured query language script decryption information to obtain an operation script.
5. The method of claim 1, wherein generating a data cache statement from the data to be cached and the statement configuration file comprises:
acquiring a data table name of the initial hot update data table, and converting the data table name into an identifier;
Determining a table field in the initial hot update data table;
Converting a field name of each table field into a corresponding statement placeholder for each table field;
And generating a data cache statement according to the identifier and the statement placeholders corresponding to each table field.
6. The method of claim 5, wherein generating the data cache statement from the identifier and the respective statement placeholder for each of the table fields comprises:
Determining an arrangement order of the table fields in the initial hot update data table;
splicing the sentence placeholders corresponding to each table field according to the arrangement sequence of the table fields in the initial hot update data table to obtain initial sentences;
And splicing the identifier to the head of the initial statement to obtain a data caching statement.
7. The method of claim 1, wherein the executing the data cache statement to write the data to be cached to the initial hot update data table to obtain a target hot update data table for the target application in the target hot update version comprises:
creating a data filling template sentence corresponding to each sentence placeholder;
matching the data filling template sentences with the data to be cached according to the arrangement sequence of the sentence placeholders in the data caching sentences to obtain the data to be cached, which are matched with each data filling template sentence;
and filling the data to be cached into a table field corresponding to the matched data filling template statement to obtain a target hot update data table.
8. The method of claim 1, wherein the target hot update data table is stored in a local cache, the method further comprising:
Intercepting a server data query request, and determining a dynamic query condition according to a request parameter carried by the server data query request;
generating a data query statement according to the dynamic query condition, and generating a local data query request according to the data query statement;
and searching data from the local cache based on the local data query request.
9. A data table generating apparatus, the apparatus comprising:
a determining module for determining a target hot update version;
The acquisition module is used for acquiring a configuration file corresponding to the target hot update version, wherein the configuration file comprises a statement configuration file and an interface information configuration file;
The creation module is used for generating an operation script according to the statement configuration file and creating an initial hot update data table of the target application program under the target hot update version according to the operation script;
the generation module is used for acquiring data to be cached according to the interface information configuration file and generating a data caching statement according to the data to be cached and the statement configuration file;
And the execution module is used for executing the data caching statement, writing the data to be cached into the initial hot update data table, and obtaining a target hot update data table of the target application program under the target hot update version.
10. A computer device comprising a memory and a processor, the memory storing a computer program, characterized in that the processor implements the steps of the method of any one of claims 1 to 8 when the computer program is executed.
11. A computer readable storage medium, on which a computer program is stored, characterized in that the computer program, when being executed by a processor, implements the steps of the method of any of claims 1 to 8.
12. A computer program product comprising a computer program, characterized in that the computer program, when executed by a processor, implements the steps of the method of any one of claims 1 to 8.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202410283807.4A CN118092972A (en) | 2024-03-12 | 2024-03-12 | Thermal updating method, thermal updating device, computer equipment and storage medium |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202410283807.4A CN118092972A (en) | 2024-03-12 | 2024-03-12 | Thermal updating method, thermal updating device, computer equipment and storage medium |
Publications (1)
| Publication Number | Publication Date |
|---|---|
| CN118092972A true CN118092972A (en) | 2024-05-28 |
Family
ID=91147757
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202410283807.4A Pending CN118092972A (en) | 2024-03-12 | 2024-03-12 | Thermal updating method, thermal updating device, computer equipment and storage medium |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN118092972A (en) |
-
2024
- 2024-03-12 CN CN202410283807.4A patent/CN118092972A/en active Pending
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| US9002868B2 (en) | Systems and methods for secure access of data | |
| US20040083426A1 (en) | System and method for generating pre-populated forms | |
| EP3173951B1 (en) | Integrated framework for secured data provisioning and management | |
| CN112364083A (en) | Data dictionary management method, system and storage medium based on configuration file | |
| US11360966B2 (en) | Information processing system and method of controlling information processing system | |
| US20230144072A1 (en) | Data storage server and client devices for securely storing data | |
| CN112685091A (en) | Service request processing method, device, equipment and medium based on big data | |
| CN112434015A (en) | Data storage method and device, electronic equipment and medium | |
| CN114547204A (en) | Data synchronization method and device, computer equipment and storage medium | |
| CN111831744B (en) | System, method and medium for searching data on DAPP chain | |
| CN113127906A (en) | Unified authority management platform, method and storage medium based on C/S architecture | |
| US11947684B2 (en) | Searching encrypted data | |
| CN116208676A (en) | Data back-source method, device, computer equipment, storage medium and program product | |
| CN118092972A (en) | Thermal updating method, thermal updating device, computer equipment and storage medium | |
| CN115221559A (en) | Data account access authorization method and device | |
| CN110222105B (en) | Data summarization processing method and device | |
| US8719822B2 (en) | Method and system for storing and referencing partial complex resources using object identifiers in a printing system | |
| CN112347794A (en) | Data translation method, device, equipment and computer storage medium | |
| CN112052234A (en) | Service data processing method and device, storage medium and electronic device | |
| CN113313540B (en) | Contract generation method and device, electronic equipment and readable storage medium | |
| CN116628654B (en) | Front-end page authority control method, device, equipment and storage medium | |
| CN117009327B (en) | Data processing method and device, computer equipment and medium | |
| US11899811B2 (en) | Processing data pages under group-level encryption | |
| US20230188324A1 (en) | Initialization vector handling under group-level encryption | |
| CN116595546A (en) | Data encryption method, device, computer equipment and storage medium |
Legal Events
| Date | Code | Title | Description |
|---|---|---|---|
| PB01 | Publication | ||
| PB01 | Publication | ||
| SE01 | Entry into force of request for substantive examination | ||
| SE01 | Entry into force of request for substantive examination |