KR101693108B1 - Database read method and apparatus using t-tree index for improving read performance - Google Patents
Database read method and apparatus using t-tree index for improving read performance Download PDFInfo
- Publication number
- KR101693108B1 KR101693108B1 KR1020150056598A KR20150056598A KR101693108B1 KR 101693108 B1 KR101693108 B1 KR 101693108B1 KR 1020150056598 A KR1020150056598 A KR 1020150056598A KR 20150056598 A KR20150056598 A KR 20150056598A KR 101693108 B1 KR101693108 B1 KR 101693108B1
- Authority
- KR
- South Korea
- Prior art keywords
- index
- requested data
- tree
- key
- data
- Prior art date
Links
Images
Classifications
-
- G06F17/30327—
-
- G06F17/30595—
-
- G06F17/30961—
Landscapes
- Information Retrieval, Db Structures And Fs Structures Therefor (AREA)
Abstract
A method and apparatus for reading a database using a T-tree index for improving read performance are disclosed. A method for reading a database using a T-tree index according to an exemplary embodiment of the present invention includes: searching a memory storage table (MemStore) to search for requested data when a read operation is requested from a client terminal; Retrieving an index of the requested data by searching a T-tree index formed in a memory area if the requested data does not exist in the memory storage table; And obtaining the location of the requested data using the searched index and reading the requested data via the HFile of the obtained location.
Description
The present invention relates to a database reading method and a database reading method and apparatus using a T-tree index capable of improving a reading performance of a database, for example, HBase using a T-tree index structure.
Due to the popularity of the Internet, smartphones, and the proliferation of social network services, a large amount of data is produced every day, and this data is called big data. Recently, various big data processing techniques for storing / managing big data and analyzing them have been actively studied and applied to real life.
Conventional relational database management systems (RDBMSs) need to provide scalability to store big data, but there are difficulties with repository management and cost problems. In recent years, less formal databases of NoSQL databases have been increasingly used compared to relational databases. Typically, Google has released a big-table storage technique to efficiently process large amounts of data, and HBase, a big-table-based open source NoSQL database, is widely used.
HBase, which is a representative NoSQL database, uses Hadoop Distributed File System (HDFS) for storing data and massively generates HFile, which is a persistent storage file, only by sequential writing to improve write performance. HBase temporarily stores the data in the memory when the data is inserted. When the memory becomes full, the HBase stores data on the disk through batch writing. Since the HFiles stored in HDFS can not be updated, the number continues to accumulate until the merging operation called Compaction is performed.
The HBase read operation searches all the HFiles of the region that contains the key to be searched. That is, the read performance of the HBase is not better than that of the optimized write because the read operation has to be performed in the HDFS as many as the number of the HFile. In particular, the deterioration of the read performance becomes worse as the amount of data increases.
Therefore, there is a need for a method to improve the read performance of HBase.
Embodiments of the present invention provide a database reading method and apparatus using a T-tree index capable of improving reading performance of a database by summarizing and managing keys for HFile.
Embodiments of the present invention utilize a T-tree index structure to reduce access to stored HFiles for each region of the HBase and improve the search performance by reducing the time required to read data by creating indexes on the stored data And a method for reading the database using the T-tree index.
Embodiments of the present invention provide a T-tree index structure that summarizes and manages keys for a plurality of distributed HFiles.
A method for reading a database using a T-tree index according to an exemplary embodiment of the present invention includes: searching a memory storage table (MemStore) to search for requested data when a read operation is requested from a client terminal; Retrieving an index of the requested data by searching a T-tree index formed in a memory area if the requested data does not exist in the memory storage table; And obtaining the location of the requested data using the searched index and reading the requested data via the HFile of the obtained location.
The T-tree index summarizes the key and generates summarized key information to distinguish the data of the key / value format stored in the HFile, and maps the generated summarized key information to the mapping of the actual key corresponding to the summarized key An information mapping table may be formed in the memory area and formed by the formed mapping table and the T-tree.
The step of retrieving the index for the requested data may include obtaining summary key information corresponding to the requested data from the mapping table and searching the index of the T-tree index through the obtained summary key information .
The searching of the index for the requested data may include obtaining an index for the requested data using the mapping table, comparing the obtained index with an offset constituting the T-tree index, And retrieve the obtained index from the tree index.
The reading of the requested data may include obtaining location information of the HFile corresponding to the searched index from location information of the HFile according to the index stored in advance in the disk area and reading the requested data using the obtained location information .
A method of generating a T-tree index according to an exemplary embodiment of the present invention is a method of generating a T-tree index of a database, comprising the steps of: summarizing a key to generate summarized key information to distinguish key / value format data stored in HFile step; Forming a mapping table in the memory area including the generated summary key information and mapping information of the actual key corresponding to the abstracted key; And generating a T-tree index in the memory area using the formed mapping table and the T-tree.
Wherein the step of forming the mapping table in the memory area includes a first mapping table including map information on the row key and a mapping table including map information on the column, Two mapping tables can be formed.
Each index included in the T-tree index may be composed of a combination of a row key, a column, and a file pointer.
In addition, the method of generating a T-tree index according to an embodiment of the present invention stores the frequency of each index included in the T-tree index, and when the stored frequency is smaller than a predetermined reference frequency, In the step of FIG.
Furthermore, the method of generating a T-tree index according to an embodiment of the present invention may further include updating an index included in the T-tree index when a HFile including a division of a compaction and a region is changed have.
A database reading apparatus using a T-tree index according to an embodiment of the present invention includes a receiving unit for receiving a read operation request from a client terminal; Searches the memory storage table (MemStore) according to the read operation request to search for requested data, and if the requested data does not exist in the memory storage table, searches the T-tree index formed in the memory area, A search unit for searching an index for data; And a reading unit that obtains the position of the requested data using the searched index, and reads the requested data through the HFile of the obtained position.
The T-tree index summarizes the key and generates summarized key information to distinguish the data of the key / value format stored in the HFile, and maps the generated summarized key information to the mapping of the actual key corresponding to the summarized key An information mapping table may be formed in the memory area and formed by the formed mapping table and the T-tree.
The searching unit may obtain the summarized key information corresponding to the requested data from the mapping table and search the index of the T-tree index through the obtained summarized key information.
The searching unit obtains an index of the requested data using the mapping table, compares the obtained index with an offset constituting the T-tree index, and searches the acquired index in the T-tree index can do.
The reading unit may obtain positional information of the HFile corresponding to the searched index from the position information of the HFile according to the index previously stored in the disk area, and may read the requested data using the obtained positional information.
Embodiments of the present invention can improve the read performance of the database by summarizing and managing keys for HFile.
Embodiments of the present invention utilize a T-tree index structure to reduce access to stored HFiles for each region of the HBase and improve the search performance by reducing the time required to read data by creating indexes on the stored data .
Embodiments of the present invention can prevent a load from being generated in the memory by deleting the index having a low frequency among the indexes stored in the memory area.
FIG. 1 illustrates an example of a database reading method according to an embodiment of the present invention. Referring to FIG.
FIG. 2 shows an example for explaining a T-tree index structure.
3 is a flowchart illustrating an operation of a database reading method according to an embodiment of the present invention.
FIG. 4 illustrates an example of a reading process of FIG. 3. Referring to FIG.
5 shows an example of a reading performance according to the present invention.
FIG. 6 is a flowchart illustrating a method of managing a T-tree index according to an exemplary embodiment of the present invention.
FIG. 7 shows a configuration of a database reading apparatus according to an embodiment of the present invention.
Hereinafter, embodiments according to the present invention will be described in detail with reference to the accompanying drawings. However, the present invention is not limited to or limited by the embodiments. In addition, the same reference numerals shown in the drawings denote the same members.
The present invention uses a T-tree index structure for summarizing and managing keys for a plurality of distributed HFiles to reduce the access to HFiles stored in each region of HBase and reduce the time required to read data, And the improvement is achieved.
FIG. 1 illustrates an example of a database reading method according to an embodiment of the present invention. Referring to FIG.
As shown in FIG. 1, HBase stores and manages data in the form of a table through HDFS, and the table is divided based on sorted keys and distributed in various regions in a region server. In each region, a memory storage table (MemStore) formed in the memory area for temporarily storing the inserted data, an IStore storing an index for the HFiles formed in the memory area, HFiles stored in the HDFS, And IFile for restoration of IStore.
Here, IStore includes an mapping table which includes summarized key information and mapping information of an actual key corresponding to the summarized key in order to distinguish data of the key / value format stored in the HFile, -Tree index structure formed by using a tree.
IStore uses memory-optimized T-trees to construct and use indexes in memory, as shown in FIG. 2, and uses row keys and columns to simplify the tree keys. The mapping table is managed by two mapping tables. Each node in the T-tree index structure consists of one parent node pointer, two child node pointers, and a plurality of data (row key ID, column ID, file pointer). For example, each node has a subtree (a tree corresponding to a left child pointer), which is a tree of data smaller than an offset of data, and a subtree (a tree corresponding to a right child pointer), which is a tree of large data I have. The T-tree index search operation can search the index of the requested data in the T-tree index by comparing the smallest offset and the largest offset of the data at the current node with the index to be searched.
It saves memory space by keeping the key summary summarized in the mapping table and the mapping information of the actual key to find the data. Because the key must be a value that can distinguish each data, the length is long, so if you have a key for each node, the space efficiency becomes low. The present invention summarizes keys for space saving. The key information consists of a row key and a column. The two values are not only a unit for separating the data of the HFile but also are different from each other, so they are maintained differently. Since the row key enters a certain range of values into the region, it is kept in the mapping table in the form of a range of values, and the column is determined by the sum of the two values of the column family and the column qualifier when the HBase table is created. To the mapping table. And version control is possible without storing version information in the key sequentially by storing different version of data with the same key in the IFile.
In order to directly access HFile with index, position of HFile, offset information of data stored in HFile, and size information of data are needed. Since it takes a lot of capacity to store all of the information, the location information of the data can be stored in the IFile in the distributed storage system. IFile also needs to read HDFS but it is more efficient than existing system because it searches only one file without searching the block index inside the whole HFile.
Also, since there is a memory limitation for IStore to maintain all index information, index information having a small frequency can be deleted from IStore. That is, if the stored frequency is smaller than a predetermined reference frequency, the corresponding index can be deleted, and the deletion of the index according to the frequency can be performed on a predetermined time basis or at a predetermined time. This is because the number of indexes according to the frequency is required to reduce the memory usage due to a large amount of data. Therefore, the index information that is not found by storing the frequency of each index is removed from the memory. If a read request is received for the index information removed by the frequency, and the IStore can not find it, the index information of the IFtile can be found by storing the index tree of the IStore in the stored IFile.
Further, the information of the IStore can continuously update the index information of the data. However, if the index is updated every time a write request is received, the speed is lowered. Therefore, in the case of the latest information, it is maintained in MemStore and only the data of the HFile is indexed so that the update is prevented from occurring frequently. For example, IStore can update the index when the HFile changes, such as compaction and division of the region. Here, the compaction performs the function of combining the HFiles. Since the positions of the HFiles and the data are changed as a whole, new IStore and IFile are generated. Without compaction, it is easier to find the data through the index, thus reducing compaction performance. In case of region division, one region is divided into two regions, and HFile is divided according to the range of the row key of region. Therefore, when region is newly generated, IStore can be generated to generate index information when dividing HFile .
IFile stores all information of IStore. It is basically used to locate data, but it can also store information from IStore for recovery of IStore in case of server failure. In this case, when the MemStore is flushed and the data is stored in the HFile as in the case of the IStore, the IFile is also newly generated, and the location of the data and the contents of the updated IStore can be stored.
A reading method for improving the read performance of the HBase using the T-tree index structure will be described with reference to FIGS. 3 and 4. FIG.
FIG. 3 is a flowchart illustrating an operation of a database reading method according to an embodiment of the present invention. FIG. 4 illustrates an example of a reading process of FIG.
Referring to FIGS. 3 and 4, in the database according to the present invention, for example, the HBase reading method performs a MemStore search (1) in which the latest data is stored when a read operation request is received from the client terminal (S310, S320).
If there is no request data in the MemStore, the index of the requested data is obtained from the row key mapping table and the column mapping table stored in the IStore (step S230) (S330, S340).
On the other hand, if the requested data exists in the MemStore as a result of the search in step S330, the requested data is read from the MemStore (S380).
If the index of the requested data is obtained in step S340, the index obtained in the T-tree index structure of the IStore is searched (3) (S350).
Herein, in step S350, the left tree or the right tree is determined by comparing the index obtained from the uppermost parent node of the T-tree index with the smallest offset and the greatest offset, and by repeating this process at the next node, The obtained index can be retrieved from the T-tree index structure.
The T-tree index according to the present invention summarizes the key to generate summarized key information to distinguish the data of the key / value format stored in the HFile as described above, and corresponds to the generated summarized key information and the summarized key A mapping table including mapping information of the actual key to be generated is formed in the memory area and formed using the formed mapping table and the T-tree.
When the index obtained in step S350 is retrieved, HFile location information of the requested data is obtained using the searched index (4), and the key / data of the requested data requested from the client terminal through the HFile (5) Value data is read (S360, S370).
Here, the step S360 may obtain the HFile location information of the requested data from the data block of the IFile using the searched index.
As described above, since the method according to the present invention performs the HBase reading function using the T-tree index, as in the example shown in FIG. 5, IStore (5%) indexed 5% It can be seen that the search time of IStore (10%) indexed 10% of the data is 8% and 15% faster than the search time of the entire data (HBase).
As described above, the database reading method according to the embodiment of the present invention can improve the reading performance of the database by summarizing and managing the keys for the HFile, and by using the T-tree index structure, the HFiles stored for each region of the HBase And improve the search performance by reducing the time required to read the data by indexing the stored data.
The process of creating and managing the above-described T-tree index structure will be described with reference to FIG.
FIG. 6 is a flowchart illustrating a method of managing a T-tree index according to an exemplary embodiment of the present invention.
Referring to FIG. 6, the T-tree index management method summarizes keys and generates summary key information to distinguish key / value format data stored in HFile (S610).
Here, the summarized key information may be composed of a row key and a column.
When the key information summarized in step S610 is generated, a mapping table including mapping information of the generated summary key and the actual key corresponding to the summarized key is formed in the memory area (S620).
At this time, the mapping table may include an mapping table including map information about the row key of the summarized key information and an mapping table including map information about the columns of the summarized key information.
The T-tree index structure is created in the memory area using the mapping table formed in step S620 and the T-tree structure (S630).
Here, each of the indexes included in the generated T-tree index may be composed of a combination of a row key, a column, and a file pointer.
When the T-tree index structure is created in step S630, the frequency is stored for each index stored in the IStore, and the frequency for each index stored in the IStore is compared with a predetermined reference frequency (S640, S650).
If it is determined in step S650 that the frequency is lower than the reference frequency, the index is deleted from the memory area (S660).
Here, by deleting the index having a low frequency by step S660, memory usage can be reduced.
Also, the index management method according to the present invention can update the index. For example, if the HFile including the compaction and the partitioning of the region is changed, the index included in the T-tree index or the index stored in the mapping table can be updated.
As described above, according to the index managing method according to the embodiment of the present invention, it is possible to prevent a load from being generated in the memory by deleting the index having a low frequency among the indexes stored in the memory area, - By creating a tree index structure, the reading function of the database can be improved.
FIG. 7 shows a configuration of a database reading apparatus according to an embodiment of the present invention.
7, a
The receiving
The
Here, the T-tree index summarizes the key to generate summarized key information to distinguish the data of the key / value format stored in the HFile, and generates the summarized key information and the mapping information of the actual key corresponding to the summarized key May be formed in a memory area and formed using a mapping table and a T-tree structure.
The searching
At this time, the
The
Here, the
The storage unit 740 includes both a memory area and an HDFS, and may include MemStore, IStore, HFile, and IFile. That is, the storage unit 740 stores all the data for performing the present invention.
The system or apparatus described above may be implemented as a hardware component, a software component, and / or a combination of hardware components and software components. For example, the systems, devices, and components described in the embodiments may be implemented in various forms such as, for example, a processor, a controller, an arithmetic logic unit (ALU), a digital signal processor, a microcomputer, a field programmable array ), A programmable logic unit (PLU), a microprocessor, or any other device capable of executing and responding to instructions. The processing device may execute an operating system (OS) and one or more software applications running on the operating system. The processing device may also access, store, manipulate, process, and generate data in response to execution of the software. For ease of understanding, the processing apparatus may be described as being used singly, but those skilled in the art will recognize that the processing apparatus may have a plurality of processing elements and / As shown in FIG. For example, the processing unit may comprise a plurality of processors or one processor and one controller. Other processing configurations are also possible, such as a parallel processor.
The software may include a computer program, code, instructions, or a combination of one or more of the foregoing, and may be configured to configure the processing device to operate as desired or to process it collectively or collectively Device can be commanded. The software and / or data may be in the form of any type of machine, component, physical device, virtual equipment, computer storage media, or device , Or may be permanently or temporarily embodied in a transmitted signal wave. The software may be distributed over a networked computer system and stored or executed in a distributed manner. The software and data may be stored on one or more computer readable recording media.
The method according to embodiments may be implemented in the form of a program instruction that may be executed through various computer means and recorded in a computer-readable medium. The computer-readable medium may include program instructions, data files, data structures, and the like, alone or in combination. The program instructions to be recorded on the medium may be those specially designed and configured for the embodiments or may be available to those skilled in the art of computer software. Examples of computer-readable media include magnetic media such as hard disks, floppy disks and magnetic tape; optical media such as CD-ROMs and DVDs; magnetic media such as floppy disks; Magneto-optical media, and hardware devices specifically configured to store and execute program instructions such as ROM, RAM, flash memory, and the like. Examples of program instructions include machine language code such as those produced by a compiler, as well as high-level language code that can be executed by a computer using an interpreter or the like. The hardware devices described above may be configured to operate as one or more software modules to perform the operations of the embodiments, and vice versa.
While the present invention has been particularly shown and described with reference to exemplary embodiments thereof, it is to be understood that the invention is not limited to the disclosed exemplary embodiments. For example, it is to be understood that the techniques described may be performed in a different order than the described methods, and / or that components of the described systems, structures, devices, circuits, Lt; / RTI > or equivalents, even if it is replaced or replaced.
Therefore, other implementations, other embodiments, and equivalents to the claims are also within the scope of the following claims.
Claims (15)
Retrieving an index of the requested data by searching a T-tree index formed in a memory area if the requested data does not exist in the memory storage table; And
Obtaining the position of the requested data using the searched index, and reading the requested data through the HFile of the obtained position
Lt; / RTI >
The T-tree index
A mapping table summarizing the keys and generating summarized key information to distinguish the data of the key / value format stored in the HFile, and mapping information of the generated summary key information and the actual key corresponding to the summarized key, Tree index formed by the formed mapping table and the T-tree in the memory area.
The step of retrieving an index for the requested data
Tree index that obtains summary key information corresponding to the requested data from the mapping table and searches the index of the T-tree index through the obtained summary key information.
The step of retrieving an index for the requested data
Tree index to obtain an index for the requested data by using the mapping table, and comparing the obtained index with an offset constituting the T-tree index, How to read a database using tree indexes.
Retrieving an index of the requested data by searching a T-tree index formed in a memory area if the requested data does not exist in the memory storage table; And
Obtaining the position of the requested data using the searched index, and reading the requested data through the HFile of the obtained position
Lt; / RTI >
The step of reading the requested data
Acquiring location information of an HFile corresponding to the searched index from location information of HFile according to an index stored in advance in a disk area and reading the database using a T-tree index that reads the requested data using the obtained location information Way.
Generating summary key information by summarizing keys to distinguish key / value format data stored in HFile;
Forming a mapping table in the memory area including the generated summary key information and mapping information of the actual key corresponding to the abstracted key; And
Generating a T-tree index in the memory area using the formed mapping table and the T-tree;
And managing the T-tree index.
The summarized key information
A row key and a column,
The step of forming the mapping table in the memory area
A first mapping table including mapping information for the row key and a second mapping table including mapping information for the column are formed.
Each of the indices included in the T-tree index
A method of managing a T-tree index comprising a combination of a row key, a column, and a file pointer.
Storing a frequency of each index included in the T-tree index, and deleting the index in the memory area when the stored frequency is smaller than a predetermined reference frequency
Further comprising the steps of:
Updating the index included in the T-tree index when the HFile including the division of the compaction and the region is changed
Further comprising the steps of:
Searches the memory storage table (MemStore) according to the read operation request to search for requested data, and if the requested data does not exist in the memory storage table, searches the T-tree index formed in the memory area, A search unit for searching an index for data; And
Acquiring a location of the requested data using the searched index, and reading the requested data through an HFile of the acquired location,
Lt; / RTI >
The T-tree index
A mapping table summarizing the keys and generating summarized key information to distinguish the data of the key / value format stored in the HFile, and mapping information of the generated summary key information and the actual key corresponding to the summarized key, Tree index formed by the formed mapping table and the T-tree.
The search unit
Tree index to obtain summarized key information corresponding to the requested data from the mapping table and to retrieve an index of the T-tree index through the obtained summarized key information.
The search unit
Tree index to obtain an index for the requested data by using the mapping table, and comparing the obtained index with an offset constituting the T-tree index, Database reading device using tree index.
Searches the memory storage table (MemStore) according to the read operation request to search for requested data, and if the requested data does not exist in the memory storage table, searches the T-tree index formed in the memory area, A search unit for searching an index for data; And
Acquiring a location of the requested data using the searched index, and reading the requested data through an HFile of the acquired location,
Lt; / RTI >
The reading unit
Acquiring location information of an HFile corresponding to the searched index from location information of HFile according to an index stored in advance in a disk area and reading the database using a T-tree index that reads the requested data using the obtained location information Device.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| KR1020150056598A KR101693108B1 (en) | 2015-04-22 | 2015-04-22 | Database read method and apparatus using t-tree index for improving read performance |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| KR1020150056598A KR101693108B1 (en) | 2015-04-22 | 2015-04-22 | Database read method and apparatus using t-tree index for improving read performance |
Publications (2)
| Publication Number | Publication Date |
|---|---|
| KR20160126148A KR20160126148A (en) | 2016-11-02 |
| KR101693108B1 true KR101693108B1 (en) | 2017-01-05 |
Family
ID=57518540
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| KR1020150056598A KR101693108B1 (en) | 2015-04-22 | 2015-04-22 | Database read method and apparatus using t-tree index for improving read performance |
Country Status (1)
| Country | Link |
|---|---|
| KR (1) | KR101693108B1 (en) |
Cited By (1)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN108319725A (en) * | 2018-02-28 | 2018-07-24 | 武汉珞珈弘禹工程技术有限公司 | A kind of method and system of hydrologic monitoring data storage |
Families Citing this family (2)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN108153805A (en) * | 2017-11-17 | 2018-06-12 | 广东睿江云计算股份有限公司 | A kind of method, the system of efficient cleaning Hbase time series datas |
| CN112612805B (en) * | 2020-12-24 | 2023-12-22 | 北京浪潮数据技术有限公司 | Method for indexing hbase data to query engine and related device |
Family Cites Families (2)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| KR100414052B1 (en) * | 2000-10-14 | 2004-01-07 | 엘지전자 주식회사 | Index data management method for main memory database |
| KR101621385B1 (en) * | 2012-10-11 | 2016-05-18 | 주식회사 케이티 | System and method for searching file in cloud storage service, and method for controlling file therein |
-
2015
- 2015-04-22 KR KR1020150056598A patent/KR101693108B1/en active IP Right Grant
Cited By (1)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN108319725A (en) * | 2018-02-28 | 2018-07-24 | 武汉珞珈弘禹工程技术有限公司 | A kind of method and system of hydrologic monitoring data storage |
Also Published As
| Publication number | Publication date |
|---|---|
| KR20160126148A (en) | 2016-11-02 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| US11182356B2 (en) | Indexing for evolving large-scale datasets in multi-master hybrid transactional and analytical processing systems | |
| US10114908B2 (en) | Hybrid table implementation by using buffer pool as permanent in-memory storage for memory-resident data | |
| US10783115B2 (en) | Dividing a dataset into sub-datasets having a subset of values of an attribute of the dataset | |
| US8832050B2 (en) | Validation of distributed balanced trees | |
| US8719237B2 (en) | Method and apparatus for deleting duplicate data | |
| US8938430B2 (en) | Intelligent data archiving | |
| US9495398B2 (en) | Index for hybrid database | |
| US20200004851A1 (en) | Trie-based indices for databases | |
| US9594674B1 (en) | Method and system for garbage collection of data storage systems using live segment records | |
| US10678784B2 (en) | Dynamic column synopsis for analytical databases | |
| WO2018133762A1 (en) | File merging method and apparatus | |
| CN110807028B (en) | Method, apparatus and computer program product for managing a storage system | |
| KR101693108B1 (en) | Database read method and apparatus using t-tree index for improving read performance | |
| US20180075074A1 (en) | Apparatus and method to correct index tree data added to existing index tree data | |
| US20220342888A1 (en) | Object tagging | |
| US10572452B1 (en) | Context-based read-ahead for B+ tree data structures in a deduplication system | |
| US10698865B2 (en) | Management of B-tree leaf nodes with variable size values | |
| KR102354343B1 (en) | Spatial indexing method and apparatus for blockchain-based geospatial data | |
| CN110968649B (en) | Method, apparatus and computer program product for managing data sets | |
| US11132266B2 (en) | Method, device, and computer program product for managing application system | |
| JP5953262B2 (en) | DATA INDEX DEVICE, DATA INDEX METHOD, AND PROGRAM | |
| US11481372B1 (en) | Systems and methods for indexing multi-versioned data | |
| US10402452B1 (en) | Distributed hash table based logging service | |
| CN109643303B (en) | Data processing apparatus and data processing method |
Legal Events
| Date | Code | Title | Description |
|---|---|---|---|
| A201 | Request for examination | ||
| E701 | Decision to grant or registration of patent right | ||
| GRNT | Written decision to grant | ||
| FPAY | Annual fee payment |
Payment date: 20191001 Year of fee payment: 4 |