Method and system for directly querying index data by using piggyback method in nosql environment

Abstract

Disclosed are a method and system for directly querying index data by using a piggyback method in a NoSQL environment. The method for querying index data, according to an embodiment, may comprise the steps of: adding, to a first scan object including an index filter for scanning an index row, a second scan object to be used when data is acquired and a logic predefined for generating a data row key; transmitting, to a server, an index row scan request including the first scan object to which the second scan object and the logic have been added; and receiving, from the server, an index scanned by the server through the index filter according to the index row scan request, and data scanned by the server through the second scan object and the logic.

Description

A method and system for directly querying index data using a piggyback method in a NOSQL environment.

[0001] The description below is about a method and system for directly querying index data using a piggyback method in a NoSQL (Not Only SQL) environment.

[0002] NoSQL (Not Only SQL) databases like HBase don't support secondary indexes. Therefore, if users want to construct and query secondary indexes for their data, additional methods are required.

[0003] First, you can use installed OLTP (On-Line Transaction Processing) solutions such as Apache Phoenix, but in a data platform that must dynamically have various schemas according to the diverse data of a large number of users, managing and processing operation forms that fit all data types and schemas on the server side significantly increases complexity and affects performance, making it difficult to apply.

[0004] To overcome these problems, the system is designed so that data properties are not managed on the server side, and as a result, data and index schemas are managed separately on the client side.

[0005] However, in this environment, since the index lookup process is performed on the client side, the index and data are sequentially looked up from the client to the server, which increases the lookup cost.

[0006] We provide a method and system for directly querying index data using a piggyback method in a NoSQL (Not Only SQL) environment.

[0007] A method for retrieving index data of a computer device including at least one processor, the method comprising: adding, by the at least one processor, a second scan object for use in acquiring data and a predefined logic for generating a data row key to a first scan object including an index filter for scanning an index row; transmitting, to a server, an index row scan request including the second scan object and the first scan object to which the logic is added; and receiving, from the server, an index scanned by the server through the index filter according to the index row scan request, the second scan object, and data scanned by the server through the logic.

[0008] According to one aspect, the adding step may be characterized by adding the second scan object and the logic as properties of the first scan object to the first scan object.

[0009] According to another aspect, the low key of the data in the server may be changed to the low key of the index, and the receiving step may be characterized by receiving data whose low key has been changed to the low key of the index.

[0010] According to another aspect, the second scan object may include a data filter, and a data row key is generated through the index and the logic in the server, and a data scan result including the data is generated through the data row key and the data filter.

[0011] According to another aspect, a custom filter including the index filter, the second scan object, and the logic may be set in the server, and the scanning of the index, generation of the data row key, and generation of the data scan result may be processed in the server using the set custom filter.

[0012] A method for retrieving index data of a computer device including at least one processor, the method comprising: receiving, by the at least one processor, an index row scan request including a first scan object from a client, the first scan object including an index filter for scanning an index row, a second scan object for use in acquiring data, and logic predefined for generating a data row key; scanning, by the at least one processor, an index through the index filter; generating, by the at least one processor, a data row key using the logic and the scanned index; scanning, by the at least one processor, data using the data filter included in the second scan object and the data row key; and transmitting, by the at least one processor, the scanned data to the client.

[0013] According to one aspect, the transmitting step may be characterized by changing the row key of the scanned data included in the scanned data to the row key of the scanned index and transmitting the data with the changed row key to the client.

[0014] According to another aspect, the second scan object and the logic may be characterized in that they are added to the first scan object as properties of the first scan object.

[0015] According to another aspect, the method for retrieving index data may further include a step of setting a custom filter including the index filter, the second scan object, and the logic by the at least one processor, and the step of scanning the index, the step of generating the data row key, and the step of scanning the data may be characterized in that they are processed using the set custom filter.

[0016] According to another aspect, the computer device may be characterized in that it is linked to a NoSQL (Not Only SQL) database, and the index and the data are scanned from the NoSQL database.

[0017] A computer program stored on a computer-readable recording medium is provided for executing the above method on a computer device in combination with a computer device.

