CN112000739B

CN112000739B - Cell designated insertion method, device, computer equipment and storage medium

Info

Publication number: CN112000739B
Application number: CN202010855558.3A
Authority: CN
Inventors: 胥亮; 贾淋淋; 孙端
Original assignee: Xi'an Huanyu Satellite Tt & C And Data Application Co ltd
Current assignee: Xi'an Huanyu Satellite Tt & C And Data Application Co ltd
Priority date: 2020-08-21
Filing date: 2020-08-21
Publication date: 2024-04-26
Anticipated expiration: 2040-08-21
Also published as: CN112000739A

Abstract

The invention discloses a method, a device, computer equipment and a storage medium for appointed insertion of cells, wherein the method comprises the steps of receiving a cell data insertion request and positioning cells to be operated; detecting whether the data to be inserted of the cell data insertion request exists in a cell set to be operated or not; judging whether the data insertion position of the cell data insertion request is positioned in the boundary of the cell to be operated; inserting the data to be inserted into the cell set to be operated; judging whether the cell set to be operated is associated with a data table or not, if not, terminating the processing; if the association exists, executing the following steps; and when judging that the data to be inserted has row data, inserting the data to be inserted into a designated position in a table associated with the data to be inserted. The table class can append column attributes one by one through the method; when adding multiple columns to the table in batches, the newly added column attributes are simultaneously validated on each row in the table.

Description

Cell designated insertion method, device, computer equipment and storage medium

Technical Field

The present invention relates to the field of memory database caching technologies, and in particular, to a method and apparatus for inserting a cell, a computer device, and a storage medium.

Background

With the rapid development of internet technology, the distributed architecture system is continuously perfected, and higher requirements are put on the response speed of software and the overall performance of the system by users. The cache mechanism is adopted to solve the problems of high concurrent requests and hot spot data storage, and becomes a popular preferred scheme. The caching mechanism stores data in the memory by utilizing the high-speed read-write characteristic of the memory so as to improve the data access speed and reduce the performance loss of the system in the data read-write part.

Redis (Remote Dictionary Server) is a non-relational memory database which uses Key-Value as a data model, is free of source and supports high-performance concurrent reading and writing, can support various data storage structures such as character strings, lists, sets, ordered sets, hash tables and the like, provides a publishing and subscribing message communication mode, and has strong data management capability widely applied to the scenes such as cache, data publishing and subscribing. REDIS hash types are mapping tables of fields and value fields of a string type, whose (key-field-value) structure is similar to that of an object (identifier-attribute name-attribute value), and can be used to store objects that are structurally simple and have no complex relationship query.

REDIS has the advantages of distributed storage of key values, no coupling between data, strong expandability, high searching speed and the like, but the stored data is unstructured and has no coupling, and the data is only of a binary type, so that the REDIS has a very obvious disadvantage. When a developer uses a language associated with a strong type such as C/c++, it is necessary to handle conversion between a programming language associated data type such as integer, floating point, boolean, etc. and REDIS data type, and it is not easy to understand the relevance and cohesiveness of service data. Meanwhile, redis provides a plurality of client commands for performing operations such as adding, deleting, checking and the like on the REDIS server, and provides client APIs of multiple programming languages so as to complete interaction with the Redis database in the software development process. Hiredis is a lightweight C language client function library accessing the Redis database, and basically realizes minimum support for the Redis protocol. Hiredis includes synchronous API and asynchronous API, and the use method of its native interface is flexible. The asynchronous API needs to work with a third party asynchronous event library. For example, libevent is an open source, lightweight, cross-platform, high performance event notification library written in C language, supporting event driven and multiple I/O multiplexing techniques, and is widely used as an underlying network library.

In summary, a great deal of time and effort are required for the software developer to learn the REDIS command and the application method of the client API before using the REDIS, so that the time and labor costs are high, the overall progress of software development is affected to a certain extent, and the complexity of the later maintenance of the software is increased.

For the above reasons, the present inventors have proposed an automatic table data synchronization method, but in the table synchronization method, adding column attributes one by one has a problem that it is difficult to achieve, and a problem that when adding a plurality of columns to a table in batch, the newly added column attributes do not take effect on each row in the table at the same time also occurs.

The information disclosed in this background section is only for enhancement of understanding of the general background of the invention and should not be taken as an acknowledgement or any form of suggestion that this information forms the prior art already known to a person skilled in the art.

For the above reasons, the present inventors propose a method, an apparatus, a computer device, and a storage medium for inserting specification of a cell.

Disclosure of Invention

In order to meet the above requirements, a first object of the present invention is to provide a method for inserting designation of cells.

A second object of the present invention is to provide a cell-designating insertion device.

A third object of the present invention is to provide a computer device.

A fourth object of the present invention is to provide a non-transitory computer readable storage medium.

In order to achieve the above purpose, the present invention adopts the following technical scheme:

in one aspect, an embodiment of the present application provides a method for inserting specification of a cell, including the following steps:

Receiving a cell data insertion request, and positioning a cell to be operated;

Detecting whether the data to be inserted of the cell data insertion request exists in a cell set to be operated or not; if yes, terminating the treatment; if not, executing the following steps;

Judging whether the data insertion position of the cell data insertion request is positioned in the boundary of the cell to be operated, if so, terminating the processing; if the boundary is not crossed, executing the following steps;

inserting the data to be inserted into the cell set to be operated;

Judging whether the cell set to be operated is associated with a data table or not, if not, terminating the processing; if the association exists, executing the following steps;

and when judging that the data to be inserted has row data, inserting the data to be inserted into a designated position in a table associated with the data to be inserted.

In one possible embodiment, the step of receiving the cell data insertion request includes receiving data to be inserted, a data insertion location.

In one possible implementation manner, the step of detecting whether the data to be inserted of the cell data insertion request exists in the cell set to be operated includes determining whether the table to which the cell object to be inserted belongs is the same as the table to which the data to be inserted belongs.

In one possible implementation manner, the step of inserting the data to be inserted into the set of cells to be operated includes obtaining an intelligent pointer of a cell address of the data to be inserted, and adding elements into the set of cells to be operated by using an insertion method of a calling sequence container and an associated container.

