Apparatus for performing text-to-sql based on skeleton graph repository and method operation thereof

Abstract

According to various embodiments, an apparatus for performing Text-to-SQL based on a skeleton graph repository comprises: a repository in which a plurality of skeleton graphs are stored; a searcher that obtains natural language information from a user and obtains at least one candidate graph information connected to the natural language information from the repository; a synthesizer that reassembles the at least one candidate graph information to generate a predicted skeleton graph; a converter that generates SQL based on the predicted skeleton graph; and a validator that verifies the SQL and, if the verification of the SQL is successful, stores the predicted skeleton graph in the repository.

Description

Technology Field

[0001] Various embodiments of the present invention relate to a Text-to-SQL system that automatically generates a Structured Query Language (SQL) query from natural language requirements. More specifically, the invention relates to an apparatus and method that accumulates a skeleton graph extracted from past requirements and SQL pairs in a repository, and generates SQL accurately and efficiently by searching for a similar graph or reassembling a subgraph for a new requirement. Background Technology

[0002] Database systems are a core infrastructure of modern information technology and are essential for efficiently storing and managing the vast amount of data in companies and organizations. However, accessing databases requires knowledge of specialized query languages ​​such as SQL, which acts as a high barrier to entry for non-experts.

[0003] To address these issues, Text-to-SQL technology that automatically converts natural language into SQL has been researched. Conventional Text-to-SQL technology converts natural language into SQL based on predefined grammar rules, but it has limitations in that it is difficult to handle complex queries or various expressions.

[0004] Furthermore, while database schema constraints must be adhered to to ensure the accuracy of the generated SQL, conventional methods frequently fail to explicitly model these structural constraints, resulting in the generation of SQL that is syntactically correct but causes errors during execution.

[0005] Therefore, there is a need for new technology that generates accurate SQL without grammatical or structural errors regarding user requirements. Prior art literature

[0006] Korean Patent Publication No. 10-2149701 (2020.08.25) Korean Patent Publication No. 10-2512528 (2023.03.16) The problem to be solved

[0007] The present invention aims to provide an apparatus and method capable of improving accuracy and efficiency by extracting a skeleton graph including operator nodes and constraints from natural language requirements and SQL learning pairs, systematically accumulating it in a repository, and generating SQL by searching for graphs connected to similar requirements or reassembling subgraphs for input requirements. means of solving the problem

[0008] According to various embodiments, an apparatus for performing Text-to-SQL based on a skeleton graph repository comprises: a repository in which a plurality of skeleton graphs are stored; a searcher that obtains natural language information from a user and obtains at least one candidate graph information connected to the natural language information from the repository; a synthesizer that reassembles the at least one candidate graph information to generate a predicted skeleton graph; a converter that generates SQL based on the predicted skeleton graph; and a validator that verifies the SQL and, if the verification of the SQL is successful, stores the predicted skeleton graph in the repository.

[0009] According to various other embodiments, a method of operation of a device for performing Text-to-SQL based on a skeleton graph repository comprises: a step of obtaining natural language information from a user by means of a searcher of the device; a step of obtaining at least one candidate graph information connected to the natural language information from a repository in which a plurality of skeleton graphs are stored by means of the searcher; a step of generating a predicted skeleton graph by reassembling the at least one candidate graph information by means of a synthesizer of the device; a step of generating SQL based on the predicted skeleton graph by means of a converter of the device; and a step of verifying the SQL by means of a validator of the device, and if the verification of the SQL is successful, storing the predicted skeleton graph in the repository. Effects of the invention

[0010] The device according to the present embodiment has the advantage of effectively reducing the search space and improving the accuracy of SQL generation compared to the existing method of encoding the entire database schema by systematically accumulating skeleton graphs corresponding to natural language requirements in a repository and reusing verified query structures through similar requirement-based search.

[0011] In addition, the device according to the present embodiment has the advantage of significantly increasing the generation rate of executable SQL by explicitly expressing structural constraints such as PK-FK relationships, GROUP-AGG binding, and scope constraints in a skeleton graph and verifying the consistency of constraints during the graph reassembly process, thereby blocking in advance the generation of SQL that is syntactically correct but causes errors during execution.