[0018] A computer-readable recording medium having recorded thereon a program for executing the above method on a computer device is provided.

[0019] A computer device comprising at least one processor configured to execute instructions readable from a computer device, wherein the computer device receives, by the at least one processor, an index row scan request including a first scan object from a client, the first scan object including an index filter for scanning an index row, a second scan object for use in acquiring data, and a logic defined for generating a data row key, scans an index through the index filter, generates a data row key using the logic and the scanned index, scans data using the data filter and the data row key included in the second scan object, and transmits the scanned data to the client.

[0020] In a NoSQL (Not Only SQL) environment, a method and system for directly querying index data can be provided by utilizing the piggyback method.

[0021] FIG. 1 is a diagram illustrating an example of a network environment according to one embodiment of the present invention.

[0022] FIG. 2 is a block diagram illustrating an example of a computer device according to one embodiment of the present invention.

[0023] Figure 3 is a diagram illustrating an example of a process of sequentially searching an index and data in the prior art.

[0024] FIG. 4 is a diagram illustrating an example of a process for searching an index and data at the same time in one embodiment of the present invention.

[0025] FIG. 5 and FIG. 6 are drawings for explaining an example of a process for searching an index and data at the same time in one embodiment of the present invention.

[0026] FIG. 7 is a flowchart illustrating an example of an index data search method according to one embodiment of the present invention.

[0027] FIG. 8 is a flowchart illustrating another example of an index data search method according to one embodiment of the present invention.

[0028] Hereinafter, the detailed description will be given with reference to the attached drawings.

[0029] An index data retrieval system according to embodiments of the present invention may be implemented by at least one computer device. In this case, a computer program according to an embodiment of the present invention may be installed and run on the computer device, and the computer device may perform the index data retrieval method according to embodiments of the present invention under the control of the run computer program. The above-described computer program may be stored on a computer-readable recording medium so as to be coupled to the computer device and cause the computer to execute the index data retrieval method.

[0030] FIG. 1 is a diagram illustrating an example of a network environment according to an embodiment of the present invention. The network environment of FIG. 1 represents an example including a plurality of electronic devices (110, 120, 130, 140), a plurality of servers (150, 160), and a network (170). FIG. 1 is merely an example for explaining the invention, and the number of electronic devices or servers is not limited to that of FIG. 1. In addition, the network environment of FIG. 1 merely illustrates one example of environments applicable to the present embodiments, and the environments applicable to the present embodiments are not limited to the network environment of FIG. 1.

[0031] The plurality of electronic devices (110, 120, 130, 140) may be fixed terminals or mobile terminals implemented as computer devices. Examples of the plurality of electronic devices (110, 120, 130, 140) include smart phones, mobile phones, navigation systems, computers, laptops, digital broadcasting terminals, PDAs (Personal Digital Assistants), PMPs (Portable Multimedia Players), tablet PCs, etc. For example, in FIG. 1, the shape of a smart phone is shown as an example of the electronic device (110), but in embodiments of the present invention, the electronic device (110) may actually mean one of various physical computer devices that can communicate with other electronic devices (120, 130, 140) and / or servers (150, 160) via a network (170) using a wireless or wired communication method.

[0032] The communication method is not limited, and may include not only a communication method that utilizes a communication network (e.g., a mobile communication network, a wired Internet, a wireless Internet, a broadcasting network) that the network (170) may include, but also short-range wireless communication between devices. For example, the network (170) may include any one or more of a personal area network (PAN), a local area network (LAN), a campus area network (CAN), a metropolitan area network (MAN), a wide area network (WAN), a broadband network (BBN), the Internet, and the like. In addition, the network (170) may include any one or more of a network topology including, but not limited to, a bus network, a star network, a ring network, a mesh network, a star-bus network, a tree, or a hierarchical network.

[0033] Each server (150, 160) may be implemented as a computer device or multiple computer devices that communicate with multiple electronic devices (110, 120, 130, 140) via a network (170) to provide commands, codes, files, contents, services, etc. For example, the server (150) may be a system that provides services to multiple electronic devices (110, 120, 130, 140) connected via a network (170).