In one possible implementation manner, the step of adding elements to the to-be-operated cell set by using the method for inserting the calling sequence container and the associated container includes using the parameter entering cell, the inserting position and the parameter entering cell set to perform the method for inserting the calling sequence container and the associated container.

In another aspect, an embodiment of the present application further provides a device for inserting specification of a cell, including:

the request receiving unit is used for receiving a cell data insertion request and positioning cells to be operated;

a detection repeating unit for detecting whether the data to be inserted of the cell data insertion request exists in a cell set to be operated;

The out-of-range detection unit is used for judging whether the data insertion position of the cell data insertion request is positioned in the boundary of the cell to be operated;

An element adding unit for inserting the data to be inserted into the cell set to be operated;

The association judging unit is used for judging whether the data to be inserted are associated with a data table or not;

And the data inserting unit is used for inserting the data to be inserted into the appointed position in the table associated with the data to be inserted when judging that the data to be inserted has row data.

In a third aspect, an embodiment of the present application further provides a computer device, including a memory, a processor, and a specific insertion program of a cell stored in the memory and capable of running on the processor, where the specific insertion program of the cell implements the specific insertion method of the cell as described in any one of the above when executed by the processor.

In a fourth aspect, an embodiment of the present application proposes a non-transitory computer-readable storage medium, on which a computer program is stored, which when executed by a processor implements a method of specifying an insertion of cells as described in any one of the above.

Compared with the prior art, the application has the beneficial effects that: the appointed inserting method of the cells provided by the embodiment of the application can realize the insertion of appointed cell data at the appointed position of the cell set, and the table class can add column attributes one by the method; when adding multiple columns to the table in batches, the newly added column attributes are simultaneously validated on each row in the table.

The invention is further described below with reference to the drawings and specific embodiments.

Drawings

FIG. 1 is a flowchart of an embodiment of a method for inserting a cell specification according to an embodiment of the present application;

FIG. 2 is a block diagram of a two-dimensional table of a specific application scenario of a method for inserting a cell specification according to an embodiment of the present application;

FIG. 3 is a schematic diagram of attributes and methods defined by the cell class of the table of FIG. 2;

FIG. 4 is a schematic diagram of attributes and methods defined by the cell set class of the table of FIG. 2;

FIG. 5 is a schematic diagram of attributes and methods defined by the data row class of the table of FIG. 2;

FIG. 6 is a schematic diagram of attributes and methods defined by the data line set class of the table of FIG. 2;

FIG. 7 is a schematic diagram of attributes and methods of class definition of the table of FIG. 2;

FIG. 8 is a schematic block diagram of a cell assignment insertion device provided by an embodiment of the present application;

fig. 9 is a schematic block diagram of a computer device according to an embodiment of the present application.

Detailed Description

The following description of the embodiments of the present application will be made clearly and fully with reference to the accompanying drawings, in which it is evident that the embodiments described are some, but not all embodiments of the application. All other embodiments, which can be made by those skilled in the art based on the embodiments of the application without making any inventive effort, are intended to be within the scope of the application.

It should be understood that the terms "comprises" and "comprising," when used in this specification and the appended claims, specify the presence of stated features, integers, steps, operations, elements, and/or components, but do not preclude the presence or addition of one or more other features, integers, steps, operations, elements, components, and/or groups thereof.

It is also to be understood that the terminology used in the description of the application herein is for the purpose of describing particular embodiments only and is not intended to be limiting of the application. As used in this specification and the appended claims, the singular forms "a," "an," and "the" are intended to include the plural forms as well, unless the context clearly indicates otherwise.

It should be further understood that the term "and/or" as used in the present specification and the appended claims refers to any and all possible combinations of one or more of the associated listed items, and includes such combinations.

Referring to fig. 1, fig. 1 is a flowchart of a specific embodiment of a method for inserting a cell specification according to an embodiment of the present application, including the following steps:

step S101, receiving a cell data insertion request, and positioning a cell to be operated;

in particular, in the present embodiment, accuracy in receiving data to be inserted, a data insertion position, and so on is also required for the subsequent operation.

Step S102, detecting whether the data to be inserted of the cell data insertion request exists in a cell set to be operated;

If yes, the method confirms that the data to be inserted exists in the cell to be operated, and the processing is terminated; if not, executing step S103;

Specifically, step S102 further includes determining whether the table to which the cell object to be inserted belongs is the same as the table to which the data to be inserted belongs.

In some embodiments, if the user invokes the method through the object C and enters a to-be-inserted cell object a and an insertion position P, it is required to determine whether the table to which the to-be-inserted cell object a belongs is the same as the table to which the object C belongs. If the same, a is considered to be already in C, and the process ends.

Step S103, judging whether the data insertion position of the cell data insertion request is located in the boundary of the cell to be operated.

As shown in the flow of fig. 1, if the boundary is exceeded, the process is terminated; if not, executing step S104;

step S104, inserting the data to be inserted into the cell set to be operated;

Specifically, to achieve the purpose of this step, an intelligent pointer of the cell address of the data to be inserted needs to be obtained, and elements are added to the data set of the cell to be operated by using the insertion method of the calling sequence container and the associated container.

In order to implement the above operation, the table address to which the table associated with the data to be inserted belongs needs to be assigned to the object of the cell to be operated.

Sequential containers aggregate single type elements into containers, which are then stored and accessed according to location. In the prior art, three types are defined in the standard library: vector (supporting fast random access), list (supporting fast insert, delete), deque (double-ended queue) containers define only a few operations, most of which are provided by the algorithm library. Thus, in this embodiment, a type constraint on the elements within the container is required: 1. element types must support assignment operations; 2. an object of an element type must be replicable.

Specifically, the insert method may be that an element with a value val is created before the element pointed to by the iterator iter, n elements with a value val are inserted before the element pointed to by the iterator iter, elements within the range specified by the iterators b and e are inserted before the element pointed to by the iterator iter, and a given value is inserted before the element pointed to by the iterator iter.

Method for adding new elements by association container (map, multimap):

insert method

