Natural language-based query statement conversion method and device and storage medium

Abstract

The invention provides a query statement conversion method and device based on a natural language and a storage medium. The method comprises the steps that a natural language query statement input by a user is received, a pre-trained large language model is used for decomposing the natural language query statement into a plurality of subtasks, and each subtask corresponds to one query operation; analyzing each subtask, and performing step-by-step reasoning based on a mode knowledge base and a large language model in a database to generate an intermediate representation corresponding to each subtask; and summarizing the intermediate representation corresponding to each subtask, and converting the summarized intermediate representation into a complete target query statement by utilizing a large language model. According to the method, the accuracy of semantic understanding can be improved, the reliable target query statement is generated, the conversion efficiency is improved, and system debugging and optimization are facilitated.

Description

Technical Field

[0001] The present application relates to the field of artificial intelligence technology, and in particular to a natural language-based query statement conversion method, device and storage medium. Background Art

[0002] With the development of data-driven applications, users have an increasing demand for obtaining information from databases. However, traditional SQL query statements require users to have certain database knowledge and SQL syntax skills, which creates a high technical threshold for ordinary users. In order to lower this threshold, the Natural Language to SQL (NL2SQL) conversion system came into being. The system aims to automatically convert users' natural language queries into SQL statements to facilitate query operations in the database.

[0003] Existing NL2SQL conversion systems mainly rely on pre-trained language models and rule matching methods. Although such systems perform well in processing simple queries, they still have significant defects when facing complex natural language queries. Specifically, these systems have limited semantic understanding capabilities and are prone to misunderstanding the user's query intent, resulting in inaccurate generated SQL statements. In addition, due to the inefficient processing of complex queries, the system has a large lag in response time, and the generated SQL statements are often accompanied by grammatical or logical errors, which cannot meet the high-precision requirements of practical applications.

[0004] On the other hand, the NL2SQL conversion system that relies on a large language model improves its natural language understanding capabilities through a large amount of training data, and in theory can generate SQL statements better. However, such systems still have semantic misunderstandings when processing complex queries. At the same time, because the large language model is limited by the token length during processing, it cannot fully utilize the database schema information, resulting in inaccurate query results. In addition, the "black box" nature of the large language model makes the debugging and optimization process difficult, and it is difficult for developers to locate specific problems in the generated SQL statements and make effective improvements.

[0005] In summary, the existing NL2SQL conversion system has many problems in semantic understanding, accuracy of SQL generation and system debugging. There is an urgent need for a solution that can improve semantic understanding capabilities, generate reliable SQL statements, and improve system transparency and debuggability. Summary of the invention

[0006] In view of this, the embodiments of the present application provide a natural language-based query statement conversion method, device and storage medium to solve the problems of inaccurate semantic understanding, unreliable generated target statements, low conversion efficiency and non-debuggable system in the prior art.

[0007] According to a first aspect of an embodiment of the present application, a natural language-based query statement conversion method is provided, comprising: receiving a natural language query statement input by a user, and using a pre-trained large language model to decompose the natural language query statement into multiple subtasks, wherein each subtask corresponds to a query operation; parsing each subtask, and performing step-by-step reasoning based on a pattern knowledge base in a database and a large language model to generate an intermediate representation corresponding to each subtask; aggregating the intermediate representation corresponding to each subtask, and using the large language model to convert the aggregated intermediate representation into a complete target query statement.

[0008] According to a second aspect of an embodiment of the present application, a natural language-based query statement conversion device is provided, comprising: a decomposition module, configured to receive a natural language query statement input by a user, and use a pre-trained large language model to decompose the natural language query statement into multiple subtasks, wherein each subtask corresponds to a query operation; an inference module, configured to parse each subtask, and perform step-by-step inference based on a pattern knowledge base in a database and a large language model to generate an intermediate representation corresponding to each subtask; and a conversion module, configured to summarize the intermediate representation corresponding to each subtask, and use the large language model to convert the summarized intermediate representation into a complete target query statement.

[0009] According to a third aspect of an embodiment of the present application, an electronic device is provided, including a memory, a processor, and a computer program stored in the memory and executable on the processor, wherein the steps of the above method are implemented when the processor executes the computer program.

[0010] According to a fourth aspect of an embodiment of the present application, a computer-readable storage medium is provided, which stores a computer program, and when the computer program is executed by a processor, the steps of the above method are implemented.

[0011] At least one of the above technical solutions adopted in the embodiments of the present application can achieve the following beneficial effects:

[0012] By receiving the natural language query statement input by the user, the natural language query statement is decomposed into multiple subtasks using the pre-trained large language model, where each subtask corresponds to a query operation; each subtask is parsed, and step-by-step reasoning is performed based on the pattern knowledge base in the database and the large language model to generate the intermediate representation corresponding to each subtask; the intermediate representation corresponding to each subtask is summarized, and the summarized intermediate representation is converted into a complete target query statement using the large language model. This application can improve the accuracy of semantic understanding, generate reliable target query statements, improve conversion efficiency, and facilitate system debugging and optimization. BRIEF DESCRIPTION OF THE DRAWINGS

[0013] In order to more clearly illustrate the technical solutions in the embodiments of the present application, the drawings required for use in the embodiments or the description of the prior art will be briefly introduced below. Obviously, the drawings described below are only some embodiments of the present application. For ordinary technicians in this field, other drawings can be obtained based on these drawings without paying any creative work.

[0014] Figure 1 It is a flowchart of a natural language-based query statement conversion method provided in an embodiment of the present application;

[0015] Figure 2 It is a structural diagram of a natural language-based query statement conversion device provided in an embodiment of the present application;

[0016] Figure 3 It is a schematic diagram of the structure of an electronic device provided in an embodiment of the present application. DETAILED DESCRIPTION

[0017] In the following description, specific details such as specific system structures, technologies, etc. are provided for the purpose of illustration rather than limitation, so as to provide a thorough understanding of the embodiments of the present application. However, it should be clear to those skilled in the art that the present application may also be implemented in other embodiments without these specific details. In other cases, detailed descriptions of well-known systems, devices, circuits, and methods are omitted to prevent unnecessary details from obstructing the description of the present application.

[0018] It should be understood that the various steps described in the method implementation of the present application can be performed in different orders and / or performed in parallel. In addition, the method implementation may include additional steps and / or omit the steps shown. The scope of the present application is not limited in this respect.

