Classifications

• • G—PHYSICS
  • G06—COMPUTING OR CALCULATING; COUNTING
  • G06F—ELECTRIC DIGITAL DATA PROCESSING
  • G06F16/00—Information retrieval; Database structures therefor; File system structures therefor
  • G06F16/90—Details of database functions independent of the retrieved data types
  • G06F16/901—Indexing; Data structures therefor; Storage structures
  • G06F16/9017—Indexing; Data structures therefor; Storage structures using directory or table look-up
• • 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
  • Y10—TECHNICAL SUBJECTS COVERED BY FORMER USPC
  • Y10S—TECHNICAL SUBJECTS COVERED BY FORMER USPC CROSS-REFERENCE ART COLLECTIONS [XRACs] AND DIGESTS
  • Y10S707/00—Data processing: database and file management or data structures
  • Y10S707/99931—Database or file accessing
  • Y10S707/99932—Access augmentation or optimizing
• • 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
  • Y10—TECHNICAL SUBJECTS COVERED BY FORMER USPC
  • Y10S—TECHNICAL SUBJECTS COVERED BY FORMER USPC CROSS-REFERENCE ART COLLECTIONS [XRACs] AND DIGESTS
  • Y10S707/00—Data processing: database and file management or data structures
  • Y10S707/99931—Database or file accessing
  • Y10S707/99933—Query processing, i.e. searching
• • 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
  • Y10—TECHNICAL SUBJECTS COVERED BY FORMER USPC
  • Y10S—TECHNICAL SUBJECTS COVERED BY FORMER USPC CROSS-REFERENCE ART COLLECTIONS [XRACs] AND DIGESTS
  • Y10S707/00—Data processing: database and file management or data structures
  • Y10S707/99941—Database schema or data structure
  • Y10S707/99942—Manipulating data structure, e.g. compression, compaction, compilation
• • 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
  • Y10—TECHNICAL SUBJECTS COVERED BY FORMER USPC
  • Y10S—TECHNICAL SUBJECTS COVERED BY FORMER USPC CROSS-REFERENCE ART COLLECTIONS [XRACs] AND DIGESTS
  • Y10S707/00—Data processing: database and file management or data structures
  • Y10S707/99951—File or database maintenance
  • Y10S707/99956—File allocation

Definitions