(1) Insert (e); where e is a value of the value_type type on the map container. If e.first is not in the map container, a new element of e.second is inserted directly, if the key is already present in the map, the map is kept unchanged, an object of the pair type is returned, which contains two parameters, the first is an iterator of the element whose key is e.first in the map, and the second is a bool type, indicating whether the element was inserted successfully in the map.

(2) Insert (end); where beg and end are iterators marking a range of elements, where the elements must be key-value pairs of the map.value_type type. For all elements of the range, if it does not exist in the key map, it can be inserted into the map. The void type is returned.

In this embodiment, the above insertion manner may be used to insert the data to be inserted into the data set of the cell to be operated in the form of an element, so that the subsequent inserted data is ready.

Step 105, judging whether the data to be inserted is associated with a data table;

If not, terminating the processing; if there is an association, go to step 106

And step S106, when judging that the data to be inserted has row data, inserting the data to be inserted into the appointed positions in all tables associated with the data to be inserted.

In the flow of the present embodiment, the table class can append column attributes one by the method; when a plurality of columns are added to the table in batches, the newly added column attributes take effect on each row in the table at the same time.

The following describes a specific implementation procedure of an embodiment of the present invention with a specific example:

Referring to fig. 2-7, fig. 2 is a block diagram of a two-dimensional table in a specific application scenario according to an embodiment of the present application, fig. 3 is an attribute and a method defined by a cell class of the table of fig. 2 in this example, fig. 4 is an attribute and a method defined by a cell set class of the table of fig. 2 in this example, fig. 5 is an attribute and a method defined by a data line class of the table of fig. 2 in this example, fig. 6 is an attribute and a method defined by a data line set class of the table of fig. 2 in this example, and fig. 7 is an attribute and a method defined by a two-dimensional table class in this example.

The purpose of the embodiment is to realize a thread-safe distributed virtual two-dimensional form based on REDIS, namely, the specific application scenario of the form data automatic synchronization method provided by the embodiment of the application aims to enable a developer not to learn REDIS related technologies, not to care about data storage details and bottom layer realization, not to define field names and formats for data to be stored in advance, and only can access the REDIS database through row and column operation of the form, thereby solving the problems of high REDIS learning and use cost, no data coupling and difficult understanding.

In addition, the present application mainly aims to solve the problem that in the above-mentioned table synchronization method, adding column attributes one by one is difficult to achieve, and when adding a plurality of columns to a table in batches, the newly added column attributes do not take effect simultaneously on each row in the table.

The cells and rows provided in this example describe a two-dimensional tabular model, organizing data in rows and columns, and are logically more convenient for users to understand. The form is internally provided with a plurality of interfaces for users to use by realizing the integral function in cooperation with a plurality of classes. The functions provided by the table include creating the table, designing the table fields and indexes, adding in batches, modifying, deleting, querying row data, obtaining the number of rows and columns of the table, emptying the table, registering change notification callbacks, and the like.

In order to realize the table function, the technical scheme adopted by the embodiment comprises three modules, namely table definition, asynchronous subscription and REDIS operation. The table definition module comprises a cell class, a cell set class, a data row set class and a two-dimensional table class definition. The asynchronous subscription module uses Hiredis and Libevent open source software to connect REDIS service end in an asynchronous mode, executes SUBSCRIBE command subscription to channel data named by table name, starts event thread to asynchronously receive subscription response data, and timely informs outer layer users. The REDIS operation module comprises REDIS command class, synchronous client class and response analysis class definition, wherein the command class stores all parameters of one REDIS command; the response analysis class is responsible for completing the conversion from REDIS server side response to self-defined response structure; the sync client class uses Hiredis to connect to the REDIS server in a synchronized manner, execute multiple commands in a pipelined manner, and return REDIS response parameters.

In this example, a REDIS-based implementation scheme for automatically synchronizing data tables is provided, where the scheme uses the C++ language to design related classes and encapsulates a series of interfaces that are available for external use.

The scheme also comprises design and encapsulation of REDIS command class, REDIS synchronous client class, REDIS response analysis class, REDIS asynchronous subscription class, cell collection class, data row class, row collection class, table class and the like.

The REDIS server is deployed as a master-slave environment in a single-machine mode, and REDIS synchronous client class encapsulates an interface for interaction between a synchronous mode and the REDIS server. The REDIS asynchronous subscription class realizes the connection of the REDIS server in an asynchronous mode, takes the name of the table as a channel name, executes the change notification of the REDIS subscription command subscription table, and notifies the table update data after receiving the change message.

Each row record of the created table may be mapped to a key value pair in the REDIS database whose value type is a hash table. The mapping relationship is explained as follows: assuming that a table instance dt_person storing personal information is named Person, three columns of Name, age, city are defined in the table, and information of two persons a and B, i.e., { a,10, sienna }, { B,18, guangzhou }, are stored, the two information will be stored in the hash table of the REDIS database through the HMSET command of REDIS. The command corresponding to the user A is: HMSET Person:1Name A Age 10City Xiyan. Wherein the number 1 in the key Person 1 represents the row number of the record in the Person table. The mapping mode of the user B is the same as that of the user A.

The invention will be described in detail below with reference to the drawings and the detailed description.

REDIS command class is named RedisCommand, which saves all elements of a REDIS command in a dynamic string array, including command name, key name, and its parameters. RedisCommand uses template function technology to realize the function of converting non-character string types such as numerical value, boolean, etc. into character string types, defines dynamically adding parameters into REDIS command through reload < < and () operators, and returns to the interface of new RedisCommand instance, through which user can dynamically splice REDIS command parameters in an additional mode.

The REDIS synchronous client class is named RedisHA, the REDIS server is connected in a synchronous mode, a series of REDIS commands are executed on the REDIS server in a pipeline mode, and the execution result returned by the REDIS server is analyzed.

The REDIS response parsing class is responsible for uniformly converting the response message (REDISREPLY) returned by Hiredis open source software into a custom response structure. The custom response structure is named REDISREPLY and contains a dynamic array of data types, integer values, string values, and REDISREPLY types. The data types correspond to 6 return types of character strings, arrays, integer, null, state and failure defined by REDIS protocol. When the response data type is integer, storing the value in an integer value attribute of REDISREPLY types; when the response data type is character string, state or failure, storing the value in the character string value attribute of REDISREPLY types; when the response data type is an array, its values are stored in the dynamic array attribute of the REDISREPLY class, and the values of the array element REDISREPLY type are stored as per the rules described above.