[0019] A natural language to SQL (NL2SQL) conversion system is a system that automatically converts natural language queries entered by users into structured query language (SQL) statements. Its main application scenario is to allow users to query databases through natural language without having to master the complex SQL syntax. This technology is widely used in business intelligence, database management, and question-answering systems. However, developing an efficient and accurate NL2SQL system is quite challenging because the complexity and ambiguity of natural language make semantic understanding difficult, while the generation of SQL statements requires strict syntax and logical structure.

[0020] There are two main types of NL2SQL conversion systems on the market:

[0021] The first category is systems that rely on pre-trained language models and rule matching:

[0022] These systems are usually based on pre-trained natural language processing (NLP) models and combined with specific rule matching to convert natural language to SQL. The advantage of such systems is that they can quickly respond to simple query requests and perform well when processing common queries.

[0023] However, this type of system has the following significant disadvantages:

[0024] Inaccurate semantic understanding: The system is prone to misunderstanding when understanding complex natural language queries and cannot accurately grasp the user's intention. This may be because the corpus or training data of the pre-trained model is not sufficient to cover all possible semantic expressions, or the limitations of rule matching lead to understanding deviations.

[0025] Unreliable SQL statement generation: Due to inaccurate semantic understanding, the generated SQL statements may contain syntax errors or logical errors, resulting in query results that do not meet expectations.

[0026] Low conversion efficiency: When processing complex queries, the system's conversion efficiency is significantly reduced and the response time is longer. This is usually because the system needs to process more semantic analysis and rule matching steps, which tend to slow down the entire process when facing complex queries.

[0027] The second category is systems that rely on large language models:

[0028] Such systems use large pre-trained language models (such as GPT, etc.) to perform NL2SQL conversion. These models are trained with a large amount of natural language text and SQL statements, and in theory can better understand the user's intentions and generate more accurate SQL statements.

[0029] However, systems that rely on large language models also have some significant problems:

[0030] Semantic misunderstandings when processing complex queries: Although large language models have powerful language understanding capabilities, semantic misunderstandings may still occur when processing very complex natural language queries. Such misunderstandings can cause the generated SQL statements to deviate from the user's original intention.

[0031] Token length limit: Since the input of large models is usually limited by the token length, it is impossible to fully process queries containing a large amount of schema information. This limits the performance of the model when facing database queries involving multiple tables, fields, and complex relationships.

[0032] Black box characteristics make debugging difficult: The reasoning process inside a large language model is highly complex and opaque, which makes it difficult for developers to debug and optimize when errors occur in SQL statement generation. Due to the "black box" characteristics of the model, it is difficult to locate specific problems, and thus it is impossible to effectively correct or improve the system.

[0033] Based on the above shortcomings of the prior art, the existing NL2SQL system has the following major technical problems in practical applications:

[0034] Inaccurate semantic understanding: The system can easily misunderstand the user's query intent, resulting in the generated SQL statements not meeting expectations.

[0035] The generated SQL statements are unreliable: Due to semantic misunderstandings and model limitations, the generated SQL statements may contain syntax and logical errors.

[0036] Low efficiency in processing complex queries: When faced with complex natural language queries, the existing system has low conversion efficiency and long response time, and cannot meet users' requirements for real-time performance.

[0037] The system is not debuggable: Due to the black box characteristics of large language models, the debugging and optimization process of existing systems is extremely difficult, and it is difficult to improve the quality of generated SQL statements.

[0038] The problems existing in the above-mentioned prior art limit the performance of the NL2SQL system in practical applications, especially in database query scenarios requiring high precision and high reliability.

[0039] In view of the above-mentioned problems existing in the prior art, the present application proposes a natural language to SQL (NL2SQL) conversion system based on the Least to Most Prompting (L2M) method, which aims to solve the problems existing in the prior art, such as inaccurate semantic understanding, unreliable SQL generation, inefficient processing of complex queries, and difficult system debugging.

[0040] First, this application decomposes the complex natural language query input by the user into multiple subtasks by introducing a mechanism of refined prompts. Each subtask corresponds to an operation unit in the query, such as the query action, target table, field, and condition. Through this decomposition method, the system can gradually process complex queries and simplify complex semantic understanding tasks into multiple smaller and easier to handle subtasks. The system uses a large language model combined with a subtask decomposition knowledge base and a pattern knowledge base in the database to perform multi-step reasoning for each subtask and gradually generate intermediate representations. This process effectively avoids misunderstandings in overall semantic understanding through step-by-step analysis and reasoning, and improves the accuracy of natural language to SQL conversion.

[0041] Secondly, when generating SQL statements, this application aggregates the intermediate representations of each subtask and uses the large language model for reasoning again to generate a complete target SQL query statement. Since the intermediate representation has clarified the specific operation content of each subtask and its corresponding database structure information, the final generated SQL statement is more reliable in syntax and logic. In addition, through this method of step-by-step reasoning and refined prompts, the system can effectively handle complex queries and avoid errors that may occur when generating SQL statements at one time. This method not only improves the reliability of generating SQL statements, but also significantly improves the processing efficiency of complex queries.

[0042] In addition, this application introduces the L2M method, which enables the system to generate clear intermediate representations during the process of subtask decomposition and step-by-step reasoning. These intermediate representations not only make the SQL generation process more transparent, but also facilitate the debugging and optimization of the system. Developers can accurately locate the problem based on the intermediate representation and reasoning process, and then optimize and improve the system in a targeted manner. This feature effectively solves the defect of the system being undebuggable in the prior art, and greatly improves the maintainability and reliability of the system.

[0043] The contents of the technical solution of the present application are described in detail below with reference to the accompanying drawings and specific embodiments.

[0044] Figure 1 It is a flowchart of a natural language-based query statement conversion method provided in an embodiment of the present application. Figure 1 The natural language-based query statement conversion method can be executed by the server. Figure 1 As shown, the natural language-based query statement conversion method may specifically include:

[0045] S101, receiving a natural language query statement input by a user, and using a pre-trained large language model to decompose the natural language query statement into multiple subtasks, where each subtask corresponds to a query operation;

[0046] S102, parsing each subtask and performing step-by-step reasoning based on the pattern knowledge base and the large language model in the database to generate an intermediate representation corresponding to each subtask;