• the present invention relates to a data processing method and a data processing device for processing a large amount of data using an information processing device such as a computer. More specifically, the present invention relates to updating, deleting, and deleting tabular data constituting a database. For insertion and transaction processing. Background technology
• RDB relational databases
• bitmap index is a bitmap that indicates whether each record satisfies the condition with one bit.For example, if there is an item “sex”, the bitmap of “male” and “ A bitmap of “female” is created. At this time, if you try to retrieve only “female” records (that is, if you search), you can quickly obtain that subset (that is, a set of female records). However, it is not always possible to create a bitmap for each value. For example, in the case of 1 billion records that take 1 billion values (such as ID numbers), 1 billion bits (approximately 125 MB) of bit maps must be created.
• bitmap index can be realized only with items having very few variations (for example, gender). Also, it is clear that this method cannot be applied immediately to subsets, and cannot be used when records are frequently inserted and deleted. Other speedup techniques have some limitations as well. Due to the limitations of the application range of these various high-speed technologies, operations that look exactly the same to the user may be instantaneous termination or may take many hours. Serious difficulty).
• D W H can be considered to be an R D B tuned specifically for search and aggregation performance, excluding the transaction processing function. Therefore, the fundamental constraint of n * l o g (n) processing time remains, and although the performance has been improved, it is not enough, and the problem of its discontinuity has not been solved. In addition, the unavoidable combination of the existing RDB of the core system and the DWH of the information system has significantly increased capital investment, creating new problems such as complicated information management and increased operation costs.
• MDB presumably creates a basic crosstab by combining specified items (called dimensions) and combines the crosstab requested by the user from the basic crosstab. good.
• cross tabulation can be synthesized with a satisfactory response, but there are many problems. For example, it is not possible to return to the original data (unless special measures are taken because it is impossible to return to the original data from the aggregation). (Because a cross tabulation must be created in advance,) There are problems such as the inability to cope with data that is constantly updated or the inability to create cross tabulations of items (dimensions) other than those specified in advance. Of course, the equipment The same problems as DWH have also occurred, such as increased investment, more complicated information management and higher operating costs.
• the linear filter Yuichi method has high processing performance, stability, and uniform processing. It has many highly desirable properties such as data compactness and partitionability, 0 (n) architecture, software serial connection, and suitability for pipeline processing and parallel processing.
• the present invention particularly provides a method for inserting, deleting, and deleting data in tabular data in which the processing of inserting, deleting, and updating data can be performed quickly and appropriately using the linear fill method.
• the purpose is to provide an update method.
• an object of the present invention is to provide a method of inserting, deleting, and updating tabular data capable of appropriately performing the transaction processing. Disclosure of the invention
• An object of the present invention is a tabular data insertion method for inserting an item value at an arbitrary position of tabular data represented as an array of records including an item and an item value included therein.
• a number is accepted as a subscript
• a subscript conversion array configured to give an offset value corresponding to the range of the subscript is generated, an insertion position indicating the position of the item value to be inserted is specified, and the subscript is specified.
• the character conversion array Regarding the insertion position, the range of the corresponding subscript is determined, and an offset value for specifying a predetermined position after the end of the array is given, and the offset value corresponding to the insertion position in the subscript conversion array is given.
• the range of the corresponding subscript is shifted upward, and an offset value for decrementing the received subscript is given.
• the item value to be inserted is arranged, and the subscript is assigned an offset value according to the range of the subscript in the subscript conversion array, and the offset value is arranged according to the subscript given. This is achieved by the tabular data insertion method, wherein the item values in the table are specified.
• a predetermined offset is given to the subscript by the subscript conversion array to specify the item value of the array. Therefore, in the case of insertion, the subscript corresponding to the newly inserted position can specify a new item value arranged at a predetermined position after the end of the array by the subscript conversion array. Therefore, there is no need to actually insert data into the array and move other data, and logically insert item values into the array. In addition, this makes it possible to appropriately perform parallel processing and transaction processing as described below.
• an object of the present invention is a method of deleting tabular data for deleting an item value at an arbitrary position in tabular data represented as an array of records including an item and an item value included in the item.
• Generates a subscript conversion array configured to accept numbers as subscripts and to provide offset values corresponding to the range of subscripts accepted, and to specify the deletion position indicating the position of the item value to be deleted.
• the subscript conversion array for a record having a record number larger than the record number corresponding to the deletion position, the range of the corresponding subscript is shifted downward, and the received subscript is incremented.
• the offset value according to the range of the subscript in the subscript conversion array is given to the subscript.
• the item value corresponding to the position to be deleted is determined by the subscript conversion array. It is configured so that the subscript does not point.
• the process of data deletion is realized logically without actually deleting the data and without moving the data.
• the update method and the deletion method described above may be executed sequentially or in the reverse order.
• a tabular data conversion method for converting the value of an item value of tabular data represented as an array of records including an item and an item value included therein Generates a value conversion array configured to give an offset value corresponding to a range of item values, accepts a record number as a subscript, and converts the item value corresponding to the subscript in the array into: It is configured to give an offset value corresponding to the range of the item value.
• an object of the present invention is to provide a tabular data, which is configured to specify an item value corresponding to an arbitrary record number, in tabular data represented as an array of records including an item and an item value included therein.
• the tabular data is defined as a value list including the first entity array in which the item values are stored in the order of the item value numbers corresponding to the item values belonging to the specific item.
• the data is divided into one or more information blocks including a pointer array including a second entity array storing a boy value for indicating the item value number;
• a first subscript conversion array configured to give a first offset corresponding to a range of the subscript to the input record number as a subscript in the pointer array is provided.
• the pointer value in the second entity array identified by the subscript given the offset through the subscript conversion array as a value, and providing the second offset corresponding to the range of the value.
• a third offset corresponding to the range of the suffix is provided to the value list as a suffix.
• a second subscript conversion array is formed, and the item value in the first entity array is specified by the output of the pointer array that has been given an offset via the second subscript conversion array. This is achieved by the data structure of tabular data, which is characterized in that
• a subscript conversion array or a value conversion array In other processes, it is possible to form a data stream that uses only a physical array. In this way, by setting the passing or non-passing of the conversion array as necessary, it is possible to appropriately realize the parallel processing of the process and the transaction processing.
• each of the subscript conversion arrays is a start position array including a start position indicating a minimum value of the subscript included in the predetermined range, and / or a maximum value of the subscript included in the predetermined range. It is preferable to include an end position array consisting of end positions indicating the following, and an offset array consisting of corresponding offset values. Further, the value conversion array includes a start position array including a start position indicating a minimum value of a value included in a predetermined range, and / or an end position indicating a maximum value of a value included in the predetermined range. And an offset array consisting of the corresponding offset values.
• an object of the present invention is a method of inserting tabular data for inserting an item value at an arbitrary position in the tabular data represented by the data structure defined above,
• An insertion position indicating the position of the item value to be inserted is specified, and in the second subscript conversion array, a corresponding subscript is determined with respect to the insertion position, and a predetermined subscript after the end of the first entity array is determined.
• a third offset value for specifying the position of the subscript is given, and in the second subscript conversion array, the range of the corresponding subscript with respect to a value larger than the value of the subscript corresponding to the insertion position is specified. , The value defining the range is shifted upward so as to increase, and a third offset value for decrementing the accepted subscript is given, and a predetermined position after the end of the first entity array ,
• the item value to be inserted is arranged,
• An insertion position indicating a position of a boyfriend value corresponding to a record number to be inserted is specified, and in the first subscript conversion array, a subscript corresponding to the insertion position is determined, and the first entity is determined.
• a first offset value for specifying a predetermined position after the end of the array is given, and in the first subscript conversion array, the insertion position For records with record numbers higher than the corresponding record number, the corresponding subscript range is shifted upward so that the value defining the range is larger, and the accepted subscript is Providing a first offset value for decrementing; placing a new pointer value greater than the existing pointer value at a predetermined position after the end of the second entity array; and
• the value conversion array is provided with a second offset value that increments the pointer value having a pointer value corresponding to the insertion position in the value list or more, and the new pointer value is included in the value conversion array.
• the present invention is achieved by a data insertion method for tabular data, wherein a second offset value for specifying a position corresponding to the insertion position is given.
• the method comprises m record numbers and n item values, and the insertion position of the item value in the value list is i (0 ⁇ i ⁇ n-1). , The item value is located at the end n of the first entity array, the record number insertion position is j (0 ⁇ j ⁇ m-1), and the pointer value is at the end m of the second entity array.
• the value conversion array of the pointer array when the value range is (i-1), 0 is given as the second offset value, and the value range is i or more and (n-1) or less. In this case, 1 is given as the second offset value, and when the value is n, (i ⁇ n) is given as the second offset value. Or, it has m record numbers and n item values, the insertion position of the item value in the value list is i (0 ⁇ i ⁇ n—1), and the first entity array has The item value is placed at the specified position z (z ⁇ n) after the end, the record number is inserted at j (0 ⁇ j ⁇ m-1), and the specified value after the end of the second entity array If the pointer value is located at the position x (x ⁇ m) of
• the value range is (i-1) or less, 0 is given as the third offset value, and if the value is i, (z--i) is given as the third offset value, and If the value range is not less than (i + 1) and not more than n, (1-1) is given as the third offset value, and
• an object of the present invention is a method of deleting tabular data that deletes an item value at an arbitrary position in a tabular data represented by a data structure based on the above definition. Identifying a deletion position indicating the position of the Boyne evening value to be deleted, determining a corresponding subscript for the deletion in the first subscript conversion array, For those having a record number higher than the record number corresponding to the deletion position, the corresponding subscript range is shifted downward so that the value defining the range becomes smaller, and the received subscript is This is achieved by a method for deleting tabular data, characterized by providing a first offset value for incrementing the data.
• the pointer array includes m record numbers and n item values, and when the deletion position of the record number is j (0 ⁇ j ⁇ m-1).
• the first subscript conversion array of if the range of the subscript is (j ⁇ l) or less, 0 is given as the first offset value, and the range of the subscript is j or more (m ⁇ 2 ) It is configured to give 1 as an offset value when:
• an object of the present invention is a tabular data update method for updating an item value at an arbitrary position in a tabular data represented by a data structure defined above,
• an insertion position indicating the position where the item value is to be inserted is specified, and the second subscript conversion array corresponds to the insertion position.
• an offset value for specifying a predetermined position after the end of the first entity array is given, and the subscript corresponding to the insertion position is provided in the second subscript conversion array.
• a third offset value to shift the corresponding subscript range upward so that the value defining the range is larger, and to decrement the accepted subscript The item value to be inserted is arranged at a predetermined position after the end of the first entity array
• an updated pointer value is assumed to be a pointer value to be inserted, an insertion position indicating a position where the pointer value is to be inserted is specified, and in the first subscript conversion array, Regarding the insertion position, the corresponding subscript is determined, and a first offset value for specifying a predetermined position after the end of the first entity array is given, and in the first subscript conversion array, For those having a record number higher than the record number corresponding to the insertion position, the range of the corresponding suffix is shifted upward so that the value defining the range becomes larger, and is accepted.
• a first offset value for decrementing the subscript is added, and a new value larger than the existing pointer value is provided at a predetermined position after the end of the second entity array.
• B With respect to the pointer array, the position of the pointer value to be updated is deleted.
• the position is specified in consideration of the insertion position, and in the first subscript conversion array, a corresponding subscript is determined with respect to the deletion position, and in the first subscript conversion array, the deletion is performed. For those with record numbers higher than the record number corresponding to the position, shift the range of the corresponding subscript downward so that the value defining the range becomes smaller. Rutotomoni, providing a first offset value for incrementing the subscript accepted,
• the present invention is attained by a tabular data update method characterized by being configured to sequentially execute any one of the above (A) and (B) or the above (B) and (A).
• the updating method includes m record numbers and n item values, and an update position of the item value in the value list is i (0 ⁇ i ⁇ n-1).
• the item value is located at the end n of the first entity array, the update position of the record number is j (0 ⁇ j ⁇ m—1), and the pointer value is at the end m of the second entity array.
• the update position of the item value in the value list is i (0 ⁇ i ⁇ n—1)
• the first entity array has The updated item value is placed at the specified position z (z ⁇ n) after the end, the update position of the record number is j (0 ⁇ j ⁇ m-1), and the end of the second entity array
• the updated pointer value is located at the subsequent predetermined position X (x ⁇ m)
• the value conversion array of the pointer array when the value range is (i ⁇ 1), 0 is given as the second offset value, and the value range is i or more and (n ⁇ 1) or less. In this case, if 1 is given as the second offset value and the value is y (where y is the pointer value stored at position X of the second physical array), the second offset value is used. It may be configured to give (i-y) as a value.
• the method of deleting tabular data may be such that the record number is determined in accordance with a fourth entity array in which the record number itself is arranged and a range of a subscript for specifying the record number.
• a third subscript conversion array that gives the offset value of the record number, specifies a deletion position indicating the position of the record number to be deleted, and, in the third subscript conversion array, a subscript corresponding to the deletion.
• the range of the corresponding subscript is changed so that the value for determining the range becomes smaller.
• Shift down and accept subscripts May be configured to provide a fourth offset value for incrementing the value.
• This forms an information block including a fourth entity array in which the record numbers themselves are arranged, and forms a subscript conversion array for specifying the record numbers, thereby realizing substantial data deletion. I have.
• an object of the present invention is to insert, delete, and / or update data in tabular data by the above method, and in any of rollback and commit, the subscript conversion array and the value conversion array are used. This can also be achieved by a transaction processing method characterized by disposal. In this case, the subscript conversion array and the value conversion array may be discarded only in the case of rollback.
• an object of the present invention is a parallel processing method of processes in which processes are simultaneously executed by a plurality of processes with respect to tabular data having a data structure according to the above definition.
• the first subscript conversion array, the second entity array, and the value conversion array are configured to pass through the pointer array.
• the process is configured to go through a second subscript conversion array and a first entity array, while the processes that do not involve the continuous insertion, deletion, and / or updating of It is characterized in that it is configured to go through the second entity array and to go through the first entity array in the value list in the value list. It can also be achieved by a parallel processing method.
• Processes involving data insertion, deletion and / or updating preferably utilize any of the insertion, deletion, and updating methods described above.
• a method for locking a record includes providing an information block including an array for managing the lock, and arranging the information block.
• an item value indicating the type of lock is arranged corresponding to each of the record numbers.
• FIG. 1 is a block diagram illustrating a hardware configuration of a computer system capable of realizing a search, aggregation, and search method according to an embodiment of the present invention.
• FIG. 2 is a diagram illustrating information blocks used in the present embodiment.
• Figure 3 shows an example of tabular data and an example of an information block based on the tabular data.
• Fig. 4 shows another example of tabular data and another example of an information block based on the tabular data.
• Figure 5 is a flowchart showing the search method for a single item.
• FIG. 6 is a flowchart illustrating a process for creating an information block based on a tabular format.
• Figure 7 is a diagram showing an example of the original data for creating an information block.
• FIG. 8 is a diagram showing an example of inserting an element into an array and an example of updating an element of the array.
• FIG. 9 is a diagram showing a relationship between a subscript, an array and a value from the array, and a subscript conversion and a value according to the present invention. Diagram explaining the outline of conversion,
• FIG. 10 is a diagram for explaining a logical relationship between input and output relating to insertion of an element, and insertion of an element into an array according to the first embodiment
• FIG. 11 is a flowchart showing a process for specifying an element in an array from a subscript according to the first embodiment
• FIG. 12 is a diagram illustrating insertion of a certain element at a specific position in the first embodiment.
• FIG. 13 is a flowchart showing a process for generating a subscript conversion array for inserting an element in the present embodiment
• FIG. 14 is a diagram showing an example of a subscript conversion array generated by the process of FIG. 13.
• FIG. 15 is a diagram showing a logical relationship between input and output relating to the deletion of an element and the first embodiment. A diagram for explaining the deletion of elements from an array,
• FIG. 16 is a diagram for explaining the deletion of an element at a specific position in the first embodiment.
• FIG. 17 is a diagram for generating a subscript conversion array for deleting an element in the present embodiment.
• FIG. 18 is a diagram showing a state in which numerical values in the conversion array change according to the processing shown in FIG. 17,
• FIG. 19 is a diagram for explaining a state when insertion and deletion are sequentially performed in the first embodiment
• FIG. 20 is a diagram for explaining a state where insertion and deletion are sequentially performed in the first embodiment
• FIG. 21 is a diagram for explaining a configuration of a conversion array according to the second embodiment of the present invention.
• FIG. 22 is a diagram for explaining a real array and a difference array according to the third embodiment of the present invention.
• FIG. 23 is a diagram for explaining an outline of a value conversion array according to the fourth embodiment of the present invention.
• FIG. 24 is a flowchart illustrating a value conversion process according to the fourth embodiment.
• FIG. 25 is a flowchart illustrating a process of generating a value conversion table according to the fourth embodiment.
• FIG. 26 is a diagram for explaining a state in the case where the conversion of the values in the actual array is performed in the fourth embodiment.
• FIG. 27 is a diagram showing an example of a data structure obtained by combining a subscript conversion array and a value conversion array in the present invention.
• FIG. 28 is a diagram showing the structure of each information block according to the fifth embodiment of the present invention.
• FIG. 29 is a diagram for explaining a process of deleting a specific record in the fifth embodiment.
• FIG. 30 is a diagram for explaining a process of deleting a specific record in the fifth embodiment.
• FIG. 31 illustrates a process of deleting a specific record in the fifth embodiment.
• FIG. 32 is a diagram for explaining a process of deleting a specific record in the fifth embodiment.
• FIG. 33 is a diagram for explaining a process of inserting a specific record at a specific position in the fifth embodiment
• FIG. 34 is a diagram for explaining a process of inserting a specific record at a specific position in the fifth embodiment
• FIG. 35 is a diagram for explaining processing for inserting a specific record into a specific position in the fifth embodiment
• FIG. 36 is a diagram for explaining a process of inserting a specific record into a specific position in the fifth embodiment.
• FIG. 37 is a diagram for explaining a process of inserting a specific record into a specific position in the fifth embodiment.
• FIG. 38 is a diagram for explaining a process of inserting a specific record into a specific position in the fifth embodiment.
• FIG. 39 is a diagram illustrating a process of inserting a specific record into a specific position in the fifth embodiment.
• FIG. 40 is a diagram for explaining a process of inserting a specific record at a specific position in the fifth embodiment
• FIG. 41 is a diagram for explaining a process of inserting a specific record at a specific position in the fifth embodiment.
• FIG. 42 is a diagram for explaining a process of deleting a specific record in the sixth embodiment of the present invention.
• FIG. 43 is a flowchart showing a transaction process using the present invention.
• FIG. 44 is a diagram for explaining parallel processing of a plurality of processes using the present invention.
• FIG. 45 is an exclusive process using the present invention. A diagram for explaining the
• FIG. 46 is a flow chart for explaining a data insertion process in a tabular format in the form of an information block according to the present invention
• FIG. 47 is a view for explaining data insertion processing of tabular data in the form of an information block according to the present invention
• FIG. 48 is a diagram for explaining data deletion processing of tabular data in the form of an information block according to the present invention.
• FIG. 49 is a diagram for explaining another application example of the subscript conversion array according to the present invention.
• FIG. 50 is a diagram for explaining still another application example of the value conversion array according to the present invention.
• 1 is a diagram for explaining still another application example of the subscript conversion array and the value conversion array according to the present invention,
• FIG. 52 is a diagram for explaining another example of the data insertion process in tabular data in the form of an information block according to the present invention.
• FIG. 53 is a diagram for explaining data update processing in tabular data in the form of an information block according to the present invention.
• FIG. 54 is a diagram for explaining another example of the data update process in tabular data in the form of an information block according to the present invention. DESCRIPTION OF THE PREFERRED EMBODIMENTS OF THE INVENTION
• FIG. 1 is a block diagram showing a hardware configuration of a combination system that can implement a method of inserting, deleting, and updating data of a certain item in a tabular format according to an embodiment of the present invention.
• the computer system 10 has a configuration similar to that of a normal computer. By executing a program, the computer system 10 stores the CPU 12 that controls the entire system and individual components, and stores work programs and the like.
• RAM Random Access Memory
• R 0 M Read Only Memory
• fixed storage medium 18 such as hard disk
• CD-ROM 19 for accessing CD-ROM 19 ROM driver
• CD- An interface (I / F) 22 provided between the ROM driver 20 and an external terminal connected to an external network (not shown) 22, an input device 24 consisting of a keyboard and mouse, and a CRT display device It has 26.
• CPU 12, RAM 14, ROM 16, external storage medium 18, I / F 22, input device 24 and display device 26 are connected via bus 28. Interconnected.
• the program for controlling the parallel processing and the program for implementing the exclusive processing may be stored in the CD-ROM 19 and read by the CD-ROM driver 20 or may be stored in the ROM 16 in advance. .
• the data once read from the CD-ROM 19 may be stored in a predetermined area of the external storage medium 18.
• the program may be supplied from the outside via a network (not shown), an external terminal, and the I / F 22.
• the insertion of data includes not only inserting data between adjacent records, but also adding a new record at the end of a record.
• this information block generation program may be stored in the CD-ROM 19, stored in the ROM 16, or stored in the external storage medium 18. Alternatively, it goes without saying that these programs may be supplied from outside via a network (not shown).
• data (information block) generated by the information block generation program is stored in the RAM 14 or in a predetermined area of the external storage medium 18.
• the handling of tabular data which is the premise of the present invention, that is, a form for managing tabular data will be briefly described.
• the present inventor has developed a specific data format in order to quickly search, tabulate, and sort tabular data, and to allow a plurality of tabular data to be joined as desired. It has devised a tabular data construction (Japanese Patent Application No. 10-227278) and a join of tabular data having the specific data format (Japanese Patent Application No. 111-1151156).
• the tabular format data is based on the technology disclosed in these applications. Evening is constructed as a set of predetermined information blocks, which are used for searching, counting, and sorting.
• FIG. 2 is a diagram showing information blocks used in the present embodiment.
• the information block 100 includes a value list 110 and a bus array 120 to the value list.
• the value list 110 is a list of item values corresponding to the above item value numbers in the order of the item value numbers in which the item values belonging to the item are ordered (converted to integers) for each item of the tabular data. 1 is the stored table.
• Pointer array to value list 120 is an array in which the item value numbers of columns (that is, items) with tabular data, that is, pointers to value list 110 are stored in the order of record numbers of tabular data. is there.
• FIG. 3 (a) For example, consider the tabular format shown in Fig. 3 (a).
• various item values are given to the items such as customer ID, customer name, and telephone number.
• such tabular data is held as information blocks in the format shown in FIGS. 3 (b) to 3 (d).
• the pointer array 1 2 0—1 is associated with a value list 1 1 0—1 that stores item values indicating customer IDs. That is, the pointer value of the pointer array of the first record (record number “0”) is 0, and correspondingly, the item value “1” indicating the customer ID is obtained.
• the pointer array 12 0-2 is associated with the value list 110-2 storing the item values indicating the customer names.
• the pointer value in the pointer array of the first record (record number “0”) is “5”, and correspondingly, the item value “S mith” indicating the customer name is obtained.
• the pointer array 1 2 0—3 is associated with the value list 1 1 0—3, which stores the item values that indicate telephone numbers. Also, in each value list, you can see that the item values are ordered (in this example, in ascending order).
• the value management table of the information block 100 stores, in addition to the value list 110, a classification number flag array used for searching and counting, and the number of bytes corresponding to the item value.
• a start position array indicating the head address of the memory space to be provided, and an existence number array are included.
• Each flag of the classification number flag array and each existence number of the existence number array are associated with each item value.
• the flag value of the classification number flag is usually “0”, and is set to “1” according to the item value to be found in search or aggregation.
• the number of occurrences corresponds to the number of records having the item value.
• Fig. 4 (a) is a diagram showing another example of tabular data
• Figs. 4 (b) and (c) are diagrams showing information blocks relating to "sex" and "age", respectively.
• the value management table 2 1 0—1 of the information block 2 0 0 _ 1 relating to gender includes the item values (“male ”And“ Women ”) and the classification number, start position, and number of occurrences corresponding to each item value.
• the number of records whose Boyne evening value is “0” (that is, the item value of the value list is “male”) is 6 3 2 5 6 4, while the number of Boyne evening value s
• the number of records with "l” (that is, the value of the item in the value list is "female”) is 367436.
• the start position corresponding to each item value indicates the head address of a boy-in-law array 230-1 to a record described later. The same can be understood in Fig. 4 (c).
• FIG. 5 is a flowchart showing a search method for a single item. This process is realized by the CPU 12 (see FIG. 1) executing a predetermined search program. This example finds records where the age field value is 16 or 19 years.
• “information block 200-2—age-2” shown in FIG. 4 (c) is specified (step 501).
• the item value corresponding to the one that matches the above search condition (16 years old or 19 years old) The classification number of the row to be set is set to "1" (step 502).
• the classification number of the row corresponding to the item value number “0” and the item value number “3” is set to “1”.
• the start position and the number of occurrences corresponding to the line whose classification number is set to “1” are obtained (step 503).
• Such information is referred to as pointer extraction information.
• a record number indicating the number of records to the record that matches the search condition is extracted based on the pointer extraction information acquired in step 503 (step 504).
• the pointer of the record corresponding to the item value number “0” is stored in the start position “0” of the pointer array to the record, that is, in the area from the beginning to the 458,98.
• the pointer of the record corresponding to the item value number ⁇ 3 '' must be stored in the area of 1 896 3 53 from the 2 3 8 3 1 3 7 I understand.
• an array of fetched record numbers is created as a result set and stored, so that it can be used in later processing (step 505).
• Aggregation and sorting can also be realized by using the classification number, start position, and number of occurrences.
• FIG. 6 is a flowchart illustrating a process for creating an information block based on tabular data.
• the system 10 obtains the original data in the form of a table and decomposes the data into items (step 601).
• This original data may be, for example, the one shown in FIG. 7 (a) or the one shown in FIG. 7 (b). These original data may be supplied from the outside, or may be data stored in the fixed storage medium 18.
• the processing block 610 consisting of steps 602 to 604 described below is a certain term. 4 illustrates the generation of an information block for an eye. Therefore, when generating information blocks for a plurality of items, the processes corresponding to the processing blocks 6110 are executed by the number of items. The following is an explanation using the information block for items related to “sex” as an example.
• an area for an information block of an item relating to “sex” is secured, for example, in RAMI 4 (step 602).
• a value management table is generated in the reserved area. More specifically, first, the value management table is initialized. Next, by scanning the data related to “sex” from the beginning to the end of the original data, it is possible to find out what item names and how many items exist. In this example, it is found that there are only 3674336 and 6325644 item names "female” and "male”, respectively. 3 With this, the item values “female” and “male” are set in the value list, and a predetermined number is set in the existence number array. Thereafter, the item values are sorted according to predetermined criteria.
• the number of existing items is also rearranged according to the rearrangement of the number of items.
• the value of the start position array is determined. This is obtained by accumulating the number of higher-ranking entities by sorting. Also, the value of the start position array is assigned to the value of the corresponding classification number array. This value will be used in the next step. After the value management table is generated in this way, a binding array for the records is generated. The size of the area of this pointer array corresponds to the sum of the numbers.
• This information block is generated in advance, and the search, tallying, and sorting processes are performed using the generated information block.
• the entire array is scanned.
• the subscript indicates the position in the array, and the stored value of the corresponding position is extracted (that is, the stored value is quoted from the subscript). This is advantageous in that it can be used. In other words, if each element (stored value) is stored in the order of the memory address, the address can be calculated immediately from the subscript, and the extended value of the corresponding address can be obtained. Therefore, there is a need for a method that minimizes the load required to insert and delete elements (stored values) while taking advantage of this advantage.
• a subscript converter for converting the “subscript” given to the array and / or a value converter for converting the value extracted from the array are provided, and the array itself is divided into an entity array and a difference array, Elements can be inserted, deleted, and updated without changing the position of the elements (stored values) contained in the array and without changing the values themselves.
• a suffix conversion array for element insertion or the like used in the first embodiment of the present invention.
• the subscripts are record numbers for specifying the elements (pointer values) of the pointer array to the value list, and boin for specifying the item values of the value list.
• the pointer value in the evening array is included.
• the array includes a pointer array to a value list, a value list, a pointer array to a record number, and the like.
• the subscript conversion array includes a start position array, an end position array, and an offset array. Of the elements (values) stored in these arrays, those located at the same position (for example, line 0, line 1, etc.) are related to each other.
• the elements in the start position array and the corresponding elements in the end position array specify the range of the associated subscript. That is, the element in the start position array indicates the minimum value of the associated subscript, and the element in the end position array indicates the maximum value of the associated subscript.
• the corresponding element in the offset array indicates the offset value to be added or subtracted from the subscript to obtain the converted subscript specifying the actual entity array.
• a set of elements corresponding to the start position array, the end position array, and the offset array (that is, a set of elements located on the same line) is sometimes referred to as a “structure array”. These elements are called “structure members”.
• the meaning of the subscript conversion array will be described below.
• the range of the subscript and the offset value of the subscript included in the range are determined by one member of the structure in a certain structure array. For this reason, for a given subscript, a structure array related to the subscript is specified, and an offset value is added to obtain a converted subscript.
• the position of (substance array) it is possible to refer to the elements (stored values) in the array.
• the subscript “0” is related to the structure array in the 0th row (first row).
• the subscript “1” is related to the structure array in the first row (second row), and the value of the member (offset value) in the offset array related to the structure array is “n ⁇ 1 "
• the storage position of the corresponding element can be specified for the subscripts “2” and “n”.
• the number indicating the position of the subscript (storage position number) is initialized (step 1101), and then, referring to the elements of the start array and the end array, the subscript is set in the start position array and the end position array. It is specified which of the ranges defined by the values is included (step 1102). That is, this step specifies which structure array the subscript is associated with. For example, in the example of FIG. 10 (c), it can be seen that the subscript “0” is included in the range specified by the element “0” in the start array and the element “0” in the end array. Alternatively, it can be seen that the subscript “1” is included in the range specified by the element “1” in the start array and the element “1” in the end array.
• the corresponding offset value is extracted (step 1103), and the value obtained by adding the offset value to the subscript is obtained (step 1104).
• the value to which this offset is added becomes the converted subscript, and the element in the entity array is specified using this value (step 1105).
• this subscript is included in the range corresponding to the first row (second row), so the offset value “n—1” of the first row is replaced by the subscript “1”. Added. Therefore, the converted subscript is “n”, and the corresponding element (stored value) “Y 0” in the entity array can be obtained.
• the offset value “1 1” of the second row is replaced by the subscript “2”. Is added to Therefore, the converted subscript is “1”, and the corresponding element (stored value) “X 1” in the entity array can be obtained.
• the elements (stored values) in the entity array are maintained while maintaining the logical relationship shown in Fig. 10 (b). ) Can be obtained. Therefore, in the present invention, when an element (stored value) in an array is inserted, a conversion array as described above is generated, and a predetermined position (for example, an address of an address) of an entity array is moved without moving the element itself in the array. By arranging the element to be inserted at the position corresponding to the maximum value, the element can be inserted without any load.
• FIG. 13 is a flow chart illustrating a process of generating a conversion array for inserting a new element (stored value) into the array. This processing is executed by the CPU 12 in FIG. First, a subscript conversion array in an initial state is generated (step 1300). More specifically, the number of elements in the array is examined to determine the starting and ending positions.
• the start position is “0” and the end position is “4” in the initial subscript conversion array.
• the elements in the array are referenced directly from the subscript, so the initial offset value is “0” (see reference numeral 1401 in FIG. 14). ). If the subscript conversion array has been generated in advance, that is, if insertion has been performed more than once, or if the initial subscript conversion array has been generated when the information block was generated, step 1 3 0 0 is omitted.
• each array included in the initial subscript conversion array includes only one element each, but by the processing of step 1301, 3 An area is reserved for an array with one element (the element before the insertion position, the element after the insertion position, and the element after the insertion position) (step 1302). If an array with multiple elements has already been provided, An area is allocated for the array so that the number of elements increases by two.
• the values of the elements of each array are determined before the insertion position (step 1303). More specifically, the corresponding element value of the start position array and the corresponding element value of the offset array are not changed, and “the value corresponding to the insertion position 1” is given as the element value of the end position array. Also, regarding the insertion position, the value of the corresponding element of each array is determined (steps 1304 and 1305). In this case, the value corresponding to the insertion position is given as the element value of the start position array and the end position array, and the value corresponding to the end position of the actual array is provided as the element value of the offset array. Is given. As will be described later, if the elements to be inserted are arranged at different positions as a “differential array”, a value corresponding to the position of the element to be inserted in the differential array is set as an offset value. Just give it.
• the element value of each array is determined by the following method after the insertion position.
• “value corresponding to the insertion position + 1” is given as the corresponding element value of the start position array (step 1306), and the corresponding value of the initial position corresponding to the initial end position Is given (step 1307).
• the corresponding element value of the offset array is set to “its initial value (original value) — 1” (step 1308).
• step 1300 changes the initial subscript conversion array indicated by reference numeral 1401 in FIG. 14. If it is generated, it can be understood that the subscript conversion array indicated by reference numeral 141 1 is generated by the processing of steps 1301 to 1307.
• the CPU 12 After generating such a subscript conversion array, the CPU 12 stores the element to be inserted at a predetermined position (the end in the above example) after the end of the entity array set in step 1304. I do. As a result, it is possible to substantially (logically) insert an element at a desired position in the actual array without moving the element (stored value) of the actual array.
• the elements (stored values) in the entity array are specified.
• the subscript “1” is related to the structure array in the first row (second row), and the value of the member (offset value) in the offset array related to the structure array is “1”.
• Fig. 16 (a) consider an array of 5 elements (reference number 1601), and delete the element (stored value) X0 in the first row (second row). (See reference numeral 1602). In this example, it is assumed that the entity array is the same as array 1601.
• FIG. 17 is a flowchart showing a process of generating a conversion array for deleting an element (stored value) from the array.
• FIG. 18 (a) is a diagram showing a conversion array for the example shown in FIG. 16 (a). It is a figure showing the state where the numerical value inside changes.
• an initial subscript conversion array is generated (step 1700). For example, in the example shown in Figure 16 (a), the number of elements is “5”, so the value indicating the start position is “0”, the value indicating the end position is “4”, and the offset value is “0”.
• a start position array, an end position array, and an offset array are generated (see reference numeral 1801 in FIG. 18A).
• step 1701 the position of the element to be deleted is specified (step 1701), and A region for the conversion array relating to the position is specified (step 1702).
• the area for accommodating the elements before the deletion position, the deletion position, and after the deletion position is set. Be chosen.
• “value-1 indicating the deletion position” is placed as an element of the end position array (step 1703), while on the other hand, after the deletion position, the start position array As the element of “deletion position + 1” is arranged (step 1704).
• a start position array, an end position array, and an offset array as indicated by reference numeral 1802 are created for the structure array in the conversion array including the deletion position. Since the structure array related to the deletion position is not used eventually, it is necessary to calculate the deletion position itself, but as shown in Fig. 18 (a), it is necessary to store the elements in the array. There is no.
• the element of the start position array is set to “original value _ 1” (step 1705), and the element of the end position array is set to “original value-1” (step 1). 1 706).
• the element of the offset array is set to “original value + 1” (step 1707).
• the element “2” in the start position array located after the delete position is decremented to “1” (see reference numeral 1804), and the end position array The element “4” of this is decremented to “3”, and the element “0” in the offset array is incremented to “1”.
• the entity array that is, the array that actually stores the element specified by the subscript
• the entity array is not changed when the element is deleted.
• elements in the apparent (logical) array can be deleted only by the subscript conversion array.
• the elements in the array can be deleted by the processing of FIG.
• the element “Y 0” is inserted in the third row (line 4) of the array by the insertion of the elements described above, and therefore, the entity array has the element “ ⁇ 0 "Is added (reference numeral 1610 in Fig. 16). See).
• a subscript conversion array indicated by reference numeral 1811 in FIG. 18B is generated. In such a case, the generation of the initial conversion array shown in step 1700 is omitted.
• the subscript conversion array indicated by reference numeral 1813 is obtained by performing the processing of steps 1701 to 1707 on the subscript conversion array indicated by reference numeral 1811 in FIG.
• Insertion and deletion of elements in the array are realized by sequentially executing the insertion processing shown in FIG. 13 and the deletion processing shown in FIG. It goes without saying that the order of the above processing is easily reversed.
• the order of the above processing is easily reversed. For example, initially, as shown in Figure 19, for the subscripts “0” to “4”, respectively, “0”, “100”, “200”, “300” and “400” Consider an array 19 0 1 in which the element is specified. Regarding this array, insert the element “20 1” between the second row (the third row) and the third row (the fourth row), and delete the element of the first row (the second row).
• an initial conversion array is created (see reference numeral 2001), and then the conversion array for insertion is inserted by the processing shown in FIG. (See reference numeral 2002 in Fig. 20 (b)), and place an element to be inserted (in this case, "201") at the end of the entity array (see reference numeral 2003).
• a conversion array for deletion is created by the processing shown in FIG. As a result, insertion and deletion of elements are realized.
• the element is updated by sequentially executing the processing of deleting the element and inserting a new element at the position of the deleted element.
• the storage position indicates a subscript via the subscript conversion array, and the storage value indicates an apparent (logical) entity array. Initially, the subscripts match the storage locations (see reference numeral 201 1), but the insertion and deletion create or update the subscript conversion array, and the elements in the apparent entity array as desired. You can see that has been inserted and deleted (see reference numerals 2012, 2013).
• the start position array and the end position array are used to specify the range in which the subscript is included or the position of the element to be deleted or inserted. I was however, if the value of a certain element in the end position array is “n”, it is clear that the value of the element in the start position array located on the next line is “n + l”, and vice versa. It is also clear. Therefore, in the second embodiment, the subscript conversion array is composed of the start position array and the offset array, or the end position array and the offset array, and the memory size required for the subscript conversion array is reduced.
• the subscript conversion array 211 shown in FIG. 21 (a) may be represented as shown in FIG. 21 (b).
• the subscript “i” such that 0 ⁇ subscript ⁇ ⁇ (3-1) corresponds to the 0th row (first row).
• the character offset value is “0”.
• the letter "i" corresponds to the second line (third line).
• a subscript conversion array as shown in FIG. 21 (c) may be used.
• the subscript "i” such that 5 ⁇ subscript ⁇ ⁇ (3 + 1) corresponds to the second row (third row), and 3 ⁇ subscript i (2 + 1).
• a suffix "i” corresponds to the first row (2nd row), and a suffix "i” such that 2 ⁇ subscript i corresponds to the 0th row (first row) I do.
• the elements to be inserted are arranged at the end of the array (for example, see FIG. 10 (c)).
• the inserted element is arranged in an arbitrary editing work area. Such an editing work area in which elements to be inserted are arranged is called a “difference array”.
• FIG. 22 is a diagram illustrating an example of the subscript conversion array, the entity array, and the difference array.
• the inserted elements "Y0" and " ⁇ 1" are secured in a separate area from the entity array 222 by the subscript conversion array 222.
• a value conversion array according to a fourth embodiment of the present invention will be described.
• a value conversion array described below is used to update an element of the array.
• a value conversion array is arranged at the subsequent stage (downstream side) of the array, and the values output from the array are passed through the value conversion array. The converted value is output, and a method is used in which the element (stored value) is updated in the converted output.
• a value conversion array as shown in FIG. 23 (a)
• the value conversion array includes an end position array and an offset array.
• the value conversion array may be composed of a start position array, an end position array, and an offset array.
• a structure array is constituted by the elements arranged at the corresponding positions.
• the position of the element (stored value) in the actual array is related to which structure array is specified by the value of the end position array.
• the offset can be specified.
• the number indicating the storage position of the element is initialized (step 2401), and the element (storage value) in the array specified by the storage position number is defined by the end position array. It is specified which of the ranges is included (Step 2402).
• This step identifies which structure array the element is associated with. In the example of Fig. 23 (b), the element whose storage position number is "0" (that is, the 0th row (first row)) is "1", and this element is the 1st row in the end position array. Since the value is in the range determined by the value of (the second line) (that is, 1 ⁇ the element in the array ⁇ 1), the element is related to the structure array in the first row (the second line).
• the offset value in the offset array belonging to this structure array is extracted (step 2403), and the value obtained by adding the offset value to the element is output (step 2404).
• the value that has passed through the value conversion array may be stored in an area corresponding to the storage position number of the output value array (step 2405).
• the value passed through the value conversion array may be directly used for other processing.
• an initial value conversion array is created (step 2500). The processing of this step is executed only when the value conversion array has not been created.
• an initial value conversion array as shown in FIG. 26 (a) is obtained.
• the maximum value of the elements in the entity array is assigned as an element in the end position array, and “0” is assigned as an element in the offset array.
• the number of rows of the array to be generated is determined based on the range of elements (stored values) giving a certain offset (step 2501). For example, as shown in Fig. 23 (a), when the condition that "1" is added to an element having a value of "1" or more is given, the number of rows in the end position array and the offset array is " 2 ". This is because rows (or structure arrays) for elements with values less than "1" and rows (or structure arrays) for elements with values greater than "1" should be generated.
• the maximum value of each range is placed on the corresponding row of the end position array, and its offset value is placed on the corresponding row of the offset array (Steps 2 502, 25 03).
• the entity array as shown in Fig. 23 (a) if "1" is to be added to the element having a value of "1" or more, in the end position array, 1 The maximum value “0” of the smaller value is placed, and the offset value “0” is placed in the 0th row (first row) of the offset array. That is, a numeric value is given to the structure array on the 0th line.
• the first line (the second line) gives the maximum value "1” of the elements in the entity array. This can be done by using the initial value of the value conversion array.
• the offset value “1” is placed in the first row (second row) of the offset array (see reference numeral 2602 in FIG. 26 (a)).
• two conversion array regions are formed by one condition.
• the present invention is not limited to this.
• a plurality of conditions for example, when 0 ⁇ value ⁇ 1 is satisfied
• Add “1” to the element add “ ⁇ 1” to the element if 1 ⁇ value ⁇ 4, and do not give offsets to other elements.
• the above subscript conversion array and value conversion array can be used in combination.
• FIG. 27 on the upstream side (input side) of the physical array (see reference numeral 2700) in which the elements “0” to “99” repeatedly appear, “0” to “500, Subscripts up to “0 0 0” are given an offset “0” and subscripts from “500, 0 00” to “99 9, 999” are given an offset “1”
• a subscript conversion array (see reference numeral 2701) is provided, and if the value is 49 or less, an offset “1 1” is given to the downstream side (output side) of the entity array, and if the value is 50 or more,
• a value conversion array reference numeral 270 2 2
• giving the offset “1” is provided.
• the output value can be obtained through the subscript conversion array, the entity array, and the value conversion array.
• the subscript given to the entity array in a certain information block is converted, and the elements (item values) in the entity array are extracted by the converted subscripts.
• the apparent (logical) array consisting of the input (subscript) and output (converted value) of the information block is considered. Becomes possible.
• a desired member's first and last name is inserted into or deleted from the personal name table including the items of the member last name and the member name, or the last name or first name is updated.
• the method according to the second embodiment is used for insertion. That is, the subscript conversion array and the value conversion array are each composed of an end position array and an offset array.
• the process of generating a subscript conversion array and the process of generating a value conversion array described below include generating a new conversion array and updating an existing conversion array. Therefore, in the following, “generation” means generation or update, and in some cases, this is referred to as “generation (or update) j”.
• FIG. 28 (a) shows an example of a person name table. Due to such a personal name table 280, in the present embodiment, the record number list 2810 shown in FIG. 28 (b) and the item “member surname” shown in FIG. An information block 2820 relating to the item “member name” shown in FIG. 28 (d) is generated.
• the initial subscript conversion array 282 3 and the initial conversion array 282 4 are created in advance.
• the entity array 2 825 corresponds to the Boyne array to the (original) value list before creating the conversion array.
• an initial subscript conversion array 282 is created in advance. Note that the entity array 282 7 corresponds to the value list that stores the original item values.
• An initial subscript conversion array and a value conversion array are also created in advance in the data array 2830 in the value array 2831 to the value list, and in the value list 2832 as well, A subscript conversion array is created in advance.
• the CPU 12 shown in FIG. 1 performs substantially the same processing as that shown in FIG. 17 on such a subscript conversion array in the “pointer array to the value list”. More specifically, first, the position of the element to be deleted is specified in the entity array (pointer array) 3001 (step 1701 in FIG. 17), and the area of the conversion array related to the deletion position is secured. (Step 1702). Next, before the deletion position, “deletion position 1 1”, that is, “0” is arranged as an element of the end position array (step 1703). In this example, since no start position array is provided, steps 1704 and 1705 are omitted.
• each element of the end position array is decremented (step 1706), and each element of the offset array is incremented (step 1707).
• a subscript conversion array as shown in FIG. 30 (b) can be obtained.
• the pointer value of the “array of pointers to the value list”, which is the actual array is output as indicated by reference numeral 3010 for the record number as the subscript. Will.
• the CPU 12 performs substantially the same processing as that illustrated in FIG. 17 in the same manner as the information block related to “member last name”.
• the subscript conversion array 3101 in the information block of “member name” shown in FIG. 31 (a) becomes the subscript conversion array 311 1 as shown in FIG. 31 (b). Therefore, the relationship between the input of the “record number” as a subscript and the pointer value of the “pointer to a value list” as an entity array is as shown by the reference numeral 3100 in FIG. 1 (b) is changed to that shown by reference numeral 3 10.
• a desired element can be specified in the actual array of the value list.
• the CPU 12 specifies the element (pointer value) in the entity array from the new record number (subscript) by the new subscript through the subscript conversion array. For example, since the offset value for record number “0” is “0”, the element (Boin evening value) of the 0th row (1st row) in the entity array is extracted, and this pointer value “1” is used. Then, the item value of the first row (the second row) in the entity array in the value list is specified (see (1) in Fig. 32).
• the item value of the first row (the second row) in the entity array in the value list is specified by the pointer value “1” (see (1) in FIG. 32).
• a record is inserted between the 0th line (1st line) and the 1st line (2nd line) (Fig. 33 (a) b) See).
• insertion of elements by subscript conversion array is executed” and “generation of value conversion array” is executed for necessary information blocks.
• FIG. 34 is a diagram showing a state of each information block before a record (data) is inserted.
• the update of the subscript conversion array in the information block of “member surname” and the update of the subscript conversion array in the information block of “member name” will be considered.
• "For member surname I, the element” Ford " (Item value) must be added. Therefore, the CPU 12 executes an insertion process using the subscript conversion array in the value list (see FIG. 13). More specifically, the insertion position of the element (item value) is determined (see step 1300 in FIG. 13). In this example, it is necessary to insert the element “Field” (field value). However, in the actual array of the value list, the elements are arranged in ascending order (in this case, alphabetical order). The element “Ford” must be placed before the element “Smith”, and therefore its insertion position is determined to be line 0 (line 1).
• Step 1301 in FIG. 35 since the insertion position is the 0th line (1st line), no element exists before the insertion position, and Step 1 303 to Step 1307 are performed for the insertion position and the element after the insertion position. Is performed.
• Fig. 35 (b) regarding the insertion position (see reference numeral 3510), an element "0" indicating the insertion position is arranged in the end position array (see reference numeral 35 1 1), and the end of the entity array is added.
• the indicated position “1” is arranged as the corresponding element of the offset array (see reference numeral 3512).
• a value obtained by adding “+1” to the original value is placed in the end position array (see reference numeral 3513), and the original offset value is set as the corresponding value of the offset array.
• a value obtained by adding “1” to “0” is placed (see reference numeral 3514).
• a new element (item value) “Ford” is placed at the end of the entity array (see reference numeral 3520).
• the apparent (that is, logical) array is changed to code 3521. As shown, the order is ascending (alphabetical).
• the CPU 12 executes an insertion process (FIG. 13) using the subscript conversion array in the value list of in the information block of “member name”. More specifically, the insertion position of the element (item value) is determined to be the first row (the second row) (see reference numeral 3610 in FIG. 36 (b)), and the area for each conversion array is secured. You. For elements before the insertion position, as elements in the end array, The insertion position (in this case, “1”) is assigned a value obtained by subtracting “1” (adding “1 1”) (see reference numeral 3611), while the value in the corresponding offset array is assigned. The element is retained (see code 3612).
• an element “1” indicating the insertion position is arranged in the end position array (see reference numeral 3513), and the position “2” indicating the end of the actual array is provided.
• the offset value "1" to indicate "” is given as an element in the offset array (see reference numeral 3614).
• a value conversion array for converting the elements of the entity array needs to be created (or updated).
• the related value list that is, the “member surname” value list
• “Ford” is inserted at the beginning of the apparent (or logical) array (see reference numeral 3521 in Figure 35). Therefore, among the pointer values of the pointer array to the value list (that is, the elements in the entity array 3701), those having values of 0 or more must be incremented.
• the CPU 12 generates (or updates) the value conversion array in the pointer array to the value list according to the flowchart shown in FIG.
• the maximum value that can be taken is "0", and it is necessary to increment the value greater than "0".
• the value "0" in the offset array Is added to "+1" (see step 2503 in FIG. 25, and reference numeral 3711 in FIG. 37 (b)).
• the element (pointer value) actually stored in the actual array and the element (pointer value) output via the value conversion array are as shown by reference numeral 3702 in FIG. 37 (a).
• the elements (pointer values) output through the value conversion array, as shown in FIG. Then, the original value is incremented.
• the CPU 12 executes the processing shown in FIG. 13 for the subscript conversion array of the pointer array in response to the insertion of the record number as the subscript. More specifically, since the record number where the new surname “Ford” (and the new first name “Jonny”) should be inserted is “1”, the insertion position is on the first line (the second line). It is determined that there is (see step 1301 in FIG. 13), and the area of the conversion array at the insertion position and before and after it is secured (step 1302). Below, step 1 30 By the processing of steps 3 to 13 08 (actually, the processing relating to the start position is omitted), a subscript conversion array (see reference numeral 3810) is formed as shown in FIG. 38 (a). You.
• the pointer array of the value list selects an output as indicated by reference numeral 381 1 with respect to the input of the record number as the subscript.
• the element (the item value) "Ford” is arranged in ascending order (alphabetical order). ) Is higher than the element (item value) named “S mith”. Therefore, the value of the entity array in the pointer array of the value list must be converted by the value conversion array so that the elements (item values) in the value list can be appropriately designated.
• CPU 12 executes the processing according to FIG.
• the offset value that is, the offset value “1 1” is given by inserting the last name “Ford” so that the output of the entity array is “1”, but the output is “0”.
• a process that gives an offset value “1” is executed.
• a value conversion array (see reference numeral 380) can be obtained as shown in FIG. 38 (b).
• the value output through the subscript conversion array, entity array, and value conversion array becomes the apparent (that is, ethical) array (code It should be understood that the elements (item values) of the value list are specified appropriately.
• the CPU 12 determines whether the subscript conversion array of the pointer array has a subscript
• the processing shown in FIG. 13 is executed in response to the insertion of a record number of ⁇ 1>. More specifically, the record number in which the new member name “Jonny” is to be inserted is “1”. Therefore, the processing according to FIG. 13 is performed with the first row (second row) as the insertion position (see step 1301 in FIG. 13). This makes it possible to obtain an offset array (see reference numeral 4010) as shown in FIG.
• FIG. 40 (b) the output of the pointer array of the value list subscripted by the record number is as shown in an apparent (logical) array (see reference numeral 4021). It can be seen that the output is obtained from each record number along the route shown by the broken line in FIG. 40 (b).
• the desired element in the entity array of the value list is obtained.
• (Item value) can be specified.
• the CPU 12 starts from the new record number (subscript), passes through the subscript conversion array, the entity array, and the value conversion array, and returns to the value list.
• Such output is given to a value list, and the elements (item values) in the entity array are specified by passing through the subscript conversion array in the value list.
• the element (item value) in the entity array of the value list is specified from the record number through the same route (see 1 to 4 in Figure 41).
• the elements of the actual array are defined by defining the input to the actual array as a subscript, converting the subscript, and / or converting the value output from the actual array.
• the element can be inserted and deleted from the entity array without moving.
• by applying a predetermined function to the input and output to the actual array it is configured such that insertion / deletion / update to the actual array is performed virtually (or logically). Therefore, it is possible to realize insertion of data and the like without requiring movement of elements in the actual array.
• a tabular format with a large number of elements it is possible to contribute to remarkably high-speed processing by not moving elements.
• Updating data for a tabular format is equivalent to sequentially deleting data at a certain record number (deleting a record) and inserting data into the same record number (inserting a record).
• the act of updating the record in the first row (the second row) for example, changing “Ford” of “Member surname” to “Truman”) And / or updating “Jonny” of “Member name” to “Tom”.
• the method described with reference to FIGS. 29 to 32 is used.
• the CPU 12 processes the subscript conversion array in accordance with the insertion of the item value into the value list, that is, sorts in alphabetical order.
• the process of generating (or updating) the subscript conversion array is executed (step 4601).
• the element (item value) is inserted at a predetermined position in the apparent (logical) entity array (value list). Those having a value equal to or greater than the value corresponding to the predetermined position are incremented (step 4602).
• the CPU 12 executes the processing of the subscript conversion array of the pointer array to the value list according to the input of the record number. (Step 4603). After such processing, finally, the value conversion array for the item value (in the above example, one value larger than the maximum value in the original entity array) in the entity array of the newly inserted pointer array is stored. Generating (Step 4604) 0
• step 460 1 and step 4603 can be executed independently (in some cases, they can be executed in parallel), while step 460 2 and step 4604 are executed collectively. be able to. Therefore, as shown in FIG. 46 (b), the import processing includes processing relating to the subscript conversion array of the pointer array (step 4611: corresponding to step 4603 in FIG. 46 (a)), and adding the value list. It can be considered to consist of processing relating to the character conversion array (step 4612: corresponding to step 4601) and processing relating to the value conversion of the pointer array (step 4613: corresponding to steps 4602 and 4604).
• the processing in step 4611 results in a pointer array to the value list consisting of an end position array and an offset array.
• a subscript conversion array see reference numeral 4701
• an entity array see reference numeral 4702
• the elements should be inserted in the i-th row by scanning this element. If it is determined that there is a subscript conversion array consisting of the end position array and offset array (see reference numeral 4703), and it should be inserted at the end by the processing of step 4612 It can be seen that an entity array (see reference numeral 4704) in which the elements (item values) are arranged is obtained.
• the subscript conversion array uses the offset value “0” if the subscript (record number) “p” is 0 ⁇ p ⁇ (j—1).
• the subscript conversion array adds the offset value “0” when the input subscript (output of the pointer array) “q” is 0 ⁇ qi ⁇ 1), and adds ⁇ If q ⁇ i (that is, q 2 i), add the offset value "n-i", or if (i + 1) ⁇ q ⁇ n, add the offset value "1 1" Means that.
• the value of the point value added to the end of the entity array of the value list (that is, the value of the boy at the position “m” in the entity array added with the record number insertion process) is: It is considered to be "n". This is because, in the actual array of the pointer array before the insertion processing, any value from “0” to “n ⁇ 1” can be taken, and the point value “n” is given by the insertion processing. Therefore, in order for this point value “n” to point to the apparent (logical) insertion point “i” in the value list by value conversion, the offset value must be set to “i-1 n”. I understand that it is good.
• the offset value should be given by value conversion so that the value is converted to "i".
• the record is deleted by processing the record number list without processing the information block of “member last name” and “member name”. More specifically, as shown in Fig. 42, a deletion process is performed on the subscript conversion array of the record number list, and a logical output in a form in which the original record number "1" is deleted I try to make. As shown in FIG. 42 (a), the relationship between the subscript input and the record number output in the record number list is as shown by reference numeral 4201. Therefore, CPU 12 executes the processing shown in FIG. 17 to delete the first row (second row). More specifically, the deletion position (in this case, the first row) is identified (step 1701), and then a region of the conversion array relating to the deletion position is generated (step 1702).
• a predetermined process is executed for the element of (see Steps 1703 to 1707; however, in this example, the process for the start array is not executed.)
• a subscript conversion array (see reference numeral 420) as shown in FIG. 42 (b) is obtained.
• the relationship between the input and output is as shown by reference numeral 421, and logically the record number "1" is deleted, and the record numbers below it are changed one by one. It can be seen that the shifted state has been realized.
• the record number can be deleted and shifted virtually (logically), and therefore, the record can be deleted by a very simple method. It is possible to do.
• FIG. 43 is a flowchart showing the transaction processing. This process is illustrated in Figure 1.
• CPU 12 Also, it is assumed that a process (for example, a process shown in FIG. 6) for converting tabular data into a form of an aggregate of a plurality of information blocks has been executed in advance.
• the CPU 12 first assigns an initial conversion array to all information blocks involved in the transaction processing (step 4301). For example, in the record number list, an initial subscript conversion array for the record number array (substance array) is generated, or in the pointer array to the value list of a certain information block, the pointer array entity is used. An initial subscript conversion array and a value conversion array for the array are generated, and an initial subscript conversion array for the entity array (actual value list) is generated in the value list of the information block.
• the CPU 12 executes a predetermined transaction process (step 4302).
• a predetermined transaction process if it is necessary to insert, delete, or update a record, update the subscript conversion array or value conversion array as described above, and if necessary, use the entity array. Insert an element at the end of (or create a difference array in another area). For example, when an instruction is given to the user by an operation or the like (Yes in step 4303, the CPU 12 discards all the existing conversion arrays at that time (step 43) 0 4).
• the CPU 12 commits the processing (step 4304).
• the CPU 12 may discard each conversion array, or return the state of each conversion array to that of the initial conversion array generated in step 4301, and so on. This process may be configured to pass through the conversion array in this state. Also, other processes may use this in the state of the conversion array at the end of processing. Furthermore, the conversion arrays may be maintained so that they can be used as needed.
• one process involves updating data (for example, withdrawing 10,000 yen from an account), while another process refers to a tabular database. (For example, the process of obtaining the total balance of deposits in each account).
• the update process uses the subscript conversion array and the value conversion array to delete and insert records (see the solid arrow in FIG. 44).
• the “reference process”) refers to the entity array directly without referring to the subscript conversion array or the value conversion array (see the broken arrow in FIG. 44), so that multiple processes can be performed in parallel. Even if it is executed, the processing can be performed properly without interference.
• FIG. 45 is a diagram for explaining record locking.
• a lock management information block (reference number 4501) is provided, and a pointer array (reference number 4500) in which the number of record number elements can be arranged in the information block. 2) is provided.
• This pointer array stores “NON” for read / write disabled, “R” for read-only (cannot be updated or deleted), “RW” for read / write, etc. as elements (stored values). I have.
• the program locks the record in the join table. In effect, it locks the corresponding record in the original table.
• the lock can be propagated to the join table, so that the join table can be made rewritable.
• the present invention is not limited to the insertion, deletion, and update of data in tabular data constructed by a set of a plurality of information blocks as in the fifth to seventh embodiments.
• a structure consisting of a record number (see code 4901) and a character string such as last name (4 characters), first name (4 characters), address (20 characters), etc. It is also possible to insert, delete, and update data relating to tabular data in a form in which is associated with.
• a set of structure arrays consisting of names, addresses, etc.
• the record numbers are considered as subscripts, and a process almost equivalent to that shown in Fig. 13 is executed, good.
• a set of structure arrays may be considered as an actual array, and a record number may be considered as a subscript, and processing substantially equivalent to that shown in FIG. 17 may be performed.
• the value conversion array according to the present invention can be used alone. For example, consider a case where 100 million samples of measurement data are sequentially supplied from a D / A converter (not shown). Normally, it is not easy to store 100 million samples of data in one memory (for example, even if 2 bytes / 1 sample, 200 million bytes (100 Mbytes or more) of data capacity) However, consider dividing this into 10 memories and storing them. In Figure 50, the first (No. 0) memory block 50,000 to the last (No. 9) memory block 509, each with 1,000,000 measurement data (sample data) Is housed.
• the logical accumulated value corresponding to the final address in the memory block adjacent to the upper part of the memory block is extracted, and this is the offset value in the offset array in the value conversion array of the memory block.
• the offset value is Z (9, 999, 999) (where z is a logically accumulated value).
• the logical accumulated value Z (19, 999, 999) are required. It will be understood that the accumulated value Z (19, 999, 999) is an offset value used in the lower adjacent memory block.
• the accumulated value of each memory block is calculated. It takes 10 million steps to find it, and about 9 steps to set the additive offset value. On the other hand, it can be understood that 100 million steps are required to obtain the accumulated value using the conventional method. This is because even if a memory block is divided, the accumulated value of the higher-order memory block is calculated and the accumulation for the memory block can be started for the first time. Is virtually impossible. As described above, by using the value conversion array of the present invention, it is possible to increase the speed of scientific and technological calculations and the like. Further, according to the present invention, it is possible to adopt a nest structure as shown in FIG. In Fig.
• the nest located at the innermost side is provided with a subscript conversion array (see reference numeral 5101), a substantive array (see reference numeral 5102), and a value conversion array (reference numeral 5103).
• a subscript conversion array see reference numeral 5101
• a substantive array see reference numeral 5102
• a value conversion array reference numeral 5103
• the set consisting of the subscript conversion array, the entity array, and the value conversion array is considered as a second entity array (see reference numeral 5112)
• the input side A subscript conversion array (see reference numeral 5111) is placed on the output side, and a value conversion array (see reference numeral 5113) is placed on the output side.
• the inner nest is considered as the third entity array (see reference numeral 5122), and the subscript conversion array (see reference numeral 51211) is provided at the input side. And a value conversion array (see reference numeral 521) at the output side.
• the item value in the value list, is placed at the end of the entity array, but it is limited to such a configuration. Not something. That is, regarding the pointer array to the value list, the pointer value may be arranged in another area (difference array) without being adjacent to the actual array, or the pointer value f (m) may be assigned to another area. The value may be set to “y” (however, yn).
• the item values may be arranged in another area (differential array) without being adjacent to the actual array.
• the data update process in the tabular format in the form of an information block includes an insertion process and a deletion process or a deletion process and an update process in order.
• a subscript conversion array and a value conversion array can be obtained as follows.
• a predetermined program is read into the general computer system 10 and the program is executed, thereby realizing processes such as generation and update of the attachment conversion array and the value conversion array.
• the present invention is not limited to this.
• a board combination dedicated to data base processing is connected to a general computer system such as a personal computer, and the board computer is connected to the computer.
• the configuration may be such that the above processing can be executed. Therefore, in this specification, means means necessarily physical means. However, it also includes the case where the function of each means is realized by software. Further, the function of one means may be realized by two or more physical means, or the function of two or more means may be realized by one physical means.
• the present invention can be used particularly for a system for managing a large amount of data, for example, a database and a data warehouse. More specifically, it can be used for large-scale scientific and technical calculations, order management, core business management such as securities transactions, and business administration.