REDIS asynchronous subscription class is named RedisSubscriber, and defined core data members include a Libevent event object, hiredis asynchronous object, an initialization notification callback, and a message notification callback. The subscription class initialization process needs to be completed as follows: firstly, an REDIS server is connected in an asynchronous mode to acquire Hiredis an asynchronous object, connection and disconnection callbacks are set, a Libevent event object instance is created and bound to the asynchronous object, and REDIS asynchronous callback and event association are achieved; secondly, the user needs to register an initialization notification callback and a message notification callback to the subscription class; thirdly, starting independent thread to start event distribution processing; fourthly, the table name is taken as a channel name, the REDIS SUBSCRIBE command SUBSCRIBEs to the change notification of the table, and the command feedback callback is registered. And the command feedback callback is used for differentially processing the SUBSCRIBE command execution result and the subscription message. And after receiving the subscription information, calling the change callback registered by the outer layer user to notify the outer layer of the change data.

The cell class is named DataCell, abbreviated as DC in this document. The cells are basic data units in a two-dimensional table, and have attributes such as cell names (string types), stored values (string types), change flags (boolean types), and tables where the cells are located (weak_ptr types).

The interfaces provided by the cell classes are shown in table 1.

Table 1 cell class interface table

The DCI_3 is a DC class assignment operator reload interface, and the interface resets the internal data of the current object according to the parametering object. For a unique pointer data member within a DC class, i.e., the table to which it belongs, the assignment operation simply resets its value.

DCI_4 is a DC class copy construction function, and the interface directly calls the DCI_3 interface to realize the function.

DCI_8 is an interface for acquiring cell values of the DC class, and the interface uses a function template of C++ language and a reloading technology to realize the conversion of character string values stored in cells into various basic data types, so that a user can acquire values according to actual required types.

DCI_9 is an interface for setting cell values of a DC class, and the interface uses function templates, reloads and character streaming technologies to uniformly convert a plurality of different input parameter types into character string types for storage in order to support a plurality of C++ language basic data types input by a user.

Dci_14 is a comparison function interface of a cell class encapsulation, the function defining two arguments, argument 1 being a string type, for storing relational operators such as: ">", "> =", "<", "<=", |! = "," like "," betwen "," in "; the argument 2 is a string array type for storing relational operator parameters. The method calls a relationship operator interface of the internal reload of the DC class, and compares the relationship between the stored values in the two cells.

The cell collection class is named DataCellCollection, abbreviated DCC in this document. A set of cells consisting of a plurality of cells, the set being logically equivalent to a row or a column; the order of use and associated container within the DCC class stores a plurality of cell addresses (shared_ptr < DataCell >). The intelligent pointer is used for conveniently managing the dynamic memory and avoiding memory leakage. Storage in a sequential container may facilitate indexing cells with subscripts; the storage in the association container can establish a mapping relation between the column names and the cells, so that the cells can be conveniently searched according to the column names.

The interfaces provided by the cell collection class are shown in table 2.

Table 2 cell set class interface table

The DCCI_3 is a heavy load interface of a DCC class assignment operator, the DCCI_4 is a copy construction function interface of the DCC class, the two interfaces define a copy control mechanism of the DC class, and the class object copy process is required to construct completely independent copies, namely, a deep copy mode is required to be adopted for cell object pointers stored in the class.

Dcci_7 is an interface defined by DCC class that obtains its location index from the cell name. The position index of a cell within a collection is defined as the subscript of the cell object in the sequential container.

The dcci_8 interface detects whether a named cell exists within the set of cells.

Dcci_9 is a first add operation interface defined by DCC class, which mainly implements the function of inserting a specified cell in a specified position of a current object, that is, another embodiment of the specified cell inserting method according to the embodiment of the present application.

In this embodiment, the default parameter identification is only incremented on the current row. Assuming that the user invokes the dcci_9 interface through the DCC class object C, a DC object address a and an insertion position P are input, and the detailed processing procedure of the dcci_9 interface is as follows:

Step 1, judging whether the table of the cell object A to be inserted is the same as the table of the set C to be inserted. If the same, a is considered to be already in C, and the process ends.

And 2, judging whether the insertion position P is out of range. If the boundary is exceeded, the process is terminated.

And 3, assigning the table address of the table associated with the C object to the A object. And acquiring the shared_ptr intelligent pointer of the C object. The dcci_10 interface is invoked.

And step 4, judging whether the C object is associated with the data table. If not, the process is terminated.

And 5, judging whether the data in the C object association data table exists or not. If not, the process is terminated.

And 6, inserting the reference cell object A in the appointed positions of all rows of the C object association table.

Dcci_10 is a second type of add operation interface defined by DCC class, which mainly implements a function of inserting a specified cell at a specified location of a specified cell collection object. The default parameter entering unit lattice, the inserting position and the parameter of the parameter entering unit lattice set of the interface are legal, and the parameter entering unit lattice object is added into the parameter entering unit lattice set by directly calling the insert method of the sequence container and the associated container.

The technical effects obtained by the method for inserting the cell specification provided in this embodiment are: firstly, the table class can add column attributes one by one through the method; secondly, when a plurality of columns are added to the table in batches, the newly added column attribute takes effect on each row in the table at the same time.

Dcci_11 is a third add operation interface defined by DCC class, which appends cells to the set, i.e., inserts at the end position.

Dcci_12 is a fourth add operation interface defined by DCC class, and a designated name cell is added to the set, and the interface firstly constructs a cell object according to the name of the participating cell, and then invokes dcci_11 interface;

Dcci_13 is the first delete operation interface defined by the DCC class that deletes a cell of a specified name in the collection. For example: the user calls the DCCI_13 interface through the DCC class object C, a cell name N is transmitted, the DCCI_13 interface firstly acquires a cell index from the container according to the cell name N, and then calls the DCCI_14 interface;