[0034] FIG. 2 is a block diagram illustrating an example of a computer device according to an embodiment of the present invention. Each of the plurality of electronic devices (110, 120, 130, 140) or servers (150, 160) described above can be implemented by the computer device (200) illustrated in FIG. 2.

[0035] Such a computer device (200) may include a memory (210), a processor (220), a communication interface (230), and an input / output interface (240), as illustrated in FIG. 2. The memory (210) may be a computer-readable recording medium, and may include a random access memory (RAM), a read only memory (ROM), and a non-permanent mass storage device such as a disk drive. Here, the non-permanent mass storage device such as a ROM and a disk drive may be included in the computer device (200) as a separate permanent storage device distinct from the memory (210). In addition, an operating system and at least one program code may be stored in the memory (210). These software components may be loaded into the memory (210) from a computer-readable recording medium separate from the memory (210). Such a separate computer-readable recording medium may include a computer-readable recording medium such as a floppy drive, a disk, a tape, a DVD / CD-ROM drive, a memory card, etc. In another embodiment, the software components may be loaded into the memory (210) via a communication interface (230) other than a computer-readable recording medium. For example, the software components may be loaded into the memory (210) of the computer device (200) based on a computer program installed by files received over a network (170).

[0036] The processor (220) may be configured to process instructions of a computer program by performing basic arithmetic, logic, and input / output operations. Instructions may be provided to the processor (220) via the memory (210) or the communication interface (230). For example, the processor (220) may be configured to execute instructions received according to program code stored in a storage device such as the memory (210).

[0037] The communication interface (230) may provide a function for the computer device (200) to communicate with other devices (e.g., the storage devices described above) via the network (170). For example, requests, commands, data, files, etc. generated by the processor (220) of the computer device (200) according to program codes stored in a recording device such as the memory (210) may be transmitted to other devices via the network (170) under the control of the communication interface (230). Conversely, signals, commands, data, files, etc. from other devices may be received by the computer device (200) via the communication interface (230) of the computer device (200) via the network (170). Signals, commands, data, etc. received via the communication interface (230) may be transmitted to the processor (220) or the memory (210), and files, etc. may be stored in a storage medium (the permanent storage device described above) that the computer device (200) may further include.

[0038] The input / output interface (240) may be a means for interfacing with an input / output device (250). For example, the input device may include a device such as a microphone, a keyboard, or a mouse, and the output device may include a device such as a display or a speaker. As another example, the input / output interface (240) may be a means for interfacing with a device that integrates input and output functions, such as a touchscreen. At least one of the input / output devices (250) may be configured as a single device with the computer device (200). For example, a touchscreen, a microphone, a speaker, etc. may be implemented in a form included in the computer device (200), such as a smartphone.

[0039] Additionally, in other embodiments, the computer device (200) may include fewer or more components than those illustrated in FIG. 2. However, it is not necessary to explicitly illustrate most conventional components. For example, the computer device (200) may be implemented to include at least some of the input / output devices (250) described above, or may further include other components such as a transceiver, a database, etc.

[0040] Figure 3 illustrates an example of a process for sequentially querying indexes and data in the prior art. As previously explained, NoSQL (Not Only SQL) databases do not support secondary indexes. Therefore, if a user wishes to construct and query a secondary index for data, the client must perform two queries to the region server.

[0041] For example, a client can first scan an index via a local server to retrieve index information, then combine the resulting values ​​with the data's schema to generate a row key ('rowkey') containing the data. The client then retrieves the data using the row key.

[0042] If data updates occur between these steps, additional indexes and data lookups may be required to maintain consistency.

[0043] This conventional client-server communication incurs high network costs and latency for users.

[0044] FIG. 4 is a diagram illustrating an example of a process for simultaneously retrieving an index and data in one embodiment of the present invention. In the embodiment of FIG. 4, when scanning an index, a client (410) simultaneously provides, in a piggyback format, information necessary for data retrieval and filter information for query and filtering for data retrieval to the server (420), and accordingly, the server (420) performs index and data retrieval.