[0012] In addition, the device according to the present embodiment has the advantage of significantly improving data accessibility by automating the entire process from natural language input to SQL generation, verification, and repository updates, thereby enabling even general users who are not database experts to perform complex data queries, and enabling the implementation of an adaptive system that can effectively respond to continuously evolving data requirements. Brief explanation of the drawing

[0013] FIG. 1 illustrates a block diagram of an apparatus of the present invention according to various embodiments. FIG. 2 is a flowchart illustrating how a device operates according to various embodiments. Specific details for implementing the invention

[0014] Hereinafter, various embodiments of this document are described with reference to the accompanying drawings. The embodiments and the terms used therein are not intended to limit the technology described in this document to specific embodiments and should be understood to include various modifications, equivalents, and / or substitutions of said embodiments. In relation to the description of the drawings, similar reference numerals may be used for similar components. A singular expression may include a plural expression unless the context clearly indicates otherwise. In this document, expressions such as "A or B" or "at least one of A and / or B" may include all possible combinations of items listed together. Expressions such as "first," "second," "first," or "second" may modify said components regardless of order or importance and are used only to distinguish one component from another and do not limit said components. When it is mentioned that a certain (e.g., 1st) component is "(functionally or telecommunicationally) connected" or "connected" to another (e.g., 2nd) component, said certain component may be directly connected to said other component or connected through another component (e.g., 3rd component).

[0015] In this document, "configured to" may be used interchangeably with, depending on the context, for example, hardware- or software-wise, "suitable for," "capable of," "modified to," "made to," "capable of," or "designed to." In some cases, the expression "device configured to" may mean that the device is "capable of" in conjunction with other devices or components. For example, the phrase "processor configured to perform A, B, and C" may mean a dedicated processor for performing the corresponding operations (e.g., an embedded processor), or a general-purpose processor capable of performing the corresponding operations by executing one or more software programs stored in a memory device (e.g., a CPU or application processor).

[0017] FIG. 1 illustrates a block diagram of an apparatus of the present invention according to various embodiments.

[0019] Referring to FIG. 1, the device (101) for performing Text-to-SQL based on the skeleton graph repository (120) of the present invention may include a bus (110), a repository (120), a searcher (130), a synthesizer (140), a converter (150), and a verifier (160). In some embodiments, the device (101) may omit at least one of the components or additionally include other components. The bus (110) may include a circuit that connects the components (120-160) of the device (101) to each other and transmits communication (e.g., control messages or data) between the components.

[0020] The storage (120) may include volatile and / or non-volatile memory. The storage (120) may, for example, store and manage a number of skeleton graphs. In particular, the storage (120) may accumulate and store skeleton graphs generated in past learning stages. According to one embodiment, the skeleton graph may include an operator node containing a number of SQL operations, a constraint that determines structural errors in the SQL, and a slot which is an abstract identifier for a table and a column. For example, the operator node may represent SQL operations such as SELECT, JOIN, FILTER, GROUP BY, AGGREGATE, SUBQUERY, etc., the constraint may include a PK-FK (primary key-foreign key) relationship, a GROUP-AGG (between GROUP BY and aggregate functions) binding, a scope constraint, etc., and the slot may be represented in the form of an abstract placeholder such as , , <TABLE.COL>.

[0021] According to one embodiment, the repository (120) can build and accumulate initial skeleton graphs through a learning phase prior to the operation phase. To generate skeleton graphs from previously collected requirement-SQL learning pairs, the repository (120) can analyze learning SQL queries based on an abstract syntax tree (AST) to extract operator nodes and generate constraints between these nodes to complete the graph structure. Additionally, the repository (120) can convert the generated graph into a schema-independent structure by replacing table names and column names with slots such as and , and if the database is a single database, it can shorten the mapping process in the operation phase by storing the actual table and column identifiers in the slots. The storage (120) can analyze the structural patterns of slotted graphs to extract frequently occurring subgraph patterns and generate a unique signature (e.g., hash value or pattern identifier) ​​based on a graph hashing algorithm for each pattern, thereby eliminating redundancy and efficiently utilizing storage space by grouping graphs with the same signature into a single pattern class. Additionally, the storage (120) can extract requirement metadata, such as embedding information and keyword information, from natural language requirements associated with each skeleton graph, and store the extracted requirement metadata by linking it to the corresponding skeleton graph. Furthermore, the storage (120) can support fast searching during the operation phase by organizing and storing all graph structures, slots, signatures, and requirement metadata generated during the learning process into a multidimensional index structure. For example, search efficiency can be maximized by using an Approximate Nearest Neighbor (ANN) index specialized for vector similarity search for requirement embedding information and utilizing an Inverted Index structure for keyword information.Furthermore, it may include a function that stores performance metadata, such as the average execution time and success rate when each skeleton graph is executed via SQL, and utilizes this as a weight during searching to prioritize the recommendation of graphs with verified performance. Subsequently, the repository (120) can continuously accumulate new prediction skeleton graphs that have been successfully verified by the validator (160) during the operation phase, thereby forming a self-learning structure in which the learning phase and the operation phase interact cyclically to automatically improve the performance of the system.