[0047] S103, summarizing the intermediate representations corresponding to each subtask, and using the large language model to convert the summarized intermediate representations into a complete target query statement.

[0048] In some embodiments, a pre-trained large language model is used to decompose a natural language query into multiple subtasks, including:

[0049] Based on the natural language query statement, the knowledge information related to the query is extracted from the preset subtask decomposition knowledge base, where the subtask decomposition knowledge base is used to store the knowledge related to the natural language query intention recognition;

[0050] Generate prompt information based on the extracted knowledge information, where the prompt information is used to guide the large language model to perform task decomposition;

[0051] Call the large language model and decompose the natural language query statement into multiple subtasks based on the generated prompt information.

[0052] Specifically, this embodiment provides a method for decomposing a natural language query into multiple subtasks using a pre-trained large language model. The method extracts knowledge information related to the query from a subtask decomposition knowledge base and generates prompt information based on the information, thereby guiding the large language model to decompose the natural language query into multiple subtasks for step-by-step processing.

[0053] First, the user enters a natural language query statement through the system's front-end interface. The query statement may contain multiple query conditions or complex logical relationships, such as "find sales personnel who have at least one performance A in the past year and have worked in Shanghai." The query statement expresses that the user wants to obtain employee information under specific conditions from the database.

[0054] With the above example as the background, the subtask decomposition process is described in detail below in combination with a specific embodiment, which may specifically include the following steps:

[0055] Step S1: User inputs a natural language query

[0056] The user enters the above natural language query statement into the system. The system receives the input and prepares to enter the subtask decomposition process.

[0057] Step S2: Obtain subtask decomposition knowledge base and generate prompt information

[0058] The system first accesses the preset subtask decomposition knowledge base. This knowledge base contains knowledge information related to natural language query intent recognition, such as common query types, table names, field names, operators, and the relationship between them. By matching the query statement entered by the user, the system extracts knowledge information related to the current query from the knowledge base.

[0059] After extracting relevant knowledge information, the system generates prompt information for guiding the large language model. For example, for the above query statement, the prompt information may include the following:

[0060] Identify that the main operation involved in the query statement is "find" (corresponding to the SELECT operation in SQL).

[0061] Extract the main fields involved in the query conditions, such as "Performance Evaluation" and "Work Location".

[0062] Extract the target object, such as the Salesperson table.

[0063] The generation process of prompt information is the key, which ensures that the large language model can accurately understand the user's query intention in the subsequent task decomposition process and reasonably decompose it into multiple subtasks.

[0064] Step S3: Call the large language model for task decomposition

[0065] The system calls the pre-trained large language model and performs task decomposition on the user's natural language query based on the generated prompt information. Specifically, the large language model decomposes the entire query into multiple subtasks, each of which corresponds to a smaller query unit. For example, for the above query, the model may decompose it into the following subtasks:

[0066] Query operation: SELECT

[0067] Target table: Salesperson table

[0068] Condition 1: Performance evaluation field, condition is "at least once in the past year was A"

[0069] Condition 2: Work location field, condition is "used to be in Shanghai"

[0070] Through this decomposition, the system converts complex queries into a series of more manageable subtasks, each of which can be executed separately and finally aggregated into a complete SQL query statement. This task decomposition method significantly improves the system's semantic understanding ability and the accuracy of generating SQL statements.

[0071] For example, in another example, the natural language query entered by the user is "first-line managers who have engineering-related experience, whose performance in the last two times was at least B+, and who have served in Beijing", the natural language query can be decomposed into the following subtasks:

[0072] 1. action: query

[0073] 2. Target: Employee information table

[0074] 3. conditions:

[0075] "Former function": "Engineering"

[0076] "Performance evaluation": "At least one of the last two performance evaluations was B+"

[0077] "Previous location":"Beijing"

[0078] "Talent Stratification": "First-line Managers"

[0079] Through the technical solution of the present embodiment, the system can effectively decompose the natural language query input by the user into multiple subtasks, making the subsequent SQL generation process more accurate and efficient. This decomposition process not only improves the system's ability to handle complex queries, but also provides more transparency for system debugging and optimization.

[0080] In some embodiments, each subtask is parsed and step-by-step reasoning is performed based on a pattern knowledge base and a large language model in a database to generate an intermediate representation corresponding to each subtask, including:

[0081] Analyze the subtasks and determine the operation content corresponding to each subtask;

[0082] Acquire structural information related to the subtask from the pattern knowledge base of the database according to the key items of the subtask;

[0083] Generate prompt information for reasoning based on the operation content and structural information corresponding to the subtask;

[0084] The large language model is called to perform reasoning using the generated prompt information to generate the intermediate representation corresponding to each subtask.

[0085] Specifically, this embodiment also provides a method for parsing each subtask and gradually reasoning based on the pattern knowledge base and the large language model in the database to generate an intermediate representation corresponding to each subtask. The method parses the subtask, obtains relevant structural information, generates prompt information and performs reasoning, and finally obtains the intermediate representation of each subtask, laying the foundation for generating a complete SQL query statement.

[0086] The following is a detailed description of the subtask reasoning process of the present application in conjunction with a specific example. The subtask reasoning process of the present application may include the following steps:

[0087] Step S1: Parsing subtasks

[0088] The system first parses each decomposed subtask to determine the specific operation content corresponding to the subtask. Specifically, the system identifies its core operation by analyzing the semantic information of the subtask. For example, for a subtask "query the performance data of sales staff in a certain time period", the system will parse out that the main operation of the subtask is "query" (SELECT), the target table is "sales staff performance table", and the relevant query conditions.

[0089] Step S2: Determine whether subtask reasoning is completed

[0090] After parsing is completed, the system will determine whether the reasoning of the current subtask is clear enough. If the system has been able to determine all the operation contents and related conditions of the subtask, it can directly generate the intermediate representation of the subtask and summarize it. If the reasoning is not yet complete, the system will further perform data acquisition and reasoning processing.

[0091] Step S3: Obtaining structural information from the pattern knowledge base

[0092] If the subtask reasoning is not completed, the system will obtain the structural information related to the subtask from the schema knowledge base in the database based on the key items of the subtask (such as table name, field name, etc.). This structural information usually includes the name of the database table, field name, field type, the relationship between the field and the table, etc. For example, if the subtask involves "querying the performance field in the salesperson performance table", the system will extract the schema information related to the "salesperson performance table" from the schema knowledge base, such as the field names and data types contained in the table.