[0045] In this method, the server (420) does not need to manage the schema and query of a large amount of diverse data, and the client (410) does not need to perform continuous queries through a time-consuming network. To this end, the server (420) can process the query logic according to one embodiment of the present invention using a coprocessor (Coprocessor, 421). The Coprocessor (421) can be implemented in the form of a software module of the server (420). For example, the Coprocessor (421) is an auxiliary processor that users can register on the Hbase side, and if registered in advance through the Hbase settings, it can be triggered and operated when a specific command (operation) is performed on the server (420).

[0046] FIGS. 5 and 6 are drawings illustrating examples of a process for simultaneously retrieving an index and data in one embodiment of the present invention.

[0047] In the case where the client (410) wants to scan an index row, the second scan object to be used when acquiring data and the logic to be used when generating a data row key can be piggybacked onto the first scan object as an attribute of the first scan object (user scan(); 'userScan') that includes an index filter "Filter(index)" for the index scan. In the embodiments of FIGS. 5 and 6, the second scan object to be used when acquiring data is represented as "Piggy-backed data scan" and the logic to be used when generating a row key is represented as "Data rowkey schema", respectively. The second scan object can include a data filter "Filter(data)" for the data scan.

[0048] The server (420) uses a coprocessor (Coprocessor (421)), and can set a custom filter "directIndexScanFilter" instead of the existing filter "userFilter" to apply a new query logic. For example, when a scan of an index row is requested from a client (410), the Hbase coprocessor (421) on the server (420) can receive a scan object to be used when acquiring data and a scan object in which the logic to be used for generating a data row key is piggybacked, and set a preset custom filter "directIndexScanFilter". Inside the set custom filter "directIndexScanFilter", filtering can be performed on the index scan result "Result(index)" obtained by scanning the index row, and the "filterRowCells" process to be described later can be included during this filtering process. In other words, after receiving Result(index), the "filterRowCells" process can be performed as a post-processing task.

[0049] The custom filter "directIndexScanFilter" set through the coprocessor (421) may include a scan object (Piggy-backed data scan, 'dataScan') passed for data retrieval, a filter object of userScan (Filter(index)), and schema information for generating a data row key ("Data rowkey schema").

[0050] There are three filters in the two scanners, userScan and dataScan: a custom filter "directIndexScanFilter", an index filter "Filter(index)", and a data filter "Filter(data)". In terms of structure, the userScan of the server (420) has a custom filter "directIndexScanFilter" and scans the index.

[0051] The existing filter "userFilter" exists inside the custom filter "directIndexScanFilter", and the existing filter "userFilter" can be adjusted in the custom filter "directIndexScanFilter" so that it is called at each stage of the filter during the index scan.

[0052] The process of retrieving data based on index information can be processed through the function "filterRowCell()" of the "filterRowCells" process within the custom filter "directIndexScanFilter" as shown in Fig. 6.

[0053] The coprocessor (421) can generate a data row key "data rowkey" by applying the schema "Data rowkey schema" for generating a data row key to the filterRowCells process of the existing filter "userFilter" (index scan result "Result(index)") using the function "filterRowCell()".

[0054] Additionally, the coprocessor (421) can obtain data “Result(data)” using the function “filterRowCell()”, the piggybacked filter “Filter(data)” and the data row key “data rowkey”.

[0055] Meanwhile, there is a case where the data row key "data rowkey" returned as "Result" is used in the client (410) for Hbase. Accordingly, the coprocessor (421) can use the function "filterRowCell()" to convert the data row key "data rowkey" of the data "Result(data)" into the data row key "data rowkey" in the index and transmit the result "Result" to the client (410). For example, there is a case where the scan in the region is all finished and the metadata table of Hbase is queried to find the next region, and at this time, the data row key "data rowkey" of the last received "Result" is used. As a more specific example, the data row key "data rowkey" of the "Result" has the meaning of the position (row Key) last queried by the client (410), and the data row key "data rowkey" as this position may be required to find the starting position of the next index queried. In embodiments of the present invention, since scanning an index is a method of acquiring data, from the client's (410) perspective, the row to be read next also becomes a row of the index, and therefore, the server (420) must change the data row key "data rowkey" of "Result" to the row key of the index, not the data row key "data rowkey" of the data actually acquired, and transmit it to the client (410) so that the entire data can be acquired normally.