[0022] The searcher (130) may be configured to obtain natural language information from a user and to obtain at least one candidate graph information connected to the natural language information from the repository (120). Specifically, the searcher (130) may extract intent information representing the user's requirements, keyword information representing key words or phrases of the natural language information, and embedding information that quantifies the natural language information from the natural language information. Here, the intent information represents the purpose of database operations such as SELECT, FILTER, AGGREGATE, JOIN, etc., the keyword information includes key vocabulary that is highly likely to match table names, column names, condition values, etc., and the embedding information is an expression that converts the natural language information into a numeric vector in a high-dimensional vector space. Subsequently, the searcher (130) may calculate the similarity with past requirements within the repository (120) using the intent information, keyword information, and embedding information, and obtain at least one candidate graph information based on the similarity. The searcher (130) can calculate similarity by combining cosine similarity between embedding vectors, keyword matching scores, etc., and can select skeleton graphs that are semantically closest to the input natural language information.

[0023] The synthesizer (140) may be configured to generate a predicted skeleton graph by reassembling at least one candidate graph information obtained from the searcher (130). According to one embodiment, the synthesizer (140) may perform reassembly by determining priority based on the similarity of at least one candidate graph information. At this time, based on the searched candidate graphs, a prediction model based on a Graph Neural Network (GNN) may be utilized to predict missing parts or generate an optimal combination. Additionally, the synthesizer (140) may determine whether the predicted skeleton graph has a structural error based on constraints. In particular, if a conflict occurs during the reassembly process where two or more candidate graphs propose different structures for the same part, a conflict resolution rule may be applied to adopt the structure of the candidate graph with the higher token-unit attention score with the original natural language requirement. Here, structural errors include JOIN between tables without PK-FK relationships, use of aggregate functions without GROUP BY, and out-of-scope column references. The synthesizer (140) can generate a prediction skeleton graph that satisfies constraints by performing reassembly by changing the priority of at least one candidate graph information only when the prediction skeleton graph is determined to have a structural error. Additionally, the synthesizer (140) can repeatedly perform the reassembly process of combining at least one candidate graph information so as not to violate structural constraints.

[0024] The converter (150) can be configured to generate executable SQL based on a prediction skeleton graph generated from the synthesizer (140). Specifically, the converter (150) can map slots included in the prediction skeleton graph to actual tables and columns existing in the database schema of the repository (120). Subsequently, the converter (150) can generate complete SQL based on the mapped table and column information.

[0025] The validator (160) can be configured to validate the SQL generated from the converter (150) and, if the validation of the SQL is successful, to save the prediction skeleton graph to the repository (120). The validator (160) can perform syntax validation, schema constraint validation, and execution validation on the SQL. Here, syntax validation checks the correctness of the SQL syntax, schema constraint validation checks the set of constraints that check and guarantee the integrity of the schema, and execution validation checks whether the SQL is executed without errors by executing it in an actual database. If all validations are successful, the validator (160) can accumulate the natural language information associated with the prediction skeleton graph along with metadata in the repository (120) so that it can be reused when similar requirements are input in the future. Conversely, if the validator (160) fails to execute SQL during the execution verification phase, it logs the cause of the failure (e.g., no permission, timeout, incorrect data type) and separately stores the skeleton graph and natural language requirements associated with the cause as 'error patterns' in the storage (120). This can be used to predict and prevent similar errors in the future or as important data for system retraining.

[0027] FIG. 2 is a flowchart illustrating how a device operates according to various embodiments.