DCCI 14 is a second delete operation interface defined by DCC class that deletes cells in a set that specify an index. For example: the user calls the DCCI-14 interface through the DCC object C, a cell position index P is transmitted, the DCCI-14 interface judges whether the parameter entering index P is out of range, if so, the processing is terminated; cell object pointers ObjPtr are obtained from the order container according to index P. And searching ObjPtr the cell object names pointed by the related containers, and if no corresponding element is found in the related containers, deleting the pointed index element from the sequential containers. If found in the association container, it is also deleted from the association container. If the C object has associated a table, each row of the associated table invokes the DCCI_15 interface.

DCCI 15 is an internal delete operation interface defined by DCC class that deletes cells of a specified index in a specified set.

Dcci_16 is a third delete operation interface defined by DCC class that deletes a cell object in the current set that is named with the entry reference. For example: the user calls the DCCI_16 interface through the DCC class object C, a cell object Obj is transmitted in, the DCCI_16 interface obtains a cell name N through the cell object Obj, and then calls the DCCI_13 interface;

DCCI 17 is a copy interface of DCC class definitions that enables copying of the cell from which the current set designation index begins into the reference designated set. The user calls the DCCI_17 interface through the DCC class object C, and transmits a starting position S and a cell set M, and the DCCI_17 interface firstly checks whether the starting position S is legal in the object C; if not, the process is terminated. Object M loops to call dcci_9 interface to append cell object copies in the C set sequentially at the end.

Dcci_18 is an interface provided by the DCC class to obtain a copy of a cell object based on a cell name.

DCCI 19 is an interface provided by DCC class to obtain a copy of a cell object from a cell index.

The data line class is named DataRow, abbreviated DR in this document. The data line class describes the attributes and methods that a single line should possess. A single row should have at least one set of cells and two attributes of the table.

The interfaces provided by the row classes are shown in table 3.

Table 3 data line class interface table

/>

DRI_2 is a DR class assignment operator reload interface, DRI_3 is a DR class copy constructor interface, the two interfaces define a replication control mechanism of the DR class, and the class object replication process is required to construct completely independent replicas, namely, cell object pointers stored in the class must adopt a deep copy mode.

DRI_5 is the first search cell interface provided by the DR class, which is searched from within the row according to the cell name, and the interface internally calls the DCCI_18 interface of the cell collection class directly.

DRI_6 is a second type of search cell interface provided by the DR class, which is searched from within the row based on cell location, with the interface internal directly invoking the DCCI_19 interface of the cell collection class.

DRI_7 is the interface provided by the DR class to acquire the in-row cell collection object.

DRI_8 is an interface for the DR class to obtain a row number, and each row object in the table has a unique row number in the table, i.e., the row number is equivalent to the table primary key.

DRI_9 is the interface for DR class setup row object identification.

DRI_10 is the interface for DR class to obtain the line primary key value, the primary key of the line object is "Table name: line number".

DRI_11 is the interface provided by the DR class to obtain all field names in the row.

DRI_12 is an interface provided by the DR class to obtain all field names and values in the line, and F1-V1-F2-V2 … are sequentially stored in the returned dynamic array.

The class of data line sets is named DataRowCollection, abbreviated DRC in this document. DRC class describes the properties and methods that a plurality of rows should possess. The row set class has a plurality of rows of element sets and a table attribute; a plurality of line object pointers (shared_ptr < DR >) are managed through a doubly linked list container, a line set index table is managed through a secondary hash table, a primary hash table uses column names as keys, a value field is also a hash table, and the secondary hash table uses column unit lattice object storage values as keys, and the value field is a line object pointer.

The interfaces provided by the line set class are shown in table 4.

Table 4 data line set class interface table

/>

The row set class needs to support setting a plurality of index fields simultaneously, and in order to realize the function, the index table adopts a two-stage hash table structure, the primary hash table takes a column name as a key, and the secondary hash table as a value. The secondary hash table uses column values as keys and row class examples to which the column values belong as values. DRCI _7 is an interface for setting an index of the DRC class, and when the row set class sets the index, if the number of rows of the table to which the index belongs is 0, only the mapping relationship between the column name and the empty secondary hash table needs to be added to the primary hash table. If the table row is not 0, a secondary hash table is also constructed according to each row of data in the table.

DRCI _9 is an interface provided by the DRC class to add a single row. And adding a new row in the row set, and if the table is provided with an index, synchronously updating the index table. The specific treatment process comprises the following steps: traversing an index table, and acquiring a cell object corresponding to an index column name from the row object to be added; acquiring a storage value from the cell object, and searching whether the storage value exists in an index list value corresponding to the current list name; if the new line exists, namely the index field value conflicts, the new line addition fails. If the new column value does not exist, the corresponding relation between the new column value and the new row is inserted into the index table corresponding to the current column name. And finally, inserting a new row into the row set container.

DRCI _10 is the first interface provided by the DRC class to delete a single line. When deleting a row object from the row set, if the table has an index set, the index table also needs to be updated. The specific treatment process comprises the following steps: checking whether an index column exists in the row object to be deleted; if the mapping relation exists, deleting the mapping relation between the corresponding column value and the row object from the index table; if not, searching the appointed row object from the row set container and deleting the appointed row object;

DRCI _11 is a delete line interface provided by the line set class based on the index field name and value.

DRCI _12 is a way that the row set class provides for retrieving rows according to location. The detailed processing process is as follows: checking whether the index of the incoming position crosses the boundary, if so, terminating the processing; otherwise, the incoming position index is corresponding to the relative position of the row object in the row set list, and the row object at the specified position is returned.

DRCI _13 is the interface provided by the row set class to obtain row objects from row identification.

DRCI _14 is the interface provided by the row set class to obtain row objects based on index field names and values.

DRCI _15 is an interface to update row data provided by the row set class.

DRCI _16 is an interface provided by the rowset class to find a rowset that satisfies the user specified criteria.

DRCI _17 is the interface for the row-by-row traversal provided by the row-set class.

DRCI _18 is a row presence interface provided by the row set class that determines the presence of a row based on the row identification.

