JP7675792B2 - How cache is generated for a database - Google Patents

Description

The present disclosure relates to the field of information processing, and to a method for generating a cache for a user-input syntax for a database or a method for utilizing the cache. Specifically, the present disclosure relates to a method for analyzing syntax elements for a user-input syntax for a database and generating an LOV cache or a method for utilizing the cache.

As computer technology advances, companies and government offices use a variety of computer programs for business and administrative tasks. These computer programs can store and process a large amount of data necessary for business and administrative tasks such as accounting, human resources, finance, sales, trade, purchasing, materials, production, and inventory. By using these computer programs, users (practitioners, executives, and managers of companies and government offices) can more conveniently and easily store and manage data used by companies and government offices. Computer programs used by companies and government offices support functions for generating, editing, and managing documents in various formats. Note that the processing speed may slow down during the execution of a query statement used to process and output data.

Korean Patent Registration No. 10-0670798 (2007.01.11)

The present disclosure has been devised in response to the background technology described above, and aims to provide a method for generating and utilizing a cache for user input syntax to a database.

The technical problems of the present disclosure are not limited to those mentioned above, and other technical problems not mentioned will be clearly understood by those skilled in the art from the description below.

To solve the above-mentioned problems, a method for generating a list of views (LOV) cache for a database, which is performed by a computing device according to some embodiments, is provided. The method may include the steps of: acquiring a first syntax input to the database; calculating a cache generation base syntax by removing a predefined filtering syntax element from the first syntax; and generating an LOV cache for the first syntax corresponding to the cache generation base syntax.

In one embodiment, the method may further include generating a response to the first syntax based on an LOV cache for the first syntax.

In one embodiment, the step of generating the LOV cache for the first syntax may further include: sending a portion of the response to the first syntax generated until the delay time or number of records for the first syntax reaches a predetermined threshold value when the LOV cache for the first syntax is generated, and sending the entire response to the first syntax when the delay time or number of records for the response generated based on the first syntax is equal to or less than the threshold value when the LOV cache for the first syntax is generated.

In one embodiment, when a portion of the response to the first syntax is sent because the response delay time or number of records for the first syntax exceeds a predetermined critical value, the task of generating an LOV cache for the first syntax may be performed in a background thread.

In one embodiment, generating an LOV cache for the first syntax may include generating first cache data by executing the cache generation base syntax, selecting fields to be sorted from the first cache data, and generating second cache data by sorting the first cache data in the correct order.

In one embodiment, the step of generating second cache data by aligning the first cache data may be performed when the number of types of data included in the field to be aligned is less than a predetermined number.

In one embodiment, the filtering syntax element may perform record deduplication, record grouping, record sorting, or table joining.

In one embodiment, the method may further include, after obtaining the first syntax, obtaining a second syntax including a filtering syntax element, and if an LOV cache for the first syntax includes data extracted by the second syntax, generating a response to the second syntax based on the LOV cache for the first syntax.

Also disclosed is a computer program stored on a computer-readable storage medium for solving the problems described above.

When the computer program is executed by one or more processors, the one or more processors perform operations for generating a list of view (LOV) cache for a database, and the operations may include an operation of acquiring a first syntax input to the database, an operation of calculating a cache generation base syntax by removing a predefined filtering syntax element from the first syntax, and an operation of generating an LOV cache for the first syntax corresponding to the cache generation base syntax.

A computing device for solving the problems described above is also disclosed.

The computing device may include at least one processor and a memory, and the at least one processor may be configured to obtain a first syntax input to a database to generate a list of view (LOV) cache for the database; calculate a cache generation base syntax by removing predefined filtering syntax elements from the first syntax; and generate an LOV cache for the first syntax corresponding to the cache generation base syntax.

The present disclosure has been devised in response to the background technology described above, and is capable of generating a cache for a database based on a user input syntax, and increasing the response speed to the user input syntax through the cache.

Further scope of applicability of the present disclosure will become apparent from the following detailed description. However, it should be understood that the detailed description and specific embodiments, such as the preferred embodiments of the present invention, are given by way of example only, since various changes and modifications within the spirit and scope of the present invention will be apparent to those skilled in the art.

Various aspects are described with reference to the drawings, where like reference numerals are used to generally refer to like components. In the following embodiments, for purposes of explanation, numerous specific details are presented to provide a general understanding of one or more aspects. It will be apparent, however, that such aspects may be practiced without such specific details. In other instances, well-known structures and devices are shown in block diagram form in order to facilitate describing one or more aspects.

FIG. 1 is a block diagram illustrating a computing device according to an embodiment of the present disclosure. FIG. 2 is a flow chart illustrating a method for generating a cache for a database according to one embodiment of the present disclosure. FIG. 3 is a conceptual diagram for explaining a cache generation method for a database according to an embodiment of the present disclosure. FIG. 4 is a conceptual diagram for explaining a cache generation method for a database according to an embodiment of the present disclosure. FIG. 5 is a flowchart illustrating a method for utilizing a cache for a database according to an embodiment of the present disclosure. FIG. 6 is a conceptual diagram for explaining a cache utilization method for a database according to an embodiment of the present disclosure. FIG. 7 is a conceptual diagram for explaining an asynchronous response method for a database according to an embodiment of the present disclosure. FIG. 8 is a general schematic diagram of an exemplary computing environment in which embodiments of the present disclosure may be implemented.

Various embodiments are described below with reference to the drawings. Various descriptions are provided herein to facilitate understanding of the present disclosure. However, these embodiments can certainly be practiced without these specific descriptions.