[0093] Step S4: Generate prompt information and call the large language model for reasoning

[0094] After obtaining the relevant structural information, the system combines the operation content of the subtask and the schema information obtained from the pattern knowledge base to generate prompt information for large language model reasoning. For example, for the subtask of querying "sales staff with performance A in the past year", the system will generate corresponding prompt information, including the target table "sales staff performance table", the query condition "performance A", and other contents.

[0095] Next, the system calls the pre-trained large language model and uses the generated prompt information for reasoning. The large language model gradually generates an intermediate representation of the subtask based on the prompt information. The intermediate representation may include specific SQL fragments or other structured data, indicating the operation content and execution conditions of the subtask.

[0096] Step S5: Aggregate intermediate representation

[0097] After the intermediate representations of all subtasks are generated, the system aggregates them to ensure that the reasoning results of each subtask can together form a complete and coherent SQL query statement. The final aggregated intermediate representation provides the basis for the subsequent generation of a complete SQL query statement.

[0098] For example, in another example, the specific implementation process of the subtask reasoning process may include the following content:

[0099] First, identify the query type:

[0100] Through pre-trained language models and rule matching, the main actions of the query are identified, such as SELECT, INSERT, UPDATE, etc. For example, the main action of the input query is "find", which corresponds to the SELECT statement in SQL.

[0101] Next, determine the query object:

[0102] Extract the main objects from the query, such as table name, field name, etc. For example, the main object of the input query is "first-line managers", which corresponds to the employee table in the database.

[0103] Then, extract the filter conditions:

[0104] Extract the corresponding fields and enumerations from the query. For example, if the filter condition of the input query is "Performance evaluation: at least one of the last two performances is b+", it corresponds to the two fields last_one_performance_result and last_two_performance_result and the corresponding enumerations "B+", "A"; integrate the intermediate results obtained by step-by-step reasoning to generate an intermediate representation. For example:

[0105] action:SELECT

[0106] target:pub_longfor_employee_info

[0107] conditions:

[0108] [{

[0109] "Performance evaluation: at least one of the last two performances was b+":[{

[0110] "column":"last_one_performance_result",

[0111] "column_cn":"The last performance result",

[0112] "condition":"",

[0113] "enum_hits":[

[0114] "B+",

[0115] "A"

[0116] ],

[0117] "table":"pub_longfor_employee_info"

[0118] },

[0119] {

[0120] "column":"last_two_performance_result","column_cn":"The second to last performance result",

[0121] "condition":"",

[0122] "enum_hits":[

[0123] "B+",

[0124] "A"

[0125] ],

[0126] "table":"pub_longfor_employee_info"

[0127] } ]

[0129] },{

[0130] "Previous location: Beijing":[{

[0131] "column":"location_pre_change",

[0132] "column_cn":"Work location before change",

[0133] "condition":"",

[0134] "enum_hits":[

[0135] "Beijing"

[0136] ],

[0137] "table":"f02_hr_employee_change_detail_info"},

[0138] {

[0139] "column":"location_post_change",

[0140] "column_cn":"Work location after change",

[0141] "condition":"",

[0142] "enum_hits":[

[0143] "Beijing"

[0144] ],

[0145] "table":"f02_hr_employee_change_detail_info"

[0146] } ]

[0148] }]

[0149] Through the technical solution of the present embodiment, the system can efficiently parse and infer the operation content of each subtask and generate an accurate intermediate representation. This method uses a large language model combined with a database schema knowledge base to ensure that the reasoning process of each subtask is detailed and conforms to the database structure, thereby improving the accuracy and reliability of the SQL query statements generated by the system.

[0150] In some embodiments, parsing the subtasks to determine the operation content corresponding to each subtask includes:

[0151] Use a pre-trained language model to perform semantic analysis on each subtask to identify the key elements in the subtask;

[0152] The query operations in the subtasks are identified by rule matching, and the database objects related to the query operations are determined to determine the operation content corresponding to each subtask.

[0153] Specifically, this embodiment also provides a method for parsing subtasks and determining the operation content corresponding to each subtask. The method combines pre-trained language models and rule matching technology to perform semantic analysis on each subtask, identify key elements and query operations, and determine database objects related to the query operation, thereby clarifying the specific operation content of each subtask.

[0154] In this embodiment, a pre-trained language model is first used to perform semantic analysis on each subtask. Specifically, the system inputs the subtask into the pre-trained language model, and the model analyzes the natural language content of the subtask to identify the key elements in the subtask. The key elements usually include the query target (such as table name, field name), operation action (such as query, update), conditional restrictions (such as field value range), etc.

[0155] For example, a natural language query entered by a user may involve "find salespeople with performance A in the past year." After the query is broken down into one or more subtasks, the system identifies the following key elements through semantic analysis:

[0156] Target table: Salesperson table

[0157] Target Field: Performance Field

[0158] Time range: Past year

[0159] Target value: Performance is A

[0160] Furthermore, after identifying the key elements, the system further uses rule matching technology to identify the query operations in the subtask. Rule matching is based on a set of predefined rules that can map descriptions in natural language to corresponding SQL operations or database objects. For example, rule matching can map "find" to the SELECT operation in SQL and "update" to the UPDATE operation.

[0161] Through rule matching, the system can determine the specific query operations involved in each subtask. For example, for the above subtask, the system identifies through rule matching that the main query action is "find", and the corresponding SQL operation is SELECT. In addition, the system also identifies the database objects involved in the operation, namely the "salesperson table" and the related "performance fields".

[0162] Furthermore, combined with the results of semantic analysis and rule matching, the system finally determines the specific operation content of each subtask. The operation content usually includes the operation type (such as SELECT, INSERT, UPDATE), the target database object (such as table name, field name), and the operation condition (such as the condition in the WHERE clause). This information will serve as the basis for subsequent reasoning and generation of intermediate representations.

[0163] For example, in the above example, the operation content of the subtask will be determined as:

[0164] Operation type: SELECT

[0165] Target table: Salesperson table

[0166] Query conditions: Performance in the past year was A

[0167] Through this parsing process, the system can accurately understand and extract the core operation content of each subtask, laying the foundation for the subsequent SQL generation process.