[0056] The index scan result "Result(index)" can be implemented as a list object containing index information, and the coprocessor (421) can empty the list of the index scan result "Result(index)" and fill the index scan result "Result(index)" by changing only the row keys of the data (cells) of the data "Result(data)" to the row keys of the index. In this case, the changed "Result(index)" is implemented as a list object of the index, but the contents contained therein are data, and the row keys in these data (cells) can be combined with the row keys of the index.

[0057] Fig. 7 is a flowchart illustrating an example of an index data query method according to an embodiment of the present invention. The index data query method according to the present embodiment can be performed by a computer device (200) on which a client (410) is installed and operated. At this time, the processor (220) of the computer device (200) can be implemented to execute control instructions according to the code of the operating system included in the memory (210) or the code of at least one computer program. Here, the processor (220) can control the computer device (200) so that the computer device (200) performs steps (710 to 730) included in the method of Fig. 7 according to the control instructions provided by the code stored in the computer device (200).

[0058] In step (710), the computer device (200) may add a second scan object to be used for data acquisition and predefined logic for generating a data row key to a first scan object including an index filter for scanning an index row. At this time, the computer device (200) may add the second scan object and the logic to the first scan object as properties of the first scan object. In addition, the second scan object may include a data filter for scanning data. The index filter may correspond to the index filter "Filter(index)" described above.

[0059] In step (720), the computer device (200) may transmit an index row scan request including a second scan object and a first scan object with added logic to the server. Here, the server may correspond to the server (420) described above.

[0060] In step (730), the computer device (200) may receive from the server an index scanned by the server through an index filter in response to an index row scan request, data scanned by the server through a second scan object, and logic. For example, the server may scan an index through an index filter in response to an index row scan request, and generate a data row key through the scanned index and the logic. In addition, the server may generate a data scan result including data through the data row key and the data filter included in the second scan object. In this case, the computer device (200) according to the embodiment of FIG. 7 may receive data included in the data scan result. Accordingly, the client (410) may obtain data with a single query (index row scan).

[0061] In addition, according to an embodiment, the server may transmit the data scan result including the data in which the row key of the data is changed to the row key of the index to the computer device (200) of the present embodiment corresponding to the client (410). In this case, the computer device (200) may receive the data in which the row key is changed to the row key of the index. In the embodiments of the present invention described above, since the method of acquiring data is to scan the index, the row to be read next from the client (410)'s (410) perspective also becomes the row of the index, and therefore, the server (420) must change the data row key "data rowkey" of "Result" to the row key of the index rather than the data row key "data rowkey" of the actually acquired data and transmit it to the client (410) so that the entire data can be acquired normally.

[0062] Additionally, a custom filter including an index filter, a second scan object, and logic can be set on the server. In this case, the index scan, data row key generation, and data scan result generation can be processed using the custom filter set on the server. The use of this custom filter was previously described in detail with reference to FIGS. 5 and 6.

[0063] FIG. 8 is a flowchart illustrating another example of an index data search method according to an embodiment of the present invention. The index data search method according to the present embodiment may be performed by a computer device (200) implementing a server (420). At this time, the processor (220) of the computer device (200) may be implemented to execute control instructions according to the code of the operating system included in the memory (210) or the code of at least one computer program. Here, the processor (220) may control the computer device (200) so that the computer device (200) performs steps (810 to 850) included in the method of FIG. 8 according to the control instructions provided by the code stored in the computer device (200).