As used herein, terms such as "component," "module," and "system" refer to computer-related entities, hardware, firmware, software, a combination of software and hardware, or software execution. For example, a component may be, but is not limited to, a procedure running on a processor, a processor, an object, a thread of execution, a program, and/or a computer. For example, an application running on a computing device and a computing device may both be components. One or more components may reside within a processor and/or thread of execution. A component may be localized within a computer. A component may be distributed across two or more computers. Such components may also execute from various computer-readable media having various data structures stored therein. Components may communicate through local and/or remote processing, etc., such as by signals (e.g., data from one component interacting with other components in a local system, distributed system, and/or data transmitted over a network such as the Internet to other systems) having one or more data packets.

The suffixes "module" and "part" used in the following description are given or mixed for the sole consideration of ease of drafting the specification, and do not have any distinct meanings or roles in themselves.

Also, as used herein, the terms "information" and "data" can often be used interchangeably.

When any component is referred to as being "coupled" or "connected" to another component, it should be understood that it may be directly coupled or connected to the other component, but there may be other components in between. On the other hand, when any component is referred to as being "directly coupled" or "directly connected" to another component, it should be understood that there are no other components in between.

The term "or" is also intended to mean an inclusive "or" rather than an exclusive "or." That is, unless otherwise specified or clear from the context, "X utilizes A or B" is intended to mean one of the natural inclusive permutations. That is, if X utilizes A, or X utilizes B, or X utilizes both A and B, then "X utilizes A or B" can apply to any of these. Additionally, the term "and/or" as used herein should be understood to refer to and include all possible combinations of one or more of the associated listed items.

The predicate "comprises" and/or modifier "comprises" should be understood to mean the presence of the feature and/or component in question. However, the predicate "comprises" and/or modifier "comprises" should be understood not to exclude the presence or addition of one or more other features, components, and/or groups thereof. In addition, unless otherwise specified or unless the context is clear that a singular form is indicated, the singular in the present specification and claims should generally be interpreted to mean "one or more."

Hereinafter, the same or similar components are denoted by the same reference numerals, and repeated explanations are omitted. In addition, when explaining the embodiments disclosed in this specification, if a specific explanation of related publicly known technology is judged to make the gist of the embodiments disclosed in this specification unclear, the detailed explanation will be omitted. In addition, the attached drawings are intended to make it easier to understand the embodiments disclosed in this specification, and the technical ideas disclosed in this specification are not limited by the attached drawings.

The term "at least one of A or B" should be interpreted as meaning "when only A is included," "when only B is included," or "when a combination of A and B is included."

Those skilled in the art should further appreciate that the various exemplary logical blocks, configurations, modules, circuits, means, logic, and algorithm steps described in accordance with the embodiments disclosed herein can be implemented by electronic hardware, computer software, or a combination of both. To clearly illustrate the interchangeability of hardware and software, the various exemplary components, blocks, configurations, means, logic, modules, circuits, and steps have been described above generally in terms of their functionality. Whether such functionality is implemented as hardware or software depends on the particular application and design constraints of the overall system. Skilled engineers can implement the described functionality in various ways for each particular application. However, such implementation decisions should not be interpreted as departing from the scope of the present disclosure.

The description of the embodiments set forth herein is provided to enable one of ordinary skill in the art to use or practice the present disclosure. Various modifications to such embodiments will be apparent to those of ordinary skill in the art to which the disclosure pertains, and the general principles defined herein may be applied to other embodiments without departing from the scope of the present disclosure. Thus, the present disclosure is not intended to be limited by the embodiments set forth herein, but is to be accorded the broadest scope consistent with the principles and novel features set forth herein.

With reference to FIGS. 1-8, a technique for efficiently rendering structured documents, such as web pages, by caching pages of the structured document, such as a list of views (LOV), and using the cached resources to reduce perceived rendering time will be described below. In existing systems, when a user requests new data, the browser stops loading the current page and requests the entire new page from the server, which can take a lot of time and slow the user experience. Therefore, the present disclosure aims to reduce or eliminate such overhead by allowing applications, such as browsers and spreadsheets, to request only the new content and resources needed to render the target data, instead of reloading the entire page. This can be accomplished using asynchronous techniques that search for updates to cached resources in remote and/or local data stores, and utilizing various techniques that essentially prevent the browser or client application from re-rendering the entire data. The disclosed techniques can be used to improve the performance and user experience of list of views (LOVs), web pages, and other structured documents in various contexts.

Figure 1 is a block diagram illustrating a computing device according to one embodiment of the present disclosure.

The configuration of computing device 100 shown in FIG. 1 is merely a simplified example. As an example, computing device 100 may include other components for implementing the computing environment of computing device 100, and only some of the disclosed components may constitute computing device 100.

The computing device 100 may include a processor 110, a memory 130, and a network unit 150.

According to an embodiment of the present disclosure, the processor 110 may generally include any type of device capable of processing operations and data of the computing device 100. For example, it may refer to a data processing device built into hardware having a circuit physically structured to perform a function expressed by a code or instruction contained in a program. Examples of such a data processing device built into hardware may include a microprocessor, a central processing unit (CPU), a processor core, a multiprocessor, an application-specific integrated circuit (ASIC), a field programmable gate array (FPGA), etc., but the scope of the present invention is not limited thereto.

The processor 110 may be configured with one or more cores and may include a central processing unit (CPU) of a computing device. It may also include a processor for data analysis and deep learning, such as a general purpose graphics processing unit (GPGPU) or a tensor processing unit (TPU).