[0168] The parsing method described in this embodiment can effectively identify and determine the operation content of each subtask by combining the semantic analysis capability of the pre-trained language model and the rule matching technology. This method not only improves the accuracy of subtask parsing, but also provides more reliable data support for the subsequent SQL statement generation process, thereby enhancing the performance and accuracy of the entire NL2SQL system.

[0169] In some embodiments, prompt information for reasoning is generated according to the operation content and structure information corresponding to the subtask, including:

[0170] Extracting main object information related to the operation content from the subtask, and extracting condition information related to the subtask based on the extracted main object information;

[0171] The main object information and conditional information are combined to generate prompt information for guiding the large language model to perform reasoning.

[0172] Specifically, this embodiment provides a method for generating prompt information for reasoning based on the operation content and structure information corresponding to the subtask. The method extracts the main object information and related condition information from the subtask, combines them and generates prompt information to guide the large language model to perform further reasoning, thereby generating an accurate intermediate representation.

[0173] In this embodiment, the system first extracts the main object information related to the operation content from each subtask. The main object information usually includes the table name and field name of the database, which are the core elements for executing SQL queries.

[0174] For example, if a subtask involves querying the information of "first-line managers", the system will parse out that the main object of this subtask is the "employee table" in the database. In this table, specific fields such as the "position" field can correspond to "first-line managers", so the system extracts the "employee table" and "position" fields as the main object information of this subtask.

[0175] Furthermore, after determining the main object information, the system further extracts the condition information related to it from the subtask. The condition information usually refers to the specific value or enumeration value of the database field, and these conditions are used to refine the scope of the query or limit the query results.

[0176] For example, a user query may include a filter condition such as "Performance evaluation: at least one of the last two performances was B+". The system will identify the database fields corresponding to this condition - "last_one_performance_result" and "last_two_performance_result" fields, and further extract the relevant enumeration values ​​"B+" and "A" of these fields. This condition information is crucial for generating accurate SQL query statements.

[0177] Furthermore, after extracting the main object information and condition information, the system combines this information to generate prompt information for guiding the reasoning of the large language model. The generation of prompt information is a key step, which directly affects whether the large language model can accurately understand the user's query intent in the subsequent reasoning process and generate the corresponding SQL statement.

[0178] For example, combining the aforementioned main object information (the "employee table" and its "position" field) and condition information (the "last_one_performance_result" and "last_two_performance_result" fields and their enumeration values ​​"B+" and "A"), the system will generate the following prompt information:

[0179] Target table: Employee table

[0180] Target field: Position field (corresponding to "first-line manager")

[0181] Query condition: At least one of the two most recent results in the performance evaluation field is B+

[0182] This hint information can clearly convey the user's query intention to the large language model and provide guidance for generating accurate intermediate representations.

[0183] Through the method of the present embodiment described above, the system can effectively extract and integrate the main object information and condition information of the subtask, thereby generating accurate prompt information. This prompt information is used to guide the large language model to perform reasoning, so that the system can generate a more accurate and reliable intermediate representation, thereby improving the accuracy and effectiveness of the final generated SQL query statement.

[0184] In some embodiments, the intermediate representations corresponding to each subtask are aggregated, and the aggregated intermediate representations are converted into a complete target query statement using a large language model, including:

[0185] Arrange and summarize the intermediate representations corresponding to each subtask, and build a comprehensive intermediate representation structure based on the summarized intermediate representations;

[0186] Call the large language model to perform comprehensive reasoning based on the natural language query statement and the summarized intermediate representation to generate a complete target query statement.

[0187] Specifically, this embodiment describes a method for summarizing the intermediate representations corresponding to each subtask and converting the summarized intermediate representations into a complete target query statement using a large language model. The method constructs a comprehensive intermediate representation structure by collating and summarizing the intermediate representations of the subtasks, and ultimately generates an accurate SQL query statement.

[0188] In this embodiment, the system first organizes the intermediate representation generated by each subtask. The intermediate representation may include the operation type of the subtask (such as SELECT, UPDATE, etc.), the target table, the field name, the condition, and the related SQL fragment.

[0189] For example, for a natural language query entered by a user, "Find salespeople who have had at least one performance A in the past year and have worked in Shanghai", the query may be decomposed into the following subtasks:

[0190] Subtask 1: Determine the target table "employee table";

[0191] Subtask 2: Condition 1—Performance in the past year was A;

[0192] Subtask 3: Condition 2—having worked in Shanghai.

[0193] After each subtask completes reasoning and generates intermediate representations, the system organizes and summarizes these intermediate representations. For example:

[0194] Subtask 1 intermediate representation: the target table is "employee table";

[0195] The middle of subtask 2 indicates that: the field corresponding to condition 1 is "Performance", and the condition is "A at least once in the past year";

[0196] The middle part of subtask 3 indicates that the field corresponding to condition 2 is "work location" and the condition is "Shanghai".

[0197] Furthermore, after collating and summarizing the intermediate representations of each subtask, the system integrates this information into a comprehensive intermediate representation structure, which combines the contents of all subtasks to ensure that the final generated SQL query statement can cover the user's entire query intent.

[0198] For example, the above intermediate representations can be integrated into the following comprehensive structure:

[0199] Target table: Employee table

[0200] Query conditions:

[0201] Condition 1: The performance field is A at least once in the past year

[0202] Condition 2: The work location field is Shanghai

[0203] Step 3: Call the large language model for comprehensive reasoning

[0204] Through the method of the present embodiment, after obtaining the comprehensive intermediate representation structure, the system calls the pre-trained large language model, uses the structure and the user's natural language query as input, and performs comprehensive reasoning. The large language model generates a complete SQL query statement by jointly analyzing the comprehensive intermediate representation and the natural language query.

[0205] In some embodiments, after generating a complete target query statement, the method further includes:

[0206] The generated target query statement is output, wherein the target query statement is used to represent the user's query intention and to perform related database operations.

[0207] Specifically, this embodiment describes a method for further outputting a complete target query statement after generating the query statement. The method aims to ensure that the SQL query statement finally generated accurately reflects the query intention of the user and can be directly used to execute related database operations.

[0208] First, the system converts the user's natural language query into multiple subtasks through the aforementioned process, and gradually infers and generates the intermediate representation of each subtask. After aggregating the intermediate representations of all subtasks, the system uses the large language model to generate the complete target query sentence.