Landscapes

• Engineering & Computer Science (AREA)
• Databases & Information Systems (AREA)
• Theoretical Computer Science (AREA)
• Software Systems (AREA)
• Data Mining & Analysis (AREA)
• Physics & Mathematics (AREA)
• General Engineering & Computer Science (AREA)
• General Physics & Mathematics (AREA)
• Information Retrieval, Db Structures And Fs Structures Therefor (AREA)
• Digital Computer Display Output (AREA)

Priority Applications (3)

Applications Claiming Priority (2)

Publications (1)

Family

ID=16672576

Family Applications (1)

Country Status (7)

Cited By (2)

Families Citing this family (19)

Family Cites Families (13)

• 1999
  • 1999-07-29 JP JP21545099A patent/JP4425377B2/ja not_active Expired - Lifetime
• 2000
  • 2000-07-31 KR KR1020027001281A patent/KR100787079B1/ko not_active Expired - Fee Related
  • 2000-07-31 CN CNB008125716A patent/CN1310173C/zh not_active Expired - Fee Related
  • 2000-07-31 US US10/048,231 patent/US6973467B1/en not_active Expired - Lifetime
  • 2000-07-31 CA CA002380565A patent/CA2380565A1/en not_active Abandoned
  • 2000-07-31 WO PCT/JP2000/005135 patent/WO2001009764A1/ja not_active Ceased
  • 2000-07-31 EP EP00948339A patent/EP1213663A4/en not_active Withdrawn

Non-Patent Citations (4)

Also Published As

Similar Documents

Legal Events