The table class describes a two-dimensional table model comprising rows and columns for temporarily storing virtual table data in memory, where the rows and columns are each defined as a set of cells. A two-dimensional table is made up of multiple rows and columns. The rows are represented by a row set, which contains a plurality of row instances, each row instance contains a cell set instance, one cell set instance contains a plurality of cell instances, and each cell instance stores a valid name and value. The columns are represented by a set of cells, the set of column cells containing a plurality of cell instances, each cell instance having a valid name and not storing a meaningful value. The table also has attributes such as name, number, subscription sub-object, and REDIS client terminal object.

The table class, designated DataTable, abbreviated DT in this document, can be created and used independently. The interfaces provided by the table classes are shown in table 5.

Table 5 table class interface table

/>

Dti_3 is a static method provided by the DT class to create a table instance, the internal process flow of which is shown on the right side of fig. 7. The user transmits parameters such as REDIS server IP, port, password, form name, database index and subscription flag to the interface. The REDIS server IP is an IP address for deploying REDIS service, the port is a REDIS service monitoring port, and the password is an authentication password when the REDIS client is connected with the REDIS server. The subscription flag indicates whether to turn on the subscription form data change function, and is turned on when the value is true, and turned off when the value is false. If the caller does not transmit the database index and the subscription flag parameter to the interface, the interface uses a default value, wherein the database index default value is 0, namely, default table data is stored in a No. 0 database of the REDIS server; the subscription flag default value is true, i.e., the form instance defaults to turn on the subscription data change function.

The static method first dynamically builds a table instance on the heap, storing the instance address in the intelligent pointer. After the table is instantiated, the internal data including row set, column set, REDIS client instance and subscription instance are initialized. The initially created table has no structure, i.e. no column names are set, nor are any row data stored. Therefore, initializing a row set requires dynamic creation of a null DRC instance, initializing a column name set requires dynamic creation of a null DCC instance. In order that the form instance can be used as a bridge between a user and the REDIS database, the REDIS client terminal object needs to be initialized when the form is initially created, so that the connection establishment between the REDIS client terminal object and the REDIS server terminal is ensured to be normal. In order to timely sense the change of the table data, after the table instance is created, a subscription sub-object is initialized, so that the asynchronous connection between the subscription sub-object and REDIS server is ensured to be established normally, simultaneously, a REDIS SUBSCRIBE command is successfully executed, an asynchronous event processing thread is started normally, and all messages on a channel named by the table name are subscribed. After the table object is successfully created and all initializations are completed, the static method returns the table instance address to the user. The user can obtain the table instance address, i.e., a shared_ptr < DT > type variable. Examples of static method calls are as follows:

shared_ptr<DT>PTR＝DT::CreateDataTable(“192.168.1.1”,6973,“123456”,“TestTbl”,true,1)；

Dti_5 is the interface for the DT class set table column field name. After the user obtains the table instance address, if a brand new data table is required to be designed, the column name of the data stored in the interface setting table can be called through the table instance address according to the application scene. For example, set 3 column names as F1, F2, and F3, respectively, then call is performed: vector < string > heads= { "F1", "F2", "F3" }; PTR- > SetHead (heads); the interface traverses the input column name array, sequentially takes out each element, calls the input parameters of the DCC class DCCI_12 interface as a table column cell set object, and circularly increases the cells with specified names.

Dti_6 is the interface for the DT class to set the table index field, the index is an optional setting item, allowing the table to be index-free. The user can create the index for the table instance at any time according to the service requirement, allow the index to be created on a plurality of columns, allow the index to be set for a plurality of times, and can select two modes of resetting or adding when setting. The index information before the resetting mode is emptied, and an index table is built again according to the table data; the additional mode can keep the original index information and supplement the index table data according to the newly set index column. Although one table is allowed to set a plurality of index columns, search is allowed only on one column, and multi-column combined search is not supported. The interface of the table class setting index directly calls the line set class setting index interface.

Dti_8 is the DT class setting table name interface.

Dti_9 is the DT class get table name interface. The table name is case-wise and the default value is null.

Dti_10 is the DT class get table number interface. The table number is obtained by adding the static variable of the table class, and the table number is unique in a single process and can be the same among multiple processes.

Dti_11 is the DT class load table full data interface. If the user does not need to set a new table, and only needs to load the existing table data from the REDIS database, the dti_11 interface of the table class is called through the table instance address, and an example is called: auto ret = PTR- > LoadData (); the method for loading table data first needs to execute the REDIS SCAN command through REDIS client terminal object of table class to obtain all keys related to table instance. Assuming that the table name is TestTbl, testTbl table data in the REDIS in-memory database is stored in a hash table with a number of keys TestTbl:n, where N represents a unique row number in the data table, and the meaning of N is equivalent to the primary key of the data table, so that a row of data can be uniquely determined. Therefore, the SCAN command format to be executed is SCAN cursor MATCH TableName, the initial value of the cursor cursor is 0, and each time the command is executed, the cursor searched for next time and the current time search result satisfying the matching mode are returned. When the return cursor is 0, this indicates that the SCAN command completes one complete traversal. All KEYS retrieved during the SCAN traversal are saved to the container, assuming tbl_keys. If the container is not empty, the first element is fetched, assuming TestTbl:1, and the HKEYS command to execute REDIS retrieves all field names in the TestTbl:1 key, i.e., column names of table TestTbl. The dti_8 interface is called to set the table column name. And circularly traversing each key element in the TBL_KEYS, completing the conversion operation from the key value to the row object, and finally calling a table class batch addition data row interface to add all rows created according to the TBL_KEYS into the table. Since the data is already loaded from the REDIS database, the batch addition operation here does not need to synchronize the REDIS database. The data loading method returns the number of rows and columns successfully loaded to the caller.

A REDIS key-to-row object conversion operation is to execute HGETALL commands of REDIS to obtain all fields and values in the key, parse row number RID from the key value in the format of 'table name: row number', create a new row object with row number RID and consistent cell name and table column cell in the row, and fill all fields and values in the key into cells in the new row object.

Dti_12 is the DT class get table rank interface.