[0209] Furthermore, after generating the target query statement, the system can selectively verify and optimize the query statement. The verification step is to check whether the syntax and logic of the SQL statement are correct to ensure that it can be correctly executed by the database. The optimization step may include rewriting the SQL statement to improve query efficiency, such as by adding indexes, optimizing the order of conditions, etc.

[0210] Furthermore, after verification and optimization, the system outputs the target query statement that is finally generated. The output query statement can be transmitted through an API, a file, or directly through a database connection to facilitate the execution of corresponding database operations.

[0211] For example, in one example, the system can directly send the generated SQL statement to a related database management system (DBMS) through a database interface, and the DBMS executes the query operation and returns the query result. For example, the system can call an API interface, send the SQL statement to a remote database for execution, and receive the query result.

[0212] Furthermore, if the system integrates database management functions, after outputting the SQL query statement, the system can also directly execute the query operation. After execution, the system returns the query results to the user, and the user can view the list of employees that meet the conditions.

[0213] For example, in one example, after the system executes the above SQL statement, the returned results may include information about all employees whose performance was A in the past year and who are currently working in Beijing, such as name, position, performance record, etc.

[0214] Through the above method of this embodiment, the system can not only generate accurate SQL query statements, but also output the statements, and through further verification and optimization, ensure the correctness and execution efficiency of the SQL statements. Finally, the system can directly use the generated query statements to execute related database operations, fully realizing the user's query intention.

[0215] According to the technical solution provided in the embodiments of the present application, the technical solution of the present application has at least the following advantages:

[0216] This application introduces the L2M (Least to Most Prompting) method, adopts the strategy of refined prompts and multi-step reasoning, and effectively solves the problems of inaccurate semantic understanding and unreliable SQL generation in the prior art. By decomposing complex natural language queries into multiple subtasks and gradually reasoning to generate intermediate representations, the system can more accurately capture user intent and generate precise SQL query statements. This refined prompt design greatly improves the accuracy of semantic understanding, while reducing the error rate when generating SQL statements through step-by-step reasoning, thereby improving the overall conversion efficiency.

[0217] This application adopts a multi-module design, including natural language processing, refinement prompts, SQL generation and result verification modules. The modules work closely together to form a stable and reliable system architecture. The natural language processing module is responsible for the initial understanding of user queries, the refinement prompt module further optimizes query understanding through decomposition and prompts, the SQL generation module generates the final SQL statement based on the intermediate representation, and the result verification module ensures the logical and grammatical correctness of the generated SQL statement. This modular design not only improves the scalability and maintainability of the system, but also ensures the stability and reliability of the system when processing queries of different types and complexities.

[0218] The technical solution of this application can effectively improve the response speed of the system by optimizing the query processing process, especially when facing complex queries. The application of detailed prompts and step-by-step reasoning strategies enables the system to quickly decompose and process complex queries, simplifying query operations that may have been time-consuming into multiple small tasks that are easy to handle. After aggregating and integrating the results of these subtasks, the system can quickly generate SQL query statements that meet user needs, significantly shortening the response time from query input to result output, and greatly improving the user experience.

[0219] Therefore, in summary, this application has not only achieved significant technical progress in semantic understanding and SQL generation by introducing the L2M method, multi-module design and optimized processing flow, but also achieved significant improvements in system stability, reliability and response speed, and has broad application prospects and practical value.

[0220] It should be noted that, with respect to the above-mentioned technical solution of the present application, other alternative solutions and expansion solutions may also be considered in order to achieve the purpose of the invention, so as to further enhance the flexibility and adaptability of the system and meet the needs of different application scenarios.

[0221] For example, different pre-trained language models are used in combination with the L2M method for semantic understanding and SQL generation. In the core technical solution of this application, the pre-trained language model is a key component for realizing the conversion of natural language queries to SQL. Although a specific large language model is used in the current embodiment to complete this task, different pre-trained language models can actually be selected to achieve the same conversion purpose.

[0222] For example: BERT (Bidirectional Encoder Representations from Transformers): BERT is a pre-trained language model based on the Transformer architecture. It is good at processing contextual relationships and can capture complex semantic relationships in input natural language queries. Combined with the L2M method, BERT can effectively decompose and understand complex query statements and generate highly accurate SQL statements.

[0223] GPT (Generative Pre-trained Transformer): GPT is a generative pre-trained model with strong natural language generation and understanding capabilities. By combining the L2M method, GPT can provide more flexible responsiveness in semantic understanding and SQL generation, especially when processing unstructured or complex queries.

[0224] RoBERTa, XLNet, T5 and other models: These models each have different advantages, such as better context understanding, stronger generation capabilities or faster reasoning speed. According to the specific application scenario and requirements, you can choose a suitable model combined with the L2M method to achieve efficient conversion from natural language to SQL.

[0225] By replacing different pre-trained language models, the system can achieve optimal performance in different application scenarios and meet the needs of different users, while maintaining the core advantage of the technical solution, that is, improving the accuracy and efficiency of semantic understanding and SQL generation through the L2M method.

[0226] Another example is the conversion extended to other database query languages. In the basic implementation scheme of this application, the system mainly converts SQL (Structured Query Language). However, in order to adapt to a wider range of application scenarios, the system can also be extended to other types of database query languages, such as NoSQL and GraphQL, to achieve a wider range of data query needs.

[0227] NoSQL (non-relational database query language): NoSQL databases (such as MongoDB and Cassandra) use a query language different from SQL to process large-scale unstructured data. By extending the L2M method, the system can convert natural language queries into a query language suitable for NoSQL databases, supporting different types of query requirements such as document databases, key-value stores, column family stores, and graph databases.

[0228] GraphQL: GraphQL is a flexible query language that allows clients to specify the required data structure instead of predefined queries. By extending the L2M approach to GraphQL, the system can convert natural language queries into complex GraphQL queries that meet the requirements for data accuracy and flexibility.

[0229] Through the above expansion scheme, the system can not only process traditional relational database queries, but also meet the diversified query requirements in modern database technology. This scalability makes this technical solution highly applicable and flexible in a wider range of application scenarios, providing users with a more comprehensive solution.