[0064] In step (810), the computer device (200) may receive an index row scan request including a first scan object from a client. At this time, the first scan object may include an index filter for scanning an index row, a second scan object for use in acquiring data, and predefined logic for generating a data row key. Here, the client may correspond to the client (410) described above, and the second scan object and logic may be added to the first scan object as properties of the first scan object by the client. In addition, the second scan object may include a data filter for scanning data.

[0065] According to an embodiment, the computer device (200) may set a custom filter including an index filter, a second scan object, and logic. In this case, steps (820), (830), and (840) may be processed using this custom filter. Below, an embodiment in which steps (820), (830), and (840) are processed simply using the index filter, the second scan object, and the logic included in the custom filter will be described.

[0066] At step (820), the computer device (200) can scan the index through an index filter. The index filter may correspond to the index filter "Filter(index)" described above, and the computer device (200) can scan the index through this index filter to generate an index scan result "Result(index)". The computer device (200) can be linked to a NoSQL database, and the index and the data described below can be scanned from the NoSQL database.

[0067] In step (830), the computer device (200) can generate a data row key using logic and a scanned index. An example of generating a data row key using the logic "Data rowkey schema" to be used for row key generation and the index scan result "Result(index)" has been described above.

[0068] In step (840), the computer device (200) can scan data using the data filter and data row key included in the second scan object. An example of generating a data scan result "Result(data)" using the data filter "Filter(data)" and the data row key "data rowkey" has been described above.

[0069] In step (850), the computer device (200) may transmit the scanned data to the client. In some embodiments, the computer device (200) may change the row key of the scanned data to the row key of the scanned index and transmit the data with the changed row key to the client.

[0070] In this way, according to embodiments of the present invention, a method and system for directly querying index data using a piggyback method in a NoSQL environment can be provided.

[0071] The systems or devices described above may be implemented as hardware components, or a combination of hardware components and software components. For example, the devices and components described in the embodiments may be implemented using one or more general-purpose computers or special-purpose computers, such as, for example, a processor, a controller, an arithmetic logic unit (ALU), a digital signal processor, a microcomputer, a field programmable gate array (FPGA), a programmable logic unit (PLU), a microprocessor, or any other device capable of executing instructions and responding to them. 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 the execution of the software. For ease of understanding, the processing device is sometimes described as being used alone; however, one of ordinary skill in the art will recognize that the processing device may include multiple processing elements and / or multiple types of processing elements. For example, a processing unit may include multiple processors, or a processor and a controller. Other processing configurations, such as parallel processors, are also possible.

[0072] Software may include a computer program, code, instructions, or a combination of one or more of these, which may configure a processing device to perform a desired operation or may independently or collectively command the processing device. The software and / or data may be embodied in any type of machine, component, physical device, virtual equipment, computer storage medium, or device for interpretation by the processing device or for providing instructions or data to the processing device. The software may be distributed over networked computer systems and stored or executed in a distributed manner. The software and data may be stored on one or more computer-readable recording media.

[0073] The method according to the embodiment may be implemented in the form of program commands that can be executed through various computer means and recorded on a computer-readable medium. The computer-readable medium may include program commands, data files, data structures, etc., singly or in combination. The medium may continuously store a computer-executable program, or may temporarily store it for execution or download. In addition, the medium may be various recording or storage means in the form of a single or multiple hardware combinations, and is not limited to a medium directly connected to a computer system, but may also be distributed over a network. Examples of the medium may include magnetic media such as hard disks, floppy disks, and magnetic tapes, optical recording media such as CD-ROMs and DVDs, magneto-optical media such as floptical disks, and those configured to store program commands, including ROM, RAM, and flash memory. In addition, examples of other media may include recording or storage media managed by app stores that distribute applications, sites that supply or distribute various software, servers, etc. Examples of program instructions include machine language code, such as that produced by a compiler, as well as high-level language code that can be executed by a computer using an interpreter, etc.

[0074] Although the embodiments described above have been described by way of limited examples and drawings, those skilled in the art will appreciate that various modifications and variations can be made based on the above teachings. For example, appropriate results can still be achieved even if the described techniques are performed in a different order than described, and / or components of the described systems, structures, devices, circuits, etc. are combined or combined in a different manner than described, or are replaced or substituted with other components or equivalents.