[0029] In operation 201, the searcher (130) can obtain natural language information from the user. According to one embodiment, the searcher (130) can receive a database query in the form of natural language input through a user interface. Here, the natural language information is a requirement expressed in everyday language by the user to query the database for desired information, which enables database querying without specialized knowledge of SQL.

[0030] In operation 203, the searcher (130) may obtain at least one candidate graph information connected to natural language information from a storage (120) in which a plurality of skeleton graphs are stored. According to one embodiment, the searcher (130) may extract intent information indicating a user's requirement, keyword information indicating a core word or phrase of the natural language information, and embedding information that quantifies the natural language information from the natural language information. Here, the intent information indicates the purpose of a database operation and may include data retrieval, data filtering, data aggregation, data combination, data grouping, etc. Additionally, the keyword information may indicate a core word or phrase that is highly likely to match a table name, column name, condition value, etc. Additionally, the embedding information may be a representation in which the natural language is converted into a numeric vector in a high-dimensional vector space and may be in a quantified form that allows semantic similarity to be calculated.

[0031] In operation 205, the synthesizer (140) can generate a predicted skeleton graph by reassembling at least one candidate graph information. According to one embodiment, the synthesizer (140) can reassemble several retrieved candidate graphs or subgraphs by determining priority based on similarity.

[0032] According to one embodiment, although not illustrated in FIG. 2, the synthesizer (140) can determine whether the predicted skeleton graph is a structural error based on constraints. Here, a structural error is an error that is grammatically possible in SQL but violates database schema constraints, and may include JOIN between tables without PK-FK relationships, use of aggregate functions without GROUP BY, and out-of-scope column references. In this embodiment, the synthesizer (140) can reassemble the graph by changing the priority of at least one candidate graph information only when the predicted skeleton graph is determined to be a structural error. Through this, the synthesizer (140) can generate a correct skeleton graph that satisfies constraint consistency.

[0033] When the synthesizer (140) generates a prediction skeleton graph based on, for example, the first candidate graph (e.g., similarity 0.87), a structure including a SELECT node, a GROUP BY node, and an AGGREGATE node may be generated. Subsequently, the synthesizer (140) may perform a constraint check and determine that there are no structural errors if it determines that the GROUP-AGG constraint is correctly connected between the GROUP BY node and the AGGREGATE node.

[0034] Meanwhile, the synthesizer (140) can determine that there is a structural error when a structure is created to JOIN the first table and the second table during the reassembly process but the PK-FK relationship between the two tables is not defined, and can perform reassembly by changing the priority to the second candidate graph (e.g., similarity 0.82).

[0035] In operation 207, the converter (150) can generate SQL based on the prediction skeleton graph. According to one embodiment, the converter (150) maps the slots of the prediction skeleton graph to tables and columns of the storage (120) and can generate executable SQL based on the mapped tables and columns. The converter (150) can convert the operator node structure of the prediction skeleton graph to conform to SQL syntax to generate a complete SQL query including SELECT clauses, FROM clauses, WHERE clauses, GROUP BY clauses, JOIN clauses, etc. According to one embodiment, the converter (150) can map the slots included in the prediction skeleton graph to actual tables and columns existing in the database schema of the storage (120). That is, the converter (150) can refer to the schema information of the current database environment to bind the slots to specific identifiers. According to another embodiment, the converter (150) may omit the mapping process by utilizing a skeleton graph in which actual table and column identifiers are pre-included in the slots when the database is a single database.

[0036] In operation 209, the validator (160) validates the SQL and, if the validation of the SQL is successful, can save the predicted skeleton graph to the repository (120). According to one embodiment, the validator (160) can perform syntax validation, schema constraint validation, and execution validation on the SQL.

[0037] In this embodiment, syntax verification checks whether the generated SQL complies with standard SQL syntax rules and can verify keyword errors, parenthesis mismatches, clause order errors, etc. For example, the verifier (160) can check whether clauses such as SELECT, FROM, WHERE, and GROUP BY are placed in the correct order, whether the syntax of functions such as SUM() is correct, and whether semicolons are correctly positioned.

[0038] In this embodiment, schema constraint verification involves verifying a set of constraints that examine and guarantee the integrity of the schema, and can verify domain constraints, key constraints, entity integrity, referential integrity, etc. For example, the verifier (160) can verify the integrity of the schema by checking whether each attribute value of the SQL is within the allowed data type and value range, checking whether the uniqueness of the primary key and unique key is guaranteed, and checking whether the primary key value of the table referenced by the foreign key exists.