According to one embodiment of the present disclosure, the memory 130 can store any type of information generated or determined by the processor 110 and any type of information received by the network unit 150.

According to one embodiment of the present disclosure, the memory 130 may be a flash memory type, a hard disk type, a multimedia card micro type, a card type memory (e.g., SD or XD memory, etc.), a RAM (Random Access Memory, RAM), a SRAM (Static Random Access Memory, SRAM), a ROM (Read-Only Memory, ROM), an EEPROM (Electrically Erasable Programmable Read-Only Memory), a PROM (Programmable Read-Only Memory, PROM), a EEPROM (Electrically Erasable Program ... The memory 130 may include at least one type of storage medium, such as a memory, a magnetic memory, a magnetic disk, or an optical disk. The computing device 100 may also operate in association with web storage that performs the storage function of the memory 130 over the Internet. The above description of the memory is merely exemplary, and the present disclosure is not limited thereto.

The network unit 150 according to one embodiment of the present disclosure can use various wired communication systems such as the Public Switched Telephone Network (PSTN), x Digital Subscriber Line (xDSL), Rate Adaptive DSL (RADSL), Multi Rate DSL (MDSL), Very High Speed DSL (VDSL), Universal Asymmetric DSL (UADSL), High Bit Rate DSL (HDSL), and Local Area Network (LAN).

In addition, the network unit 150 presented in this specification can use various wireless communication systems such as CDMA (Code Division Multi Access), TDMA (Time Division Multi Access), FDMA (Frequency Division Multi Access), OFDMA (Orthogonal Frequency Division Multi Access), SC-FDMA (Single Carrier-FDMA), and other systems.

In the present disclosure, the network unit 150 may be configured regardless of the communication mode, such as wired or wireless, and may be configured with various communication networks, such as a short-range communication network (LAN: Local Area Network), a personal communication network (PAN: Personal Area Network), and a wide area communication network (WAN: Wide Area Network). In addition, the network may be the well-known World Wide Web (WWW: World Wide Web), or may use a wireless transmission technology used for short-range communication, such as infrared (IrDA: Infrared Data Association) or Bluetooth (registered trademark).

The techniques described herein may be used in the networks mentioned above as well as in other networks.

In this specification, a database may be controlled by at least one relational database management system (RDBMS) among ORACLE, PostgreSQL, MySQL, SQL Server (MS-SQL), or SQLite. The database may be one in which data is input and output using a database statement.

The application of this specification may include a separate syntax execution module. When the database statement inputs and outputs data to the database management system (RDBMS), the syntax execution module may generate a customized statement that matches the syntax according to the type of database. For example, through this disclosure, a user can conveniently generate, check, and control a statement through an abstracted formula provided in a user interface (UI) provided by the application, regardless of the type of database.

Also, the application may be related to an SQL statement, the statement performing one or more operations of create, read, update, and delete (CRUD). Here, the SQL statement may be a signal related to one of commands of insert, update, and delete, and the signal may be input or displayed as a name or an abbreviation of the SQL statement in a cell of a spreadsheet. For example, the display may be as shown in Table 1 below.

The user input information may also be for setting columns related to syntax generation or for specifying record conditions. For example, SQL syntax can be executed even if the column order between the original data and the output data is changed or the column names are different. The user input information may also display annotations for the output data.

In the present disclosure, a list of views (LOVs) is a type of user interface element that displays a list of items, and is typically in the form of a table or grid. The LOV typically includes a column for each item attribute and a row for each item in the list. When loading the LOV, the load speed may be slower because the element may be difficult to find or the complexity of the element may increase the query execution time when a query involving a particular element is performed. This may occur when a syntax element included in a query has many attributes or is linked to many other syntax elements in the database, requiring more processing time to find and display the information. Also, if a syntax element is near the end of a list, the query may have to find and process many previous syntax elements before reaching the desired element, which may further slow down the load process, and the caching of the present disclosure may improve the load speed in this case.

Figures 2, 3, and 4 are flowcharts and conceptual diagrams illustrating a method for generating a cache for a database according to one embodiment of the present disclosure.

2, 3 and 4, the computing device of the present disclosure may include a step of acquiring a user input syntax for a database (S110), a step of checking a predefined filtering syntax element from the user input syntax (S210), and a step of checking the existence of an LOV cache for the database corresponding to the user input syntax (S300). In this specification, the cache may be an LOV cache. In addition, the user input syntax is inputted through a user interface (UI) or the like, and may be expressed as a first syntax in which the corresponding LOV cache does not exist and a second syntax in which the corresponding LOV cache exists.

In the step of acquiring user input syntax for the database (S110), a user may run an application linked to the database. The user may then enter a query into a search box. As an example, the query may be "SELECT * FROM products WHERE price>10 AND category='clothing'". The application may then receive the user's input and send it to the database. The database may then receive the user's input and recognize it as SQL syntax. The database may then process the query and return the results to the application. Here, the user input syntax is the SQL syntax entered by the user into a search box, and the application may act to "acquire" this input and send it to the database for processing. The database may then use the input to execute the query and return the results to the application.

As another example, a user may be interacting with an application that can query a database using SQL syntax, where the user may enter a query such as "SELECT DISTINCT column1, column2 FROM table_name WHERE column1='D';". In this case, the user input syntax is the entire SQL syntax entered by the user. The application receives this input and begins a cache generation process for the database. Once the user input syntax is obtained, the application of the present disclosure may proceed to the next stage of the process.

In the step of identifying a predefined filtering syntax element from the user input syntax (S210), for example, the predefined filtering syntax element may be the DISTINCT operator. The application may analyze the user input syntax to search for a DISTINCT keyword and identify the presence of this operator. To this end, the application may use regular expressions (regex) or other string matching techniques to search for keywords such as predefined filtering syntax elements from the user input syntax. As a result, if the DISTINCT keyword is found in the user input syntax, the application may proceed to the next step of the process.

In addition, if there is no LOV cache for the user input syntax in the step of checking for the existence of an LOV cache for the database corresponding to the user input syntax (S300), the present disclosure may further include a step of calculating a cache generation-based syntax by removing predefined filtering syntax elements (S410), and a step of generating an LOV cache for the first syntax based on the cache generation-based syntax (S420).

In the step of calculating a cache generation-based syntax by removing the predefined filtering syntax elements (S410), the application can remove the DISTINCT keyword and related clauses or parameters from the first syntax entered by the user. For example, the application can remove the DISTINCT keyword from the user-entered syntax using regular expressions or other string matching techniques. As a result, the generated derived syntax can be expressed as "SELECT column1, column2 FROM table_name WHERE column1='D';". The derived syntax can be used as a cache generation-based syntax for generating a cache for the database of the present disclosure of the process.

Next, in the step of generating an LOV cache for the user input syntax based on the cache generation-based syntax (S420), for example, the application checks the generated or stored LOV cache to determine whether a cache corresponding to the data requested by the user in the remaining syntax elements exists, and if the cache does not exist, the application may preferentially execute a query directly against a database and return the results to the user.

The application can obtain residual syntax elements for the user input syntax, generate derived syntax based thereon (i.e., a SELECT statement without a DISTINCT operator), and generate an LOV cache for the user input syntax based on the derived syntax. The LOV cache for the user input syntax can include data returned by the SELECT statement stored in a data structure in memory or on disk.

In addition, the application can connect to the database using a database library or API, execute derived syntax (i.e., a SELECT statement with the DISTINCT operator omitted), and store the resulting data in a cache. The cache can be implemented as a data structure in memory, or stored on disk or other permanent storage location. In this manner, the application can create an LOV cache to improve query performance.

Here, the LOV cache may include first cache data generated by executing the user input syntax or cache generation base syntax of the present disclosure. The LOV cache may also generate second cache data in which the generated first cache data is sorted. To generate the second cache data, the application may compare the value of a specific column (column1 in this case) specified in the query against the first cache data, and sort the data in ascending order using a specific sorting algorithm (e.g., ASCENDING specified in the ORDER BY clause), so that the record with the lowest value is displayed first and the record with the highest value is displayed last.

When the second cache data is generated by the method, the application can respond quickly to subsequent user input syntax. For example, if a user tries to search for the same data again, the application can retrieve the data from the cache and provide a response instead of accessing a database. Through the cache, query performance is improved and quick responses can be provided to the user.

The cache generation operation may be processed by a background thread. The background thread may be generated and operated by a threading library or API provided by a programming language or an operating system (OS). While the background thread is running, the main thread may continue to process user requests, improving the performance of the application. This may improve the performance of processing user input syntax by reducing the time that the main thread must wait for a database response if the database is slow or the workload is high. Also, if there are multiple caches for the database associated with the derived syntax, step S410 may be repeated as necessary.

In addition, in the step of checking the existence of an LOV cache for a database corresponding to a user input syntax (S300), if an LOV cache for the user input syntax exists, the present disclosure may further include a step of generating a response to the user input syntax based on the LOV cache (S510). For example, in the process of interacting with an application that can query a database using SQL syntax, if a user submits a user input syntax such as "SELECT DISTINCT column1, column2 FROM table_name WHERE column1='C';", the application checks whether the data requested by the user input syntax is included in the cache for the database. If any one or more of the caches contains the data requested by the user input syntax, the application may perform an operation of returning a response to the user input syntax based on the cache containing the data. This is particularly useful in at least one of the following cases: when a cache contains the frequently accessed data, when a database is slow, or when a workload is high.

Figures 5 and 6 are a flowchart and a conceptual diagram illustrating a method for utilizing a cache for a database according to one embodiment of the present disclosure.

Referring to FIG. 5 and FIG. 6, the computing device of the present disclosure may include a step of acquiring a first syntax for a database (S120), a step of acquiring a second syntax further including a predefined filtering syntax element (S220), and a step of generating a response to the second syntax based on a cache for the database (S520).

In the step of acquiring a first syntax for the database (S120), the first syntax input by the user can be interacted with an application capable of querying the database. For example, if a user wishes to search for a list of unique values for a particular column of a table, the user input syntax can be expressed as "SELECT DISTINCT column1 FROM table_name;".

The application then receives the user input syntax and performs a cache generation process on the database. The first step in the process is to obtain a first syntax. The first syntax may be an entire SQL syntax that does not filter data.

The application can then check the grammar of the first syntax to see if it is valid and can be executed against the database. For example, the application can analyze SQL syntax to see if it has the correct number of clauses and all required elements.

In the step of acquiring a second syntax further including the predefined filtering syntax element (S220), the application may receive the second syntax and perform a process of generating a response based on a cache for the database. For example, the predefined filtering syntax element type may be a DISTINCT operator used to remove duplicate values from a query result. Thus, the second syntax may be similar to the first syntax but may include a DISTINCT operator that returns only unique values. The second syntax may be used to generate a response to a user query in the application.

In the step of generating a response to the second syntax based on the cache for the database (S520), the application can query the database using the second syntax. For example, a user can enter a syntax such as "SELECT DISTINCT column1, column2 FROM table_name WHERE column1='F';" to search for a list of unique values for a particular column of a database table. The syntax can execute a query against the database.

The application can then use the second syntax to generate a response to the user query. For example, the application can execute the second syntax against the cache to retrieve data to return to the user as a response. By using a cache instead of querying a database directly, the application's query performance can be improved and the user can be provided with a faster response.

Figure 7 is a conceptual diagram illustrating an asynchronous response method for a database according to one embodiment of the present disclosure.

Referring to FIG. 7, a computing device of the present disclosure can obtain a first syntax for a database and return a response to the first syntax.

If, while generating the LOV cache for the first syntax, a delay time or a number of records of a response to the first syntax exceeds a predetermined threshold, the method may include sending a portion of the response to the first syntax that has been generated until the delay time or the number of records reaches the threshold. For example, the application may obtain the first syntax, check its validity, and then return the response to the first syntax.

Here, before the first syntax is executed, the application can set a threshold value for the delay time or number of items expected to occur in the response. For example, the application can set a threshold value of 500 milliseconds for the delay time expected to occur in the response and a threshold value of 1 million items for the number of items.

Next, when the first syntax is executed, the application checks whether the time expected for the response exceeds a predefined threshold (e.g., 500 milliseconds). If the predefined threshold is exceeded, the application can stop the aggregation operation and send a portion of the response to the first syntax that was generated until the delay time or number of records reaches the threshold. Conversely, if the threshold is not exceeded, the application can wait until the entire result is returned and send the entire response at once.

By setting thresholds for the time or number of items expected to occur in the response, the application can limit the amount of data returned to the user and improve query performance.

This can help prevent overloading or failure to respond to requests, which can occur frequently when the application returns a large amount of data.

After acquiring the user input syntax, the application can generate a cache for the database based on the user input syntax. The cache can be generated when the time expected for the response exceeds the predetermined threshold. The operation of generating the cache can be processed by a background thread, and thus the operation of generating the cache can be performed without increasing the latency of the asynchronous response operation of processing the first syntax.

While generating an LOV cache for the first syntax, if the latency or number of records of the response generated based on the first syntax is equal to or less than the critical value, the entire response to the first syntax can be sent. In this case, the application of the present disclosure does not need to generate a cache for the database, and thus generates an LOV cache only when the latency or number of records of the response generated based on the first syntax is equal to or greater than the critical value, thereby reducing resources for storing the LOV cache without sacrificing the response speed to the first syntax.

Figure 8 is a general schematic diagram of an exemplary computing environment in which embodiments of the present disclosure may be implemented.

Referring to FIG. 8, the computer program, when executed by one or more processors, can perform an operation to extract and output original data.

According to one embodiment of the present disclosure, the operations may include an operation of the one or more processors obtaining first data including an image from a database to perform an operation for displaying the data in a spreadsheet, and an operation of displaying the first data in a spreadsheet through a spreadsheet module based on the first data.

According to another embodiment of the present disclosure, the operations may include a spreadsheet module receiving parameters of a data extraction function so that the one or more processors perform an operation to output data to a spreadsheet, generating a first syntax for accessing a database based on the parameters of the data extraction function, acquiring first data from the database using the first syntax, and outputting the first data via the spreadsheet module based on the parameters of the data extraction function.

According to yet another embodiment of the present disclosure, the operations may include an operation of checking a domain search syntax for the original data in the table to index the original data, and an operation of generating index information for the original data based on the search syntax.

Also disclosed in one embodiment of the present disclosure is a computer-readable medium having a data structure stored thereon.

A data structure may refer to the organization, management, and storage of data that allows efficient access and modification of the data. A data structure may refer to the organization of data to solve a specific problem (e.g., data retrieval, data storage, data modification in the shortest time). A data structure may also be defined as a physical or logical relationship between data elements designed to support a specific data processing function. A logical relationship between data elements may include a linking relationship between user-defined data elements. A physical relationship between data elements may include an actual relationship between data elements that is physically stored in a computer-readable storage medium (e.g., a permanent storage device). A data structure may specifically include a collection of data, a relationship between data, and a function or instruction that can be applied to the data. Through an effectively designed data structure, a computing device can perform operations while minimizing the use of computing device resources. Specifically, a computing device can increase the efficiency of operations, reading, retrieval, deletion, comparison, exchange, and search through an effectively designed data structure.

Data structures may be classified into linear data structures and non-linear data structures according to the form of the data structure. A linear data structure may be a structure in which only one piece of data is linked after one piece of data. A linear data structure may include a list, a stack, a queue, and a deque. A list may mean a series of data sets that have an internal order. A list may include a linked list. A linked list may be a data structure in which data is linked in a manner in which each piece of data has a pointer and is linked in a row. In a linked list, the pointer may include information on the connection with the next or previous piece of data. A linked list may be expressed as a singly linked list, a doubly linked list, or a circularly linked list according to the form. A stack may be a data array structure in which access to data is restricted. A stack may be a linear data structure in which data can be processed (e.g., inserted or deleted) only at one end of the data structure. The data stored in a stack may be a last in, first out (LIFO) data structure. A queue is a data array structure that limits access to data and, unlike a stack, may be a first in, first out (FIFO) data structure. A deck may be a data structure that allows data to be processed at both ends of the data structure.

The nonlinear data structure may be a structure in which multiple data are linked after one piece of data. The nonlinear data structure may include a graph data structure. The graph data structure may be defined by vertices and edges, and an edge may include a line connecting two different vertices. The graph data structure may include a tree data structure. The tree data structure may be a data structure in which there is one path connecting two different vertices among multiple vertices included in the tree. In other words, the graph data structure may be a data structure that does not form a loop.

The data structure may include data to be input to the neural network. The data structure including the data to be input to the neural network may be stored on a computer-readable medium. The data to be input to the neural network may include training data input during a neural network training process and/or input data to be input to a neural network after training has been completed. The data to be input to the neural network may include data that has undergone pre-processing and/or data to be pre-processed. Pre-processing may include a data processing process for inputting data to the neural network. Thus, the data structure may include data to be pre-processed and data generated in pre-processing. The above-mentioned data structures are merely examples, and the present disclosure is not limited thereto.

The data structure may include weights of the neural network. (In this specification, weights and parameters may be used interchangeably.) The data structure including the weights of the neural network may be stored on a computer-readable medium. The neural network may include multiple weights. The weights may be variable and may be varied by a user or algorithm in order for the neural network to perform a desired function. For example, when one or more input nodes are interconnected to an output node by respective links, the output node may determine a data value to be output from the output node based on values input to the input nodes connected to the output node and weights set to the links corresponding to the respective input nodes. The above-mentioned data structures are merely examples, and the present disclosure is not limited thereto.

While the disclosure has been described above as generally being embodied in a computing device, those skilled in the art will appreciate that the disclosure may also be embodied in combination with computer-executable instructions and/or other program modules capable of being executed on one or more computers and/or as a combination of hardware and software.

Generally, program modules include routines, programs, components, data structures, etc. that perform particular tasks or implement particular abstract data types. Those skilled in the art will also appreciate that the methods disclosed herein can be implemented with other computer system configurations, including single-processor or multi-processor computer systems, minicomputers, mainframe computers, as well as personal computers, handheld computing devices, microprocessor-based or programmable consumer electronics, and the like, each of which can operate in conjunction with one or more associated devices.

Moreover, the embodiments described in this disclosure may be practiced in distributed computing environments where certain tasks are performed by remote processing devices that are linked through a communications network. In a distributed computing environment, program modules may be located in both local and remote memory storage devices.

A computer typically includes a variety of computer-readable media. Any medium accessible by a computer can be a computer-readable medium, including volatile and non-volatile media, transitory and non-transient media, and mobile and non-mobile media. By way of example and not limitation, computer-readable media can include computer-readable storage media and computer-readable transmission media. Computer-readable storage media includes volatile and non-volatile media, transitory and non-transient media, mobile and non-mobile media implemented by any method or technology for storing information such as computer-readable instructions, data structures, program modules, or other data. Computer-readable storage media include, but are not limited to, RAM, ROM, EEPROM, flash memory or other memory technology, CD-ROM, DVD (digital video disk) or other optical disk storage device, magnetic cassette, magnetic tape, magnetic disk storage device or other magnetic storage device, or any other medium that can be accessed by a computer and used to store information.

Computer-readable transmission media typically embodies computer-readable instructions, data structures, program modules, or other data in a modulated data signal, such as a carrier wave or other transport mechanism, and includes all information delivery media. The term modulated data signal means a signal that has one or more of its characteristics set or changed in such a manner as to encode information in the signal. By way of example, and not limitation, computer-readable transmission media include wired media, such as a wired network or direct-wired connection, and wireless media, such as acoustic, RF, infrared, and other wireless media. Combinations of any of the above media are also intended to be included within the scope of computer-readable transmission media.

An exemplary environment 1100 embodying various aspects of the present disclosure is shown including a computer 1102, which includes a processing unit 1104, a system memory 1106, and a system bus 1108. The system bus 1108 couples system components including, but not limited to, the system memory 1106 to the processing unit 1104. The processing unit 1104 may be any of a variety of commercially available processors. Dual processors and other multi-processor architectures may also be utilized as the processing unit 1104.

The system bus 1108 may be any of several types of bus structures that may be further interconnected to a memory bus, a peripheral bus, and a local bus using any of a variety of commercially available bus architectures. The system memory 1106 includes read only memory (ROM) 1110 and random access memory (RAM) 1112. A basic input/output system (BIOS) is stored in non-volatile memory 1110, such as ROM, EPROM, or EEPROM, and includes basic routines that support transferring information between components within the computer 1102, such as during start-up. The RAM 1112 may also include a high-speed RAM, such as a static RAM, for caching data.

The computer 1102 also includes an internal hard disk drive (HDD) 1114 (e.g., EIDE, SATA) - which may be configured for external use in a suitable chassis (not shown) - a magnetic floppy disk drive (FDD) 1116 (e.g., for reading from and writing to a removable diskette 1118), and an optical disk drive 1120 (e.g., for reading from and writing to a CD-ROM disk 1122 and other high-capacity optical media such as DVDs). The hard disk drive 1114, magnetic disk drive 1116, and optical disk drive 1120 may be coupled to the system bus 1108 by a hard disk drive interface 1124, a magnetic disk drive interface 1126, and an optical drive interface 1128, respectively. The interface 1124 for implementing an external drive includes at least one or both of USB (Universal Serial Bus) and IEEE 1394 interface technologies.

These drives and associated computer-readable media provide non-volatile storage of data, data structures, computer-executable instructions, and the like. In the case of computer 1102, the drives and media accommodate the storage of any data in a suitable digital format. While the above description of computer-readable media refers to HDDs, portable magnetic disks, and portable optical media such as CDs or DVDs, those skilled in the art will appreciate that other types of computer-readable media, such as zip drives, magnetic cassettes, flash memory cards, cartridges, and the like, may also be used in the exemplary operating environment, and that any such media may contain computer-executable instructions for performing the methods of the present disclosure.

A number of program modules, including an operating system 1130, one or more application programs 1132, other program modules 1134, and program data 1136, may be stored on the drive and in RAM 1112. All or portions of the operating system, applications, modules, and/or data may be cached in RAM 1112. It will be appreciated that the present disclosure may be embodied in a variety of commercially available operating systems or combinations of operating systems.

A user may enter commands and information into the computer 1102 through one or more wired or wireless input devices, such as a keyboard 1138 and a pointing device, such as a mouse 1140. Other input devices (not shown) may include a microphone, an IR remote control, a joystick, a game pad, a stylus pen, a touch screen, and the like. These and other input devices are often coupled to the processing unit 1104 through an input device interface 1142 that is coupled to the system bus 1108, but may also be coupled by a variety of interfaces, such as a parallel port, an IEEE 1394 serial port, a game port, a USB port, an IR interface, and the like.

The term user input in this disclosure may refer to any form of user input associated with a user request made within a user interface (or within a web page). For example, the user input may include a user input moving a pointer object. As another example, the user input may include a user input selecting a particular object on the user interface. For example, a user input may be made to an object (e.g., a module, a tap, etc.) by touching or clicking the object. When a selection-related user input is received, a new object may be displayed on the user interface or web page in response to the input, or attributes of the object may be changed and displayed.

As yet another example, user input may include information such as language, letters, numbers, and symbols input by various input means. User input is not limited to the above examples, and various forms of user actions are possible, such as mouse cursor control, mouse wheel scrolling, keyboard directional keys, mouse clicks, and touch.

A monitor 1144 or other type of display device is also coupled to the system bus 1108 via an interface, such as a video adapter 1146. In addition to the monitor 1144, a computer typically includes other peripheral output devices (not shown), such as speakers, printers, and the like. For example, the monitor 1144 or other type of display device may include at least one of a liquid crystal display (LCD), a thin film transistor-liquid crystal display (TFT LCD), an organic light-emitting diode (OLED), a flexible display, a three-dimensional display (3D display), and an e-ink display. The display unit also outputs (displays) data processed by the processor 110.

The computer 1102 can operate in a networked environment using logical connections to one or more remote computers, such as a remote computer 1148, via wired and/or wireless communications. The remote computer 1148 may be a workstation, a computing device computer, a router, a personal computer, a handheld computer, a microprocessor-based entertainment device, a peer device, or other conventional network node, and typically includes many or all of the components described for the computer 1102, although for simplicity, only a memory storage device 1150 is shown. The illustrated logical connections include wired or wireless connections to a local area network (LAN) 1152 and/or a larger network, such as a wide area network (WAN) 1154. Such LAN and WAN networking environments are commonplace in offices and companies and facilitate enterprise-wide computer networks, such as intranets, all of which may be coupled to a worldwide computer network, such as the Internet.

When used in a LAN networking environment, the computer 1102 is coupled to the local network 1152 via a wired and/or wireless communication network interface or adapter 1156. The adapter 1156 can facilitate wired or wireless communication to the LAN 1152, which also includes a wireless access point installed to communicate with the wireless adapter 1156. When used in a WAN networking environment, the computer 1102 may include a modem 1158 or have other means for coupling to a communications computing device on the WAN 1154 or for establishing communications over the WAN 1154, such as via the Internet. The modem 1158, which may be internal or external and a wired or wireless device, is coupled to the system bus 1108 via the serial port interface 1142. In a networked environment, the program modules described for the computer 1102, or portions thereof, may be stored in a remote memory/storage device 1150. It will be appreciated that the network connections shown are exemplary and that other means of establishing a communications link between the computers may be used.

The computer 1102 operates to communicate with any wireless device or individual that is arranged and operates in wireless communication, such as printers, scanners, desktop and/or handheld computers, PDAs (portable data assistants), communication satellites, any equipment or location associated with a wirelessly detectable tag, and telephones. This includes at least Wi-Fi® and Bluetooth® wireless technologies. Thus, communication may be of a predefined structure, such as a conventional network, or simply ad hoc communication between at least two devices.

Wi-Fi® (Wireless Fidelity) allows for connection to the Internet and the like without being wired. Wi-Fi® is a wireless technology like cell phones that allows such devices, e.g., computers, to send and receive data indoors or outdoors, i.e., anywhere within the coverage area of a base station. Wi-Fi® networks use IEEE 802.11 (a, b, g, etc.) radio technology to provide secure, reliable, and fast wireless connections. Wi-Fi® can be used to connect computers to each other, to the Internet, and to wired networks (using IEEE 802.3 or Ethernet). Wi-Fi® networks can operate in the unlicensed 2.4 and 5 GHz radio bands, e.g., at 11 Mbps (802.11a) or 54 Mbps (802.11b) data rates, or with products that include both bands (dual band).

Those of ordinary skill in the art of the present disclosure can appreciate that information and signals can be represented using any of a variety of different technologies and techniques. For example, the data, instructions, commands, information, signals, bits, symbols and chips referred to in the above description can be represented by voltages, currents, electromagnetic waves, magnetic fields or particles, optical fields or particles, or any combination thereof.

Furthermore, computer 1102 may be embodied as a user terminal. Therefore, the method according to one embodiment of the present disclosure may be applied without restriction to a terminal as hardware capable of carrying software. The user terminals described in this disclosure may include mobile phones, smart phones, laptop computers, digital broadcasting terminals, personal digital assistants (PDAs), portable multimedia players (PMPs), navigation devices, slate PCs, tablet PCs, ultrabooks, wearable devices (e.g., smartwatches, smart glass, head mounted displays (HMDs)), and the like. In addition, the user terminal may include, but is not limited to, a device that allows a user to input and output data, a device that can display data to a user, and a device that can be connected via wire or communication. For example, the computing device 100 may be a desktop, a notebook computer, a tablet PC, a portable terminal, etc.

Those of ordinary skill in the art of the present disclosure can appreciate that the various exemplary logic blocks, modules, processors, means, circuits, and algorithm steps described in the description of the embodiments disclosed herein can be embodied in electronic hardware, various forms of programs (referred to herein as "software" for ease of description) or design code, or a combination of all of these. To clearly illustrate such compatibility of hardware and software, various exemplary components, blocks, modules, circuits, and steps have been generally described above with a focus on their functionality. Whether such functionality is implemented as hardware or software is determined by the design constraints imposed on the particular application and the overall system. Those of ordinary skill in the art of the present disclosure can embody the described functionality in various ways for each particular application, and such embodying decisions should not be interpreted as departing from the scope of the present disclosure.

The various embodiments described herein may be implemented by a method, apparatus, or article of manufacture using standard programming and/or engineering techniques. The term "article of manufacture" includes a computer program, carrier, or media accessible by any computer readable device. For example, computer readable storage media include, but are not limited to, magnetic storage devices (e.g., hard disks, floppy disks, magnetic strips, etc.), optical disks (e.g., CDs, DVDs, etc.), smart cards, and flash memory devices (e.g., EEPROMs, cards, sticks, key drives, etc.). Additionally, the various storage media described herein include one or more devices and/or other machine-readable media for storing information.

It should be understood that the particular order or hierarchy of the process stages depicted herein is an example of an exemplary approach. Based on design priorities, it should be understood that the particular order or hierarchy of the process stages may be rearranged within the scope of this disclosure. The accompanying method claims provide elements of the various stages in a sample order, but are not meant to be limited to the particular order or hierarchy depicted.

The description of the embodiments shown herein is provided to enable any person of ordinary skill in the art to which the disclosure pertains to the present disclosure to use or practice the present disclosure. Various modifications to such embodiments will be apparent to those of ordinary skill in the art to which the disclosure pertains, and the general principles defined herein may be applied to other embodiments without departing from the scope of the present disclosure. Thus, the present disclosure is not intended to be limited by the embodiments shown herein, but is to be accorded the broadest scope consistent with the principles and novel features disclosed herein.

Claims (5)

1. A method for generating a list of views (LOV) cache for a database, the method being performed by a computing device, comprising:
obtaining a first syntax input to a database;
generating a cache generation based syntax by removing predefined filtering syntax elements from the first syntax;
generating an LOV cache for the first syntax in which a query result based on a cache generation-based syntax calculated from the first syntax is cached ;
The step of generating an LOV cache for the first syntax comprises:
generating first cache data by executing the cache generation base syntax;
selecting a field from the first cache data in which to sort the data in ascending order using a specific algorithm by comparing values of a specific column specified in the query;
generating second cache data by arranging the first cache data in the ascending order;
The step of generating second cache data by sorting the first cache data in the ascending order includes:
The method is performed when the number of types of data contained in the field to be sorted in ascending order is less than a predetermined number . The filtering syntax element is:
The method of claim 1 , further comprising: performing record deduplication, record grouping, record sorting, or table joining. obtaining a second syntax including a filtering syntax element after obtaining the first syntax;
2. The method of claim 1, further comprising: if an LOV cache for the first syntax contains data that the second syntax extracts, generating a response to the second syntax based on an LOV cache for the first syntax. A computer program stored on a computer-readable storage medium, the computer program, when executed by one or more processors, causing the one or more processors to perform operations for generating a list of view (LOV) cache for a database, the operations comprising:
an operation of acquiring a first syntax input to a database;
calculating a cache generation-based syntax by removing predefined filtering syntax elements from the first syntax;
generating an LOV cache for the first syntax in which a query result based on a cache generation base syntax calculated from the first syntax is cached ;
The act of generating an LOV cache for the first syntax includes:
generating first cache data by executing the cache generation base syntax;
selecting a field from the first cache data in which to sort data in ascending order using a specific algorithm by comparing values of a specific column specified in the query;
generating second cache data by arranging the first cache data in the ascending order;
The operation of generating second cache data by sorting the first cache data in the ascending order includes:
A computer program stored on a computer-readable storage medium , the computer program being executed when the number of types of data included in the field to be sorted in ascending order is less than a predetermined number . 1. A computing device comprising:
At least one processor;
A memory,
The at least one processor includes:
Obtaining a first syntax input to a database;
a cache-based syntax is calculated by removing predefined filtering syntax elements from the first syntax; and a LOV cache is generated for the first syntax, in which a query result according to the cache-based syntax calculated from the first syntax is cached ;
The configuration for generating the LOV cache includes:
executing the cache generation base syntax to generate first cache data;
A configuration in which a value of a specific column specified in a query is compared from the first cache data and a field in which data should be sorted in ascending order using a specific algorithm is selected;
generating second cache data by sorting the first cache data in the ascending order;
The configuration for generating the second cache data by sorting the first cache data in the ascending order includes:
This is performed when the number of types of data contained in the field to be sorted in ascending order is less than a predetermined number .