[0075] Therefore, other implementations, other embodiments, and equivalents to the claims also fall within the scope of the claims set forth below.

Claims

1. A computer-readable recording medium having recorded thereon a computer program for executing an index data lookup method on a computer device, The above index data query method is: A step of adding a second scan object for use in data acquisition to a first scan object including an index filter for scanning an index row and predefined logic for generating a data row key; A step of transmitting an index row scan request including the second scan object and the first scan object to which the logic has been added to the server; and A step of receiving, from the server, an index scanned by the server through the index filter according to the index row scan request, the second scan object, and data scanned by the server through the logic. A computer-readable recording medium containing .

2. In paragraph 1, The steps to add above are: Adding the second scan object and the logic to the first scan object as properties of the first scan object. A computer-readable recording medium characterized by:

3. In paragraph 1, In the above server, the row key of the above data is changed to the row key of the above index, The above receiving step is, Receiving data whose row key has been changed to the row key of the above index A computer-readable recording medium characterized by:

4. In paragraph 1, The second scan object includes a data filter, A data row key is generated through the index and the logic in the server, and a data scan result including the data is generated through the data row key and the data filter. A computer-readable recording medium characterized by:

5. In paragraph 4, A custom filter including the index filter, the second scan object, and the logic is set in the server, The scanning of the above index, the generation of the data row key, and the generation of the data scan result are processed using the set custom filter on the server. A computer-readable recording medium characterized by:

6. A method for retrieving index data of a computer device including at least one processor, A step of receiving, by at least one processor, an index row scan request from a client, wherein the first scan object includes an index filter for scanning an index row, a second scan object for use in acquiring data, and predefined logic for generating a data row key; A step of scanning an index through the index filter by at least one processor; A step of generating a data row key using the logic and the scanned index by the at least one processor; A step of scanning data using the data filter and the data row key included in the second scan object by at least one processor; and A step of transmitting the scanned data to the client by at least one processor A method for querying index data including .

7. In paragraph 6, The above transmitting step is, Changing the row key of the scanned data included in the scanned data to the row key of the scanned index and transmitting the data with the changed row key to the client. A method for retrieving index data characterized by .

8. In paragraph 6, The second scan object and the logic are added to the first scan object as properties of the first scan object. A method for retrieving index data characterized by .

9. In paragraph 6, A step of setting a custom filter including the index filter, the second scan object, and the logic by at least one processor. Including more, The step of scanning the above index, the step of generating the data row key, and the step of scanning the data are: Processed using the custom filter set above A method for retrieving index data characterized by .

10. In paragraph 6, The above computer device is linked to a NoSQL (Not Only SQL) database, The above index and the above data are scanned from the NoSQL database. A method for retrieving index data characterized by .

11. At least one processor implemented to execute instructions readable by a computer device. Including, By at least one processor, Receive an index row scan request from a client, wherein the first scan object includes an index filter for scanning an index row, a second scan object for use in retrieving data, and predefined logic for generating a data row key; Scan the index through the above index filter, Generate a data row key using the above logic and the scanned index, Scanning data using the data filter and the data row key included in the second scan object, Transmitting the above scanned data to the above client A computer device characterized by:

12. In paragraph 11, To transmit the scanned data to the client, by the at least one processor, Transmitting the scanned index and the scanned data by changing the row key of the data included in the data to the row key of the index. A computer device characterized by:

13. In paragraph 11, The second scan object and the logic are added to the first scan object as properties of the first scan object. A computer device characterized by:

14. In paragraph 11, By at least one processor, Setting a custom filter including the above index filter, the second scan object, and the above logic, The process of scanning the above index, the process of generating the data row key, and the process of scanning the data are: Processed using the custom filter set above A computer device characterized by:

15. In paragraph 11, The above computer device is linked to a NoSQL (Not Only SQL) database, By the at least one processor, the index and the data are scanned in the NoSQL database. A computer device characterized by:

Images