[0230] By introducing different pre-trained language models and extending to other database query languages, the technical solution of this application demonstrates strong adaptability and extensibility. These alternative and extended solutions not only maintain the core advantages of the system, but also significantly enhance the practicality and performance of the system in different application scenarios, and can provide more users with efficient and accurate natural language query to database query language conversion services.

[0231] The following is an embodiment of the device of the present application, which can be used to execute the embodiment of the method of the present application. For details not disclosed in the embodiment of the device of the present application, please refer to the embodiment of the method of the present application.

[0232] Figure 2 Schematic diagram of the structure of the natural language-based query statement conversion device provided in the embodiment of the present application. Figure 2 As shown, the natural language-based query statement conversion device includes:

[0233] A decomposition module 201 is configured to receive a natural language query sentence input by a user, and decompose the natural language query sentence into a plurality of subtasks using a pre-trained large language model, wherein each subtask corresponds to a query operation;

[0234] The reasoning module 202 is configured to parse each subtask and perform step-by-step reasoning based on the pattern knowledge base and the large language model in the database to generate an intermediate representation corresponding to each subtask;

[0235] The conversion module 203 is configured to aggregate the intermediate representations corresponding to each subtask and convert the aggregated intermediate representations into a complete target query statement using a large language model.

[0236] In some embodiments, Figure 2 The decomposition module 201 extracts query-related knowledge information from a preset subtask decomposition knowledge base based on a natural language query statement, wherein the subtask decomposition knowledge base is used to store knowledge related to natural language query intent recognition; generates prompt information based on the extracted knowledge information, wherein the prompt information is used to guide the large language model to perform task decomposition; and calls the large language model to decompose the natural language query statement into multiple subtasks based on the generated prompt information.

[0237] In some embodiments, Figure 2 The reasoning module 202 parses the subtasks to determine the operation content corresponding to each subtask; obtains structural information related to the subtask from the pattern knowledge base of the database according to the key items of the subtask; generates prompt information for reasoning according to the operation content and structural information corresponding to the subtask; calls the large language model and uses the generated prompt information for reasoning to generate an intermediate representation corresponding to each subtask.

[0238] In some embodiments, Figure 2 The reasoning module 202 uses a pre-trained language model to perform semantic analysis on each subtask to identify key elements in the subtask; uses rule matching to identify query operations in the subtask, determines database objects related to the query operation, and determines the operation content corresponding to each subtask.

[0239] In some embodiments, Figure 2 The reasoning module 202 extracts main object information related to the operation content from the subtask, and based on the extracted main object information, extracts condition information related to the subtask; combines the main object information and the condition information to generate prompt information for guiding the large language model to perform reasoning.

[0240] In some embodiments, Figure 2 The conversion module 203 organizes and summarizes the intermediate representations corresponding to each subtask, and builds a comprehensive intermediate representation structure based on the summarized intermediate representations; calls the large language model, performs comprehensive reasoning based on the natural language query statement and the summarized intermediate representations, and generates a complete target query statement.

[0241] In some embodiments, Figure 2 After generating a complete target query statement, the output module 204 outputs the generated target query statement, wherein the target query statement is used to represent the user's query intention and to perform related database operations.

[0242] Figure 3 Schematic diagram of the structure of the electronic device 3 provided in the embodiment of the present application. Figure 3 As shown, the electronic device 3 of this embodiment includes: a processor 301, a memory 302, and a computer program 303 stored in the memory 302 and executable on the processor 301. When the processor 301 executes the computer program 303, the steps in the above-mentioned method embodiments are implemented. Alternatively, when the processor 301 executes the computer program 303, the functions of the modules / units in the above-mentioned device embodiments are implemented.

[0243] Exemplarily, the computer program 303 may be divided into one or more modules / units, which are stored in the memory 302 and executed by the processor 301 to complete the present application. The one or more modules / units may be a series of computer program instruction segments capable of completing specific functions, which are used to describe the execution process of the computer program 303 in the electronic device 3.

[0244] The electronic device 3 may be a desktop computer, a notebook, a PDA, a cloud server, or other electronic device. The electronic device 3 may include, but is not limited to, a processor 301 and a memory 302. Those skilled in the art will appreciate that Figure 3 It is only an example of the electronic device 3 and does not constitute a limitation of the electronic device 3. It may include more or fewer components than shown in the figure, or a combination of certain components, or different components. For example, the electronic device may also include input and output devices, network access devices, buses, etc.

[0245] The processor 301 may be a central processing unit (CPU), or other general-purpose processors, digital signal processors (DSP), application-specific integrated circuits (ASIC), field-programmable gate arrays (FPGA), or other programmable logic devices, discrete gate or transistor logic devices, discrete hardware components, etc. A general-purpose processor may be a microprocessor or the processor may be any conventional processor, etc.

[0246] The memory 302 may be an internal storage unit of the electronic device 3, for example, a hard disk or memory of the electronic device 3. The memory 302 may also be an external storage device of the electronic device 3, for example, a plug-in hard disk, a smart media card (SMC), a secure digital (SD) card, a flash card, etc. equipped on the electronic device 3. Further, the memory 302 may also include both an internal storage unit and an external storage device of the electronic device 3. The memory 302 is used to store computer programs and other programs and data required by the electronic device. The memory 302 may also be used to temporarily store data that has been output or is to be output.

[0247] The technicians in the relevant field can clearly understand that for the convenience and simplicity of description, only the division of the above-mentioned functional units and modules is used as an example for illustration. In practical applications, the above-mentioned function allocation can be completed by different functional units and modules as needed, that is, the internal structure of the device can be divided into different functional units or modules to complete all or part of the functions described above. The functional units and modules in the embodiment can be integrated in a processing unit, or each unit can exist physically separately, or two or more units can be integrated in one unit. The above-mentioned integrated unit can be implemented in the form of hardware or in the form of software functional units. In addition, the specific names of the functional units and modules are only for the convenience of distinguishing each other, and are not used to limit the scope of protection of this application. The specific working process of the units and modules in the above-mentioned system can refer to the corresponding process in the aforementioned method embodiment, which will not be repeated here.

[0248] In the above embodiments, the description of each embodiment has its own emphasis. For parts that are not described or recorded in detail in a certain embodiment, reference can be made to the relevant descriptions of other embodiments.