[0039] In this embodiment, execution verification is performed by executing SQL on an actual database to confirm whether it is executed normally without runtime errors, and can be performed in a test environment.

[0040] In this embodiment, if all verifications are successful, the verifier (160) can store the predicted skeleton graph in the storage (120) by linking it with natural language information. This allows the verified skeleton graph to be searched as a candidate and reused when similar natural language requirements are input in the future, and the system can continuously learn and improve performance.

[0042] The device (101) according to the present embodiment has the advantage of effectively reducing the search space and improving the accuracy of SQL generation compared to the existing method of encoding the entire database schema by systematically accumulating skeleton graphs corresponding to natural language requirements in a storage (120) and reusing a verified query structure through a search based on similar requirements.

[0043] In addition, the device (101) according to the present embodiment has the advantage of being able to significantly increase the generation rate of executable SQL by explicitly expressing structural constraints such as PK-FK relationships, GROUP-AGG binding, and scope constraints in a skeleton graph and verifying the consistency of constraints during the graph reassembly process, thereby blocking in advance the generation of SQL that is grammatically correct but causes errors during execution.

[0044] In addition, the device (101) according to the present embodiment has the advantage of significantly improving data accessibility by automating the entire process from natural language input to SQL generation, verification, and updating of the repository (120), thereby enabling even general users who are not database experts to perform complex data queries, and enabling the implementation of an adaptive system that can effectively respond to continuously evolving data requirements.

[0046] According to various embodiments, an apparatus for performing Text-to-SQL based on a skeleton graph repository comprises: a repository in which a plurality of skeleton graphs are stored; a searcher that obtains natural language information from a user and obtains at least one candidate graph information connected to the natural language information from the repository; a synthesizer that reassembles the at least one candidate graph information to generate a predicted skeleton graph; a converter that generates SQL based on the predicted skeleton graph; and a validator that verifies the SQL and, if the verification of the SQL is successful, stores the predicted skeleton graph in the repository.

[0047] According to various embodiments, the skeleton graph includes an operator node comprising a plurality of SQL operations, a constraint determining a structural error for the SQL, and a slot which is an abstract identifier for a table and a column.

[0048] According to various embodiments, the searcher is configured to extract intent information representing the user's requirements, keyword information representing a core word or phrase of the natural language information, and embedding information quantifying the natural language information from the natural language information, calculate similarity using the intent information, the keyword information, and the embedding information, and obtain at least one candidate graph information based on the similarity.

[0049] According to various embodiments, the synthesizer is configured to determine priority and reassemble based on the similarity of the at least one candidate graph information.

[0050] According to various embodiments, the synthesizer is configured to determine whether the predicted skeleton graph is the structural error based on the constraints, and to reassemble by changing the priority of the at least one candidate graph information only if the predicted skeleton graph is determined to be the structural error.

[0051] According to various embodiments, the converter is configured to map the slot to the table and column of the storage, and to generate SQL based on the mapped table and column.

[0052] According to various other embodiments, a method of operation of a device for performing Text-to-SQL based on a skeleton graph repository comprises: a step of obtaining natural language information from a user by means of a searcher of the device; a step of obtaining at least one candidate graph information connected to the natural language information from a repository in which a plurality of skeleton graphs are stored by means of the searcher; a step of generating a predicted skeleton graph by reassembling the at least one candidate graph information by means of a synthesizer of the device; a step of generating an SQL statement based on the predicted skeleton graph by means of a converter of the device; and a step of verifying the SQL by means of a validator of the device, and if the verification of the SQL is successful, storing the predicted skeleton graph in the repository.