Dti_13 is a DT class empty table row data interface.

Dti_15 is the DT class get table new line number interface. Each table specifies a globally unique row number identifier name. For example, a table instance may be named TableNameA and a row number identifier of the table may be defined as TableNameA _seq. The method of generating the new line number requires that the line number identifier name is entered first, and then the INCR command of REDIS is executed to increment KEY by 1 the value stored in TableNameA _SEQ. The REDIS mechanism ensures that if the specified KEY does not exist in the REDIS database, the value of the specified KEY is initialized to 0, the INCR operation is performed, the KEY is stored in the REDIS database, and the result after the INCR operation is performed is returned to the client. The single-wire Cheng Chuanhang processing mechanism of REDIS ensures that no data race problem occurs when new line numbers of the same table are generated concurrently in a multi-threaded environment.

Dti_16 is the DT class create table new row object interface. The new line object creating method includes creating one empty new line object dynamically on the pile, copying list cell set of the new line object to the new line object, setting the data table associated with the new line object as the current line object, and returning the new line object address to the user for setting line data.

Dti_17 is the DT class batch add-on interface.

Dti_18 is the DT class bulk delete line interface.

Dti_19 is the DT class batch modify line interface. Batch operations are executed in a transactional manner, with success being all successful and failure being all failed. When the batch is added, deleted or modified, the table data is firstly locked, then the data backup is carried out, and the backup is used for backing up the table data when part of the row operation fails. And after the backup is finished, calling the addition, deletion or modification of the row set class definition to circularly process the incoming rows of the single row interface. After all the rows are successfully processed, the table data is unlocked first, and then whether REDIS databases are synchronously updated is selected according to service requirements.

The REDIS database updating method needs to be transmitted with batch line data to be updated and operation identifiers, and the operation identifiers can be set to be added, deleted or modified. According to the method, each line of data is firstly analyzed into a subscription and release data structure, and then the subscription and release structure is converted into REDIS commands according to operation identifiers. If the operation is identified as an add or modify, the data is converted to a HMSET KEY F V1[ F2V 2 … ] command to REDIS. If the operation is identified as delete, the data is converted to REDIS's HDEL KEY F1[ F2 … ] command. The KEY in the command is "table name: row number", and Fn and Vn correspond to the name and value of each cell in the row. All lines to be operated are converted into REDIS commands according to rules, then the whole publishing and subscribing structure is serialized, and a PUBLISH CHANNEL MESSAGE command is added to a REDIS command set to be executed, wherein CHANNEL is a table name, and MESSAGE is serialized publishing and subscribing data. Executing all REDIS commands in a channel mode, analyzing the execution result, and returning success or failure to the caller according to the command execution result.

The publish-subscribe data structure is defined as a composite type that includes an operation identifier, a database index, a table name, a table number, and change line data. The row data comprises a row number and a row attribute set; the line attribute data includes an attribute name and an attribute value. The table instance of the publish-subscribe composite structure is serialized into a JSON string, and the table instance of the subscribe-change notification is inversely serialized into a composite structure.

Dti_20 is the DT class data polling interface. The row query method allows a user to input a custom query function object, custom row query conditions are defined in the function object, and a query function object interface is defined as a bool (DR &). The line inquiry method circularly traverses all lines in the table, takes each line as an input parameter of an inquiry function object, executes an inquiry function and judges whether the input line meets the inquiry condition according to the return value. If so, a copy of the incoming row is placed into the query result set. And finally, returning the query result set to the caller.

Dti_21 is the DT class batch add-on interface.

Dti_22 is the DT class bulk delete column interface. And circularly calling interfaces of the cells in the cell set in the batch adding or deleting method of the table, wherein the list cell set of the table stores the table address, and if the rows exist in the table when the cells are added or deleted, the cells are added or deleted in the cell set corresponding to each row.

Dti_23 is a row-by-row traversal interface provided by the DT class.

Dti_24 is the DT class registration line add notification callback interface.

Dti_25 is the DT class registration line delete notification callback interface.

Dti_26 is the DT class registration line modification notification callback interface. In order to realize the automatic synchronization function of the form data, the form needs to realize a data change callback method. When the asynchronous event processing thread subscribing the sub-objects in the form receives the change message, the data change callback registered by the form class is called. The change callback of the form class can synchronously update the self memory data according to the operation identification in the subscription message body. The user can selectively register the callback interface of the table data to add, modify or delete the change callback interface, and when the table updates the object memory data due to receiving the subscription change message, the callback interface registered by the user is called, and the user can customize the processing logic of the change data in the callback interface.

Dti_27 is a DT class registration subscription notification callback interface. The table class is an upper layer user of the subscription class, and has to register a subscription notification callback with the subscription class in order to receive the table data change notification message in time. After receiving the data change notification, the form class firstly deserializes the received JSON character string into a composite structure, and then performs addition, deletion or modification processing according to the operation identifier. When the number of the line in the change data is increased, the existence of the line number in the table instance memory is checked, and if the line number does not exist, the change data is increased. Otherwise, the processing is ignored. When modifying and deleting, if the line number exists in the table instance memory, updating or deleting the corresponding line data, otherwise, ignoring the processing. The form data change which is passively received and triggered is not synchronized to the REDIS database, and the form instance which actively issues the change completes the REDIS database data change.

Dti_28 is a DT class check form presence interface. The user can check the REDIS database for the presence of any form data by way of the form instance. For example, by TestTbl table instance detecting whether TESTCHECK table already exists, PTR- > TableExist ("TESTCHECK") can be performed; if the entry list name is not specified, the existence of the list instance itself is checked by default, i.e., PTR- > TableExist () is equivalent to PTR- > TableExist ("TestTbl").

Dti_29 is the DT class interfaces to the search line according to the index field name value pair. The use of an index table search row allows searching on only one column, and does not support multi-column combined searching.

Fig. 8 is a schematic block diagram of a cell assignment insertion device according to an embodiment of the present invention. As shown in fig. 8, the present invention also provides a specific insertion device for a cell, corresponding to the above specific insertion method for a cell. The cell specification insertion device comprises a unit for executing the cell specification insertion method, and can be configured in a desktop computer, a tablet computer, a portable computer, and the like. Specifically, referring to fig. 8, the cell assignment insertion apparatus 200 includes:

a request receiving unit 201, configured to receive a cell data insertion request, and locate a cell to be operated;

A detecting repeating unit 202, configured to detect whether the data to be inserted of the cell data insertion request exists in the cell set to be operated;

A border crossing detection unit 203, configured to determine whether a data insertion position of the cell data insertion request is located within a border of the cell to be operated;

An element adding unit 204, configured to insert the data to be inserted into the set of cells to be operated; an association judging unit 205, configured to judge whether the data to be inserted is associated with a data table, and if not, associate the data with the data table;

And a data insertion unit 206, configured to insert the data to be inserted in a specified position in the table associated with the data to be inserted when it is determined that the data to be inserted has row data.

It should be noted that, as will be clearly understood by those skilled in the art, the specific implementation process of each unit of the above-mentioned cell designating and inserting device 200 may refer to the corresponding description in the foregoing method embodiment, and for convenience and brevity of description, the description is omitted here.

The above-described cell assignment insertion means 200 may be implemented in the form of a computer program that can be run on a computer device as shown in fig. 9.

With reference to FIG. 9, the computer device 300 includes a processor 302, a memory, and a network interface 305, which are connected by a system bus 301, wherein the memory may include a non-volatile storage medium 303 and an internal memory 304.

The non-volatile storage medium 303 may store an operating system 3031 and a computer program 3032. The computer program 3032 includes program instructions that, when executed, cause the processor 302 to perform a method of cell insertion specification.

The processor 302 is used to provide computing and control capabilities to support the operation of the overall computer device 300.

The internal memory 304 provides an environment for the execution of a computer program 3032 in the non-volatile storage medium 303, which computer program 3032, when executed by the processor 302, causes the processor 302 to perform a cell-specific insertion method.

The network interface 305 is used for network communication with other devices. It will be appreciated by those skilled in the art that the structure shown in FIG. 9 is merely a block diagram of some of the structures associated with the present inventive arrangements and does not constitute a limitation of the computer device 300 to which the present inventive arrangements may be applied, and that a particular computer device 300 may include more or fewer components than shown, or may combine certain components, or may have a different arrangement of components.

The storage medium may be a U-disk, a removable hard disk, a Read-Only Memory (ROM), a magnetic disk, or an optical disk, or other various computer-readable storage media that can store program codes.

Those of ordinary skill in the art will appreciate that the elements and algorithm steps described in connection with the embodiments disclosed herein may be embodied in electronic hardware, in computer software, or in a combination of the two, and that the elements and steps of the examples have been generally described in terms of function in the foregoing description to clearly illustrate the interchangeability of hardware and software. Whether such functionality is implemented as hardware or software depends upon the particular application and design constraints imposed on the solution. Skilled artisans may implement the described functionality in varying ways for each particular application, but such implementation decisions should not be interpreted as causing a departure from the scope of the present invention.

In the several embodiments provided by the present invention, it should be understood that the disclosed apparatus and method may be implemented in other manners. For example, the device embodiments described above are merely illustrative. For example, the division of each unit is only one logic function division, and there may be another division manner in actual implementation. For example, multiple units or components may be combined or may be integrated into another system, or some features may be omitted, or not performed.

The steps in the method of the embodiment of the invention can be sequentially adjusted, combined and deleted according to actual needs. The units in the device of the embodiment of the invention can be combined, divided and deleted according to actual needs. In addition, each functional unit in the embodiments of the present invention may be integrated in one processing unit, or each unit may exist alone physically, or two or more units may be integrated in one unit.

The integrated unit may be stored in a storage medium if implemented in the form of a software functional unit and sold or used as a stand-alone product. Based on such understanding, the technical solution of the present invention is essentially or a part contributing to the prior art, or all or part of the technical solution may be embodied in the form of a software product stored in a storage medium, comprising several instructions for causing a computer device (which may be a personal computer, a terminal, a network device, etc.) to perform all or part of the steps of the method according to the embodiments of the present invention.

While the invention has been described with reference to certain preferred embodiments, it will be understood by those skilled in the art that various changes and substitutions of equivalents may be made and equivalents will be apparent to those skilled in the art without departing from the scope of the invention. Therefore, the protection scope of the invention is subject to the protection scope of the claims.

Claims

1. A method for inserting a cell specification, comprising the steps of:

Receiving a cell data insertion request, and positioning a cell to be operated;

inserting the data to be inserted into the cell set to be operated;

when judging that the data to be inserted has row data, inserting the data to be inserted into a designated position in a table associated with the data to be inserted;

wherein the cells and rows describe a two-dimensional tabular model;

the step of inserting the data to be inserted into the cell set to be operated comprises the steps of obtaining an intelligent pointer of a cell address of the data to be inserted, and adding elements into the cell set to be operated by using an insertion method of a calling sequence container and an associated container.

2. The method of claim 1, wherein the step of receiving a cell data insertion request includes receiving data to be inserted, a data insertion location.

3. The method according to claim 2, wherein the step of detecting whether the data to be inserted of the cell data insertion request exists in the set of cells to be operated includes determining whether a table to which the cell object to be inserted belongs is identical to a table to which the data to be inserted belongs.

4. The method for inserting cells according to claim 1, wherein the step of adding elements to the set of cells to be operated by using the method for inserting calling sequence containers and associated containers includes the step of inserting calling sequence containers and associated containers by using the parameter entry cells, the inserting positions, and the parameter entry cell set.

5. A cell assignment insertion device, comprising:

A data insertion unit, configured to insert the data to be inserted in a specified position in a table associated with the data to be inserted when judging that the data to be inserted has row data;

6. A computer device comprising a memory, a processor, and a specified insertion program of cells stored on the memory and executable on the processor, wherein the specified insertion program of cells when executed by the processor implements the specified insertion method of cells as claimed in any one of claims 1-4.

7. A non-transitory computer readable storage medium having stored thereon a computer program which, when executed by a processor, implements a method of specified insertion of cells as claimed in any one of claims 1 to 4.