[0249] Those of ordinary skill in the art will appreciate that the units and algorithm steps of each example described in conjunction with the embodiments applied for herein can be implemented in electronic hardware, or a combination of computer software and electronic hardware. Whether these functions are performed in hardware or software depends on the specific application and design constraints of the technical solution. Professional and technical personnel can use different methods to implement the described functions for each specific application, but such implementation should not be considered to be beyond the scope of this application.

[0250] In the embodiments provided in the present application, it should be understood that the disclosed devices / computer equipment and methods can be implemented in other ways. For example, the device / computer equipment embodiments described above are only schematic. For example, the division of modules or units is only a logical function division. There may be other division methods in actual implementation. Multiple units or components can be combined or integrated into another system, or some features can be ignored or not executed. Another point is that the mutual coupling or direct coupling or communication connection shown or discussed can be through some interfaces, indirect coupling or communication connection of devices or units, which can be electrical, mechanical or other forms.

[0251] The units described as separate components may or may not be physically separated, and the components shown as units may or may not be physical units, that is, they may be located in one place or distributed on multiple network units. Some or all of the units may be selected according to actual needs to achieve the purpose of the solution of this embodiment.

[0252] In addition, each functional unit in each embodiment of the present application may be integrated into one processing unit, or each unit may exist physically separately, or two or more units may be integrated into one unit. The above-mentioned integrated unit may be implemented in the form of hardware or in the form of software functional units.

[0253] If the integrated module / unit is implemented in the form of a software functional unit and sold or used as an independent product, it can be stored in a computer-readable storage medium. Based on this understanding, the present application implements all or part of the processes in the above-mentioned embodiment method, and can also be completed by instructing the relevant hardware through a computer program. The computer program can be stored in a computer-readable storage medium, and the computer program can implement the steps of the above-mentioned various method embodiments when executed by the processor. The computer program may include computer program code, which may be in source code form, object code form, executable file or some intermediate form. Computer-readable media may include: any entity or device capable of carrying computer program code, recording medium, U disk, mobile hard disk, disk, optical disk, computer memory, read-only memory (ROM), random access memory (RAM), electric carrier signal, telecommunication signal and software distribution medium, etc.

[0254] The above embodiments are only used to illustrate the technical solutions of the present application, rather than to limit them. Although the present application has been described in detail with reference to the aforementioned embodiments, those skilled in the art should understand that they can still modify the technical solutions described in the aforementioned embodiments, or make equivalent replacements for some of the technical features therein. These modifications or replacements do not deviate the essence of the corresponding technical solutions from the spirit and scope of the technical solutions of the embodiments of the present application, and should all be included in the protection scope of the present application.

Claims

1. A query statement conversion method based on natural language, characterized in that: include: Receive a natural language query statement input by a user, and decompose the natural language query statement into a plurality of subtasks using a pre-trained large language model, wherein each subtask corresponds to a query operation; Parsing each of the subtasks, and performing step-by-step reasoning based on a pattern knowledge base and a large language model in a database to generate an intermediate representation corresponding to each of the subtasks; The intermediate representation corresponding to each of the subtasks is aggregated, and the aggregated intermediate representation is converted into a complete target query statement using the large language model.

2. The method according to claim 1, characterized in that The method of using a pre-trained large language model to decompose the natural language query statement into multiple subtasks includes: Based on the natural language query statement, extracting query-related knowledge information from a preset subtask decomposition knowledge base, wherein the subtask decomposition knowledge base is used to store knowledge related to natural language query intent recognition; Generate prompt information based on the extracted knowledge information, wherein the prompt information is used to guide the large language model to perform task decomposition; The large language model is called to decompose the natural language query statement into a plurality of subtasks according to the generated prompt information.

3. The method according to claim 1, characterized in that The parsing of each of the subtasks and performing step-by-step reasoning based on the pattern knowledge base and the large language model in the database to generate an intermediate representation corresponding to each of the subtasks includes: Parsing the subtasks to determine the operation content corresponding to each subtask; Acquiring structural information related to the subtask from a pattern knowledge base of a database according to key items of the subtask; Generate prompt information for reasoning according to the operation content and structure information corresponding to the subtask; The large language model is called to perform reasoning using the generated prompt information to generate an intermediate representation corresponding to each of the subtasks.

4. The method according to claim 3, characterized in that The parsing of the subtasks to determine the operation content corresponding to each subtask includes: Performing semantic analysis on each of the subtasks using a pre-trained language model to identify key elements in the subtask; The query operation in the subtask is identified by rule matching, and the database object related to the query operation is determined to determine the operation content corresponding to each subtask.

5. The method according to claim 3, characterized in that: The generating prompt information for reasoning according to the operation content and structure information corresponding to the subtask includes: Extracting main object information related to the operation content from the subtask, and extracting condition information related to the subtask based on the extracted main object information; The main object information and the condition information are combined to generate prompt information for guiding the large language model to perform reasoning.

6. The method according to claim 1, characterized in that The step of aggregating the intermediate representations corresponding to each of the subtasks and converting the aggregated intermediate representations into a complete target query statement using the large language model includes: Arrange and summarize the intermediate representations corresponding to each of the subtasks, and construct a comprehensive intermediate representation structure based on the summarized intermediate representations; The large language model is called to perform comprehensive reasoning based on the natural language query statement and the summarized intermediate representation to generate a complete target query statement.

7. The method according to claim 6, characterized in that After generating a complete target query statement, the method further includes: The generated target query statement is output, wherein the target query statement is used to represent the user's query intention and to perform related database operations.

8. A query statement conversion device based on natural language, characterized in that: include: A decomposition module is configured to receive a natural language query statement input by a user, and decompose the natural language query statement into a plurality of subtasks using a pre-trained large language model, wherein each of the subtasks corresponds to a query operation; A reasoning module, configured to parse each of the subtasks and perform step-by-step reasoning based on a pattern knowledge base and a large language model in a database to generate an intermediate representation corresponding to each of the subtasks; The conversion module is configured to summarize the intermediate representation corresponding to each of the subtasks, and use the large language model to convert the summarized intermediate representation into a complete target query statement.

9. An electronic device comprising a memory, a processor and a computer program stored in the memory and executable on the processor, characterized in that: When the processor executes the computer program, the steps of the method according to any one of claims 1 to 7 are implemented.

10. A computer-readable storage medium storing a computer program, characterized in that: When the computer program is executed by a processor, the steps of the method according to any one of claims 1 to 7 are implemented.

Images