[0054] As used in this document, the terms “module” or “part” include a unit composed of hardware, software, or firmware, and may be used interchangeably with terms such as logic, logic block, component, or circuit, for example. “Module” or “part” may be a component formed integrally or a minimum unit or part thereof that performs one or more functions. “Module” or “part” may be implemented mechanically or electronically and may include, for example, an application-specific integrated circuit (ASIC) chip, field-programmable gate arrays (FPGAs), or programmable logic device known or to be developed that performs certain operations, and may be executed by a processor (120). At least part of the device (e.g., modules or functions thereof) or method (e.g., operations) according to various embodiments may be implemented as instructions stored in a computer-readable storage medium (e.g., memory (130)) in the form of a program module. When the above instruction is executed by a processor (e.g., processor (120)), the processor may perform a function corresponding to the above instruction. Computer-readable recording media may include a hard disk, a floppy disk, a magnetic medium (e.g., magnetic tape), an optical recording medium (e.g., CD-ROM, DVD, magneto-optical medium (e.g., floptical disk), built-in memory, etc. Instructions may include code generated by a compiler or code that can be executed by an interpreter. A module or program module according to various embodiments may include at least one of the aforementioned components, some of which may be omitted, or additionally include other components. Operations performed by a module, program module, or other component according to various embodiments may be executed sequentially, in parallel, iteratively, or heuristically, or at least some operations may be executed in a different order, omitted, or other operations may be added.

[0055] Furthermore, the embodiments disclosed in this document are presented for the purpose of explaining and understanding the disclosed technical content and are not intended to limit the scope of this disclosure. Accordingly, the scope of this disclosure should be interpreted to include all modifications or various other embodiments based on the technical concept of this disclosure.

Claims

Claim 1 A device for performing Text-to-SQL based on a skeleton graph repository, comprising: a repository in which a plurality of skeleton graphs are stored; a searcher that obtains natural language information from a user and obtains at least one candidate graph information connected to the natural language information from the repository; a synthesizer that reassembles the at least one candidate graph information to generate a predicted skeleton graph; a converter that generates SQL based on the predicted skeleton graph; and a validator that verifies the SQL and, if the verification of the SQL is successful, stores the predicted skeleton graph in the repository. Claim 2 A device according to claim 1, wherein the skeleton graph comprises an operator node including a plurality of SQL operations, a constraint for determining a structural error for the SQL, and a slot which is an abstract identifier for a table and a column. Claim 3 In claim 2, the device is configured such that the searcher extracts intent information indicating the user's requirements, keyword information indicating a core word or phrase of the natural language information, and embedding information quantified from the natural language information, calculates similarity using the intent information, the keyword information, and the embedding information, and obtains at least one candidate graph information based on the similarity. Claim 4 In claim 3, the synthesizer is configured to determine priority and reassemble based on the similarity of the at least one candidate graph information. Claim 5 In claim 4, the synthesizer is configured to determine whether the prediction skeleton graph is the structural error based on the constraints, and to reassemble by changing the priority of the at least one candidate graph information only when the prediction skeleton graph is determined to be the structural error. Claim 6 In claim 5, the converter is configured to map the slot to the table and column of the storage and to generate SQL based on the mapped table and column. Claim 7 A method of operation of a device for performing Text-to-SQL based on a skeleton graph repository, comprising: a step of obtaining natural language information from a user by means of a searcher of the device; a step of obtaining at least one candidate graph information connected to the natural language information from a repository in which a plurality of skeleton graphs are stored by means of the searcher; a step of generating a predicted skeleton graph by reassembling the at least one candidate graph information by means of a synthesizer of the device; a step of generating an SQL statement based on the predicted skeleton graph by means of a converter of the device; and a step of verifying the SQL by means of a validator of the device, and if the verification of the SQL is successful, storing the predicted skeleton graph in the repository. Claim 8 In claim 7, the method comprises a skeleton graph including an operator node comprising a plurality of SQL operations, a constraint determining a structural error for the SQL, and a slot which is an abstract identifier for a table and a column. Claim 9 In claim 8, the step of obtaining candidate graph information comprises extracting intent information representing the user's requirements, keyword information representing a core word or phrase of the natural language information, and embedding information quantified from the natural language information, calculating similarity using the intent information, the keyword information, and the embedding information, and obtaining at least one candidate graph information based on the similarity. Claim 10 In claim 9, the step of generating the prediction skeleton graph is a method of reassembling by determining priority based on the similarity of at least one candidate graph information. Claim 11 In claim 10, the step of generating the prediction skeleton graph comprises determining whether the prediction skeleton graph is the structural error based on the constraints, and, only if the prediction skeleton graph is determined to be the structural error, changing the priority of the at least one candidate graph information and reassembling it. Claim 12 In claim 11, the step of generating the SQL comprises mapping the slot to the table and column of the storage, and generating the SQL statement based on the mapped table and column.

Images