A method, system and device for standardizing raw engineering parameters of a flight simulator

Abstract

The application belongs to the field of data processing, and particularly relates to a flight simulator original engineering parameter standardization processing method, system and device, aiming to solve the problems of serious field limitation, low processing efficiency and poor adaptation capacity in the prior art. The application comprises: analyzing a predefined configuration file, dynamically generating a database temporary table matched with an original data file structure according to field structure information and parameter mapping rules defined in the configuration file; using a batch loading mechanism based on a file system path to directly load original engineering parameter files into the temporary table, and performing multi-file parallel import based on a task queue; and converting calculation logic in the parameter mapping rules into an executable query expression, and directly exporting a standardized parameter file after performing calculation through the temporary table. The application breaks through the field limitation, realizes efficient processing of massive data, and realizes instant update of business logic through configured rules, thereby greatly reducing maintenance cost.

Description

Technical Field

[0001] The invention belongs to the field of data processing, and in particular relates to a method, system and equipment for standardizing processing original engineering parameters of a flight simulator. Background Art

[0002] In the field of standardized processing of engineering parameters for flight simulators, current mainstream technical solutions usually build data processing processes based on traditional relational databases such as SQL Server. Such solutions face severe technical bottlenecks in actual applications, which seriously restrict the real-time processing capabilities of flight training data. First, relational databases generally have a hard limit on the number of fields in a single table. Taking SQL Server as an example, its upper limit for single-table fields is 1024 columns. When processing ultra-wide table structure data generated by the full parameter collection of modern aircraft, the system cannot directly load the original data file because the number of columns often exceeds this limit. Technical personnel are forced to adopt complex table partitioning strategies or develop additional data pre-processing processes, which not only destroys the integrity of the data, but also introduces performance losses caused by cross-table join queries, significantly increasing system development and maintenance costs.

[0003] Secondly, the parameter data generated by a single flight simulator training run is massive, typically containing hundreds of thousands of rows of records. Existing technical solutions exhibit significant efficiency deficiencies in processing data of this scale. The data import phase relies on row-by-row insert operations, resulting in over ten minutes to load millions of rows of data. The computation phase lacks parallel processing capabilities, resulting in inefficient execution of complex business rules (such as real-time fault diagnosis). The result export phase requires transfer through the application, posing a risk of memory overflow. This performance bottleneck prevents the system from meeting the stringent time requirements of real-time flight training review and analysis scenarios, with processing delays often exceeding permitted thresholds.

[0004] In addition, the existing solution suffers from serious rigidity in its business logic implementation. Key calculation rules (such as aircraft control fault level judgment and engine parameter mapping) need to be hard-coded into SQL query statements. When the avionics system is upgraded or the aircraft model is replaced, technicians must modify the program source code and redeploy it, resulting in a business iteration cycle of up to several weeks. At the same time, insufficient support for underlying hardware operations such as bitwise operations further limits the system's flexibility in handling professional scenarios such as avionics signal masks. This technical architecture severely restricts the rapid adaptability of flight simulators, making it difficult to adapt to the high-frequency iteration development needs of modern aviation equipment.

[0005] Based on this, the present invention proposes a method, system and equipment for standardizing the original engineering parameters of a flight simulator. Summary of the Invention

[0006] In order to solve the above-mentioned problems in the prior art, namely, the problems that the prior art has severe field limitations, low processing efficiency, lack of support for underlying operations such as bit operations, and poor adaptability, the present invention provides a standardized processing method, system and equipment for the original engineering parameters of a flight simulator.

[0007] A first aspect of the present invention provides a method for standardizing original engineering parameters of a flight simulator, the method comprising:

[0008] Parse a predefined configuration file and dynamically generate a database temporary table that matches the original data file structure based on the field structure information and parameter mapping rules defined in the configuration file;

[0009] Using a batch loading mechanism based on the file system path, the original project parameter file is directly loaded into the temporary table, and multiple files are imported in parallel based on the task queue;

[0010] The calculation logic in the conversion parameter mapping rule is an executable query expression, and the standardized parameter file is directly exported after the calculation is performed through the temporary table.

[0011] Furthermore, the field structure information includes field type definition and field constraint conditions, and the parameter mapping rule is defined by a logical expression.

[0012] Furthermore, the field type definition includes numeric, character and Boolean data formats;

[0013] The field constraints include null value checking rules and data type legitimacy verification rules;

[0014] The logical expression is a parameter operation rule containing multiple conditional branches.

[0015] Furthermore, a database temporary table that matches the original data file structure is dynamically generated by:

[0016] Parse the field type definition in the predefined configuration file and map the field type definition to the database column type declaration, wherein the numeric parameter is mapped to the database exact numeric type or integer type; the character parameter is mapped to the database variable-length string type; and the Boolean parameter is mapped to the database Boolean storage type;

[0017] Parsing the field constraints in the configuration file and converting the field constraints into column-level constraint declarations, wherein the null value check rule is mapped to the database null value constraint declaration; the data type legitimacy verification rule is mapped to the database data range verification declaration;

[0018] Based on the column type declaration and column-level constraint declaration, dynamically construct a structured table creation instruction that explicitly includes all field definitions;

[0019] The number of fields explicitly declared in the structured table creation instruction exceeds the upper threshold of fields in a single table of a conventional database;

[0020] Calling a database engine to execute the table creation instruction to generate a temporary table that strictly matches the column structure of the original data file;

[0021] The logical expression defined in the configuration file is stored as metadata during the temporary table creation phase, and the parsing and calculation of the logical expression are delayed until the dynamic query phase.

[0022] Furthermore, when the number of columns in a data file exceeds the upper threshold of a single table field in a conventional database, row-by-row insertion is avoided;

[0023] The parallel import mechanism maintains task queue control with a preset maximum concurrency threshold.

[0024] Furthermore, the batch loading mechanism based on the file system path is implemented by a file direct loading instruction provided by the database system;

[0025] The direct export mechanism is implemented by using file export instructions provided by the database system.

[0026] Furthermore, the calculation logic in the converted parameter mapping rule is an executable query expression, and the standardized parameter file is directly exported after the calculation is performed through the temporary table, specifically:

[0027] Parse the logical expression in the parameter mapping rule, convert the logical expression into a multi-conditional branch judgment expression containing bitwise operators, and build the core calculation unit of the dynamic query statement;

[0028] Identify function identifiers referenced in logical expressions and embed predefined functions in query expressions;

[0029] Executing a query statement containing the calculation unit through a database engine to complete the calculation of the original parameters into standardized parameters on the temporary table;

[0030] Call the database kernel-level file export instruction to write the calculation result set directly into the file system to generate a standardized parameter file.

[0031] Furthermore, the multi-conditional branch judgment expression implements combinational logic judgment through bit operators, and the predefined function implements dynamic return value mapping based on input parameters.

[0032] In a second aspect, the present invention provides a system for standardizing the original engineering parameters of a flight simulator. The system is based on a method for standardizing the original engineering parameters of a flight simulator. The system includes:

[0033] A temporary table construction module is configured to parse a predefined configuration file and dynamically generate a database temporary table that matches the original data file structure based on the field structure information and parameter mapping rules defined in the configuration file;

[0034] A loading module is configured to adopt a batch loading mechanism based on a file system path to directly load the original project parameter file into the temporary table and perform parallel import of multiple files based on a task queue;

[0035] The export module is configured to convert the calculation logic in the parameter mapping rule into an executable query expression, and directly export the standardized parameter file after performing the calculation through the temporary table.

[0036] According to a third aspect of the present invention, an electronic device is provided, comprising:

[0037] at least one processor; and

[0038] a memory communicatively connected to at least one of the processors; wherein,

[0039] The memory stores instructions that can be executed by the processor, and the instructions are used to be executed by the processor to implement a standardized processing method for original engineering parameters of a flight simulator.

[0040] Beneficial effects of the present invention:

[0041] This invention dynamically parses configuration files to generate temporary tables that match the original data structure, effectively breaking through the rigid limit on the number of fields per table in traditional relational databases (such as SQL Server's 1024 columns). This enables the system to directly load ultra-wide table structures generated by comprehensive data collection of modern aircraft parameters, eliminating the need for complex table partitioning strategies or additional data preprocessing. This fully preserves the original data structure and completely avoids the performance loss associated with cross-table join queries, significantly reducing the complexity and cost of system development and maintenance.

[0042] In terms of data processing efficiency, the present invention adopts a batch loading mechanism based on the file system path and combines it with a task queue to realize the parallel import of multiple files, which greatly optimizes the loading process of massive data. At the same time, by directly converting the calculation logic in the parameter mapping rules into an efficient query expression that can be executed in the database, seamless integration of calculation and standardized result export is achieved. This method significantly shortens the processing time of millions of rows of data, effectively avoids the risk of memory overflow caused by row-by-row insertion, low computational efficiency, and export through application programs in traditional solutions, and ensures that the system can meet the strict processing speed requirements of real-time review and analysis scenarios for flight training.

[0043] In order to enhance the flexibility and maintainability of business logic, the present invention liberates key calculation rules (such as aircraft control fault level judgment, engine parameter mapping, avionics signal mask processing, etc.) from hard-coded SQL statements and transforms them into configurable rules in predefined configuration files. When faced with avionics system upgrades or aircraft model changes, technicians only need to adjust the configuration file to update the calculation logic without modifying the program source code and redeploying it, significantly shortening the business iteration cycle from several weeks to almost immediate effect. In addition, strengthening support for underlying hardware operations such as bitwise operations further improves the system's adaptability and flexibility in handling professional aviation scenarios, strongly supporting the development needs of high-frequency iterations of modern aviation equipment.

[0044] In summary, this invention systematically integrates and optimizes the end-to-end processing flow of data loading, calculation, and export through three core mechanisms: dynamic table construction, batch parallel loading, and rule configurability. This not only significantly reduces the redundancy of intermediate links in traditional solutions, lowering overall development and maintenance costs, but also fully improves the utilization efficiency of system resources through parallel mechanisms such as task queues. Ultimately, it provides a highly real-time, highly scalable, and low-maintenance solution for the standardized processing of original engineering parameters for flight simulators, laying a solid technical foundation for the agile development of modern aviation training systems. BRIEF DESCRIPTION OF THE DRAWINGS

[0045] Other features, objects and advantages of the present application will become more apparent upon reading the detailed description of non-limiting embodiments made with reference to the following drawings:

[0046] Figure 1 The present invention is a flowchart of a method for standardizing original engineering parameters of a flight simulator. DETAILED DESCRIPTION

[0047] The present application will be further described in detail below with reference to the accompanying drawings and examples. It should be understood that the specific embodiments described herein are intended only to illustrate the relevant invention and are not intended to limit the invention. It should also be noted that, for ease of description, only portions relevant to the relevant invention are shown in the accompanying drawings.

[0048] It should be noted that, in the absence of conflict, the embodiments and features of the embodiments in this application can be combined with each other. The present application will be described in detail below with reference to the accompanying drawings and in combination with the embodiments.

[0049] A first embodiment of the present invention provides a method for standardizing original engineering parameters of a flight simulator, the method comprising:

[0050] Step S10, parsing a predefined configuration file, and dynamically generating a database temporary table that matches the original data file structure according to the field structure information and parameter mapping rules defined in the configuration file;

[0051] Step S20, using a batch loading mechanism based on a file system path, directly loading the original engineering parameter file into the temporary table, and performing parallel import of multiple files based on a task queue;

[0052] Step S30: convert the calculation logic in the parameter mapping rule into an executable query expression, and directly export the standardized parameter file after performing the calculation through the temporary table.

[0053] In order to more clearly illustrate the standardization processing method of the original engineering parameters of a flight simulator of the present invention, the following is combined with Figure 1 Each step in the embodiment of the present invention is described in detail, including step S10 to step S30, and each step is described in detail as follows:

[0054] Step S10, parsing a predefined configuration file, and dynamically generating a database temporary table that matches the original data file structure according to the field structure information and parameter mapping rules defined in the configuration file;

[0055] In this embodiment, the field structure information includes field type definition and field constraint conditions, and the parameter mapping rule is defined by a logical expression.

[0056] The field type definition includes numeric, character and Boolean data formats;

[0057] The field constraints include null value checking rules and data type legitimacy verification rules;

[0058] The logical expression is a parameter operation rule containing multiple conditional branches.

[0059] Specifically, in this embodiment, the temporary table generation process is driven by a predefined configuration file that explicitly specifies field structure information and parameter mapping rules. The field structure information specifically includes two parts: field type definitions and field constraints. The field type definitions cover numeric, character, and Boolean data formats, which determine how the original engineering parameters are stored in the database. The field constraints further specify null value validation rules and data type legitimacy verification rules to ensure the integrity and compliance of the imported data.

[0060] The parameter mapping rules are precisely defined by logical expressions, which are essentially parameter calculation rules with multiple conditional branches, describing the complex conversion logic from raw parameters to standardized parameters. The system automatically extracts the aforementioned field types, constraints, and logical expressions by parsing the simulator parameter configuration pre-set in the configuration file. Based on the parsed results, it dynamically constructs and executes a CREATE TEMPORARY TABLE statement that conforms to MySQL syntax, ultimately generating a database temporary table that fully matches the column structure of the original data file. This process eliminates the need for manual intervention in table structure design and directly adapts to ultra-wide table scenarios.

[0061] In this embodiment, a database temporary table that matches the original data file structure is dynamically generated by:

[0062] Step S11, parse the field type definition in the predefined configuration file and map it to the database column type declaration, wherein the numeric parameter is mapped to the database exact numeric type or integer type; the character parameter is mapped to the database variable-length string type; and the Boolean parameter is mapped to the database Boolean storage type.

[0063] Step S12, parse the field constraints in the configuration file and convert the field constraints into column-level constraint declarations, wherein the null value check rule is mapped to the database null value constraint declaration; the data type legitimacy verification rule is mapped to the database data range check declaration.

[0064] Step S13: Based on the column type declaration and the column-level constraint declaration, dynamically construct a structured table creation instruction that explicitly includes all field definitions;

[0065] The structured table creation instruction explicitly declares that the number of fields exceeds the upper threshold of the fields of a single table in a conventional database.

[0066] Step S14: calling a database engine to execute the table creation instruction to generate a temporary table that strictly matches the column structure of the original data file;

[0067] The logical expression defined in the configuration file is stored as metadata during the temporary table creation phase, and the parsing and calculation of the logical expression are delayed until the dynamic query phase.

[0068] The structured table creation instruction explicitly declares that the number of fields exceeds the upper limit of fields in a single table of a conventional database. In this embodiment, the instruction explicitly declares that the number of fields exceeds 1024 columns, which exceeds the upper limit of fields in a single table of a SQL Server.

[0069] In this embodiment, the method for dynamically generating a database temporary table that matches the structure of the original data file is as follows: the system automatically parses the field type definition in the predefined configuration file through a program and accurately maps it to the database column type declaration, for example, mapping the numeric type in the configuration file to DECIMAL or INT, mapping the character type to VARCHAR, and mapping the Boolean type to TINYINT(1); at the same time, the field constraints in the configuration file are converted into corresponding column-level constraint declarations, including mapping the null value check rule to NOT NULL or NULL constraint, and mapping the data type validity verification rule to CHECK constraint or data type range limitation.

[0070] Based on the above mapping results, the system dynamically constructs a complete MySQL table creation instruction. This instruction explicitly includes all parsed column type declarations and column-level constraint declarations, ensuring that the temporary table's column structure, data types, and constraints are strictly consistent with the ultra-wide table structure of the original data file. Finally, by automatically executing the generated CREATE TEMPORARY TABLE statement, temporary tables suitable for ultra-wide table scenarios can be created without manual intervention.

[0071] In this embodiment, the logical expression is a core component of the parameter mapping rule and is only stored as metadata in the configuration during the temporary table generation phase. Its actual parsing and operation execution occur in the subsequent dynamic query construction phase.

[0072] Step S20, using a batch loading mechanism based on a file system path, directly loading the original engineering parameter file into the temporary table, and performing parallel import of multiple files based on a task queue;

[0073] In this embodiment, step S20 specifically includes:

[0074] In step S21, when it is determined that the number of fields in the original engineering parameter file exceeds a preset field number threshold, the database native batch loading instruction is called to directly load the formatted data file into the temporary table by specifying the file system path, thereby avoiding the performance bottleneck caused by the row-by-row insertion operation.

[0075] In step S22, the multiple data file paths to be processed are sequentially added to the task queue, and concurrent execution units are started at the same time, with the total active number of the concurrent execution units strictly maintained at no more than a preset concurrency upper limit threshold.

[0076] Step S23: Whenever a data file is loaded, the next file path to be processed is immediately extracted from the task queue, and a new concurrent execution unit is activated to process the file until the task queue is empty.

[0077] In other words, this embodiment avoids row-by-row insertion when the number of columns in the data file exceeds the upper threshold of a single table field in a conventional database;

[0078] The parallel import mechanism maintains task queue control with a preset maximum concurrency threshold.

[0079] The original project parameter file is directly loaded into a temporary table via a batch load mechanism based on a file system path. The specific implementation process is as follows: When the number of columns in a data file exceeds the upper limit of a single database table field (e.g., 1024 columns), the system automatically uses MySQL's LOAD DATA INFILE command to perform an efficient batch import, completely avoiding the performance bottlenecks associated with traditional row-by-row inserts. This command directly reads the original CSV-formatted data file via the file system path and loads it into the temporary table all at once according to the field structure mapping, significantly improving the import speed of ultra-wide table data.

[0080] For parallel import of multiple files, the system implements concurrency control based on a task queue mechanism. Initially, a task queue with a predefined capacity is created, and the paths of the files to be imported are added to the queue in sequence as task units. Simultaneously, concurrent processing threads or asynchronous tasks are started, strictly maintaining a preset maximum concurrency threshold (e.g., 5 concurrent tasks) during import operations. Specifically, whenever a file import task completes, the system immediately extracts the next task from the queue and starts a new thread / asynchronous task, ensuring that there are always tasks in the queue until all imports are complete, thereby maximizing system resource utilization and reducing overall processing time.

[0081] In this embodiment, the batch loading mechanism based on the file system path is implemented by the file direct loading instruction provided by the database system;

[0082] The direct export mechanism is implemented by using file export instructions provided by the database system.

[0083] The specific steps include:

[0084] Step S24, in response to the data loading request, calls the file direct loading instruction provided by the database kernel, binds the storage path of the original project parameter file in the file system by inputting parameters, and enables the database engine to directly read the formatted data file content.

[0085] Step S25 , based on the field structure mapping relationship of the temporary table, the data is loaded into the target table in batches through the file direct load instruction, replacing row-by-row insertion with a single full import operation.

[0086] Step S26: In response to the result export request, the file export instruction provided by the database kernel is called, and the storage path of the standardized parameter result file in the file system is specified through output parameters.

[0087] Step S27: directly write the final result set generated by the dynamic query statement into the disk file through the file export instruction, skipping the application program memory cache.

[0088] Among them, the batch loading mechanism based on the file system path is implemented through the file direct loading instruction provided by the database system. The specific process is: the system calls the batch loading instruction natively supported by the database (such as MySQL's LOAD DATAINFILE), and specifies the complete path of the original project parameter file in the file system through input parameters; this instruction directly reads the content of the formatted data file (such as CSV format), and loads the data into the target table in batches according to the field structure mapping relationship of the temporary table, realizing the completion of full data import in a single operation, and completely avoiding the performance loss caused by the application's line-by-line parsing and insertion.

[0089] In this embodiment, the direct export mechanism is implemented through the file export instruction provided by the database system. The specific process is: the system calls the result export instruction natively supported by the database (such as MySQL's INTO OUTFILE), and specifies the storage path of the target file in the file system through the output parameter; this instruction writes the calculation results of the dynamic query statement directly to the disk file, skipping the application memory caching link, avoiding the risk of memory overflow caused by large-scale result sets, and reducing the additional I / O overhead caused by data transfer.

[0090] The above mechanism is based entirely on file system path operations and uses database kernel-level instructions to achieve efficient data flow transmission, ensuring stable processing performance in ultra-wide tables and large data volume scenarios.

[0091] Step S30: converting the calculation logic in the parameter mapping rule into an executable query expression, and directly exporting the standardized parameter file after performing the calculation through the temporary table, wherein the logical expression is converted into a multi-conditional branch judgment expression in a structured query statement, and a predefined function call is embedded in the expression;

[0092] The multi-conditional branch judgment expression implements combinatorial logic judgment through bitwise operators, and the predefined function implements dynamic return value mapping based on input parameters, specifically including the following steps:

[0093] Step S31 , parsing the logical expression in the parameter mapping rule, converting it into a multi-conditional branch judgment expression containing bitwise operators, and constructing a core calculation unit of the dynamic query statement.

[0094] Step S32: Identify the function identifier referenced in the logical expression, embed the predefined function call in the query expression, and implement dynamic mapping from input parameters to return values.

[0095] Step S33: executing the query statement containing the calculation unit through the database engine to complete the calculation of the original parameters into standardized parameters on the temporary table.

[0096] Step S34: calling the database kernel-level file export instruction to directly write the calculation result set into the file system to generate a standardized parameter file.

[0097] In this embodiment, the specific method of converting the calculation logic in the parameter mapping rule into an executable query expression is as follows:

[0098] The system parses the parameter mapping rules defined in the configuration file and dynamically converts the logical expressions contained therein into multi-condition branch judgment expressions in structured query statements. This conversion process implements complex combinational logical judgments through bitwise operators, such as using the bitwise OR (|) operator to integrate multi-condition trigger rules, the bitwise AND (&) operator to perform joint condition screening, and the bitwise NOT (~) operator to implement reverse judgment, thereby accurately restoring the combinational logical relationship between the original engineering parameters.

[0099] Predefined function calls are also embedded when constructing query expressions. The system identifies function identifiers referenced in logical expressions and maps them to custom functions registered in the database. These custom functions accept input parameters and dynamically map return values, for example, dynamically returning sensor parameter values ​​based on engine type parameters. This allows for a direct translation of business rules into database logic. The resulting query expression serves as the core computational unit of the SELECT statement, and the database engine directly executes calculations on temporary tables.

[0100] After the calculation is completed, the system calls the database's native file export instruction and writes the calculation result set directly into the standardized parameter file through the file system path, avoiding the application memory cache throughout the process and ensuring the security of large-scale data processing.

[0101] Although the various steps in the above embodiment are described in the above-mentioned order, those skilled in the art will understand that in order to achieve the effect of this embodiment, different steps do not have to be executed in such an order. They can be executed simultaneously (in parallel) or in a reverse order. These simple changes are within the scope of protection of the present invention.

[0102] A second embodiment of the present invention provides a system for standardizing the original engineering parameters of a flight simulator. The system is based on the method for standardizing the original engineering parameters of a flight simulator described in the first embodiment. The system includes:

[0103] A temporary table construction module is configured to parse a predefined configuration file and dynamically generate a database temporary table that matches the original data file structure based on the field structure information and parameter mapping rules defined in the configuration file;

[0104] A loading module is configured to adopt a batch loading mechanism based on a file system path to directly load the original project parameter file into the temporary table and perform parallel import of multiple files based on a task queue;

[0105] The export module is configured to convert the calculation logic in the parameter mapping rule into an executable query expression, and directly export the standardized parameter file after performing the calculation through the temporary table.

[0106] Those skilled in the art will clearly understand that, for the convenience and brevity of description, the specific working process and related instructions of the system described above can refer to the corresponding process in the aforementioned method embodiment and will not be repeated here.

[0107] It should be noted that the standardized processing system for the original engineering parameters of a flight simulator provided in the above embodiment is only illustrated by the division of the above functional modules. In actual applications, the above functions can be assigned to different functional modules as needed, that is, the modules or steps in the embodiments of the present invention can be further decomposed or combined. For example, the modules in the above embodiment can be combined into one module, or further divided into multiple sub-modules to complete all or part of the functions described above. The names of the modules and steps involved in the embodiments of the present invention are only for distinguishing the modules or steps and are not regarded as improper limitations on the present invention.

[0108] An electronic device according to a third embodiment of the present invention includes:

[0109] at least one processor; and

[0110] a memory communicatively connected to at least one of the processors; wherein,

[0111] The memory stores instructions that can be executed by the processor, and the instructions are used to be executed by the processor to implement the above-mentioned method for standardizing original engineering parameters of a flight simulator.

[0112] A fourth embodiment of the present invention provides a computer-readable storage medium, wherein the computer-readable storage medium stores computer instructions, and the computer instructions are used to be executed by the computer to implement the above-mentioned method for standardizing the original engineering parameters of a flight simulator.

[0113] Those skilled in the art will clearly understand that, for the convenience and brevity of description, the specific working processes and related instructions of the storage device and processing device described above can refer to the corresponding processes in the aforementioned method embodiments and will not be repeated here.

[0114] Those skilled in the art should be able to appreciate that the modules and method steps of each example described in conjunction with the embodiments disclosed herein can be implemented in electronic hardware, computer software, or a combination of the two, and the programs corresponding to the software modules and method steps can be placed in random access memory (RAM), internal memory, read-only memory (ROM), electrically programmable ROM, electrically erasable programmable ROM, registers, hard disks, removable disks, CD-ROMs, or any other form of storage medium known in the art. In order to clearly illustrate the interchangeability of electronic hardware and software, the above description has generally described the components and steps of each example according to their functions. Whether these functions are performed in electronic hardware or software depends on the specific application and design constraints of the technical solution. Those skilled in the art may 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 the present invention.

[0115] The terms "first", "second", etc. are used to distinguish similar objects, rather than to describe or indicate a particular order or sequence.

[0116] The term "comprise" or any other similar term is intended to cover non-exclusive inclusion such that a process, method, article, or apparatus that comprises a list of elements includes not only those elements but also other elements not expressly listed or inherent to such process, method, article, or apparatus.

[0117] Thus far, the technical solutions of the present invention have been described in conjunction with the preferred embodiments shown in the accompanying drawings. However, it will be readily understood by those skilled in the art that the scope of protection of the present invention is obviously not limited to these specific embodiments. Without departing from the principles of the present invention, those skilled in the art may make equivalent changes or substitutions to the relevant technical features, and the technical solutions after such changes or substitutions will fall within the scope of protection of the present invention.

Claims

1. A method for standardizing original engineering parameters of a flight simulator, characterized in that: The method includes: Parse a predefined configuration file and dynamically generate a database temporary table that matches the original data file structure based on the field structure information and parameter mapping rules defined in the configuration file; The field structure information includes field type definition and field constraint conditions, and the parameter mapping rule is defined by a logical expression; Dynamically generate a database temporary table that matches the original data file structure. The method is: Parse the field type definition in the predefined configuration file and map the field type definition to the database column type declaration, wherein the numeric parameter is mapped to the database exact numeric type or integer type; the character parameter is mapped to the database variable-length string type; and the Boolean parameter is mapped to the database Boolean storage type; Parsing the field constraints in the configuration file and converting the field constraints into column-level constraint declarations, wherein the null value check rule is mapped to the database null value constraint declaration; the data type legitimacy verification rule is mapped to the database data range verification declaration; Based on the column type declaration and column-level constraint declaration, dynamically construct a structured table creation instruction that explicitly includes all field definitions; The number of fields explicitly declared in the structured table creation instruction exceeds the upper threshold of fields in a single table of a conventional database; Calling a database engine to execute the structured table creation instruction to generate a temporary table that strictly matches the column structure of the original data file; The logical expression defined in the configuration file is stored as metadata during the temporary table creation phase, and the parsing and calculation of the logical expression are delayed until the dynamic query phase. Use a batch loading mechanism based on the file system path to load the original project parameter files directly into a temporary table, and perform parallel import of multiple files based on the task queue; The calculation logic in the conversion parameter mapping rule is an executable query expression, and the standardized parameter file is directly exported after the calculation is performed through the temporary table.

2. The method for standardizing original engineering parameters of a flight simulator according to claim 1, characterized in that: The field type definition includes numeric, character and Boolean data formats; The field constraints include null value checking rules and data type legitimacy verification rules; The logical expression is a parameter operation rule containing multiple conditional branches.

3. The method for standardizing original engineering parameters of a flight simulator according to claim 1, characterized in that: When the number of columns in a data file exceeds the upper limit of a single table field in a conventional database, row-by-row insertion is avoided; The parallel import mechanism maintains task queue control with a preset maximum concurrency threshold.

4. The method for standardizing original engineering parameters of a flight simulator according to claim 1, characterized in that: The batch loading mechanism based on the file system path is implemented through the file direct loading instruction provided by the database system; The direct export mechanism is implemented through the file export instructions provided by the database system.

5. The method for standardizing original engineering parameters of a flight simulator according to claim 1, characterized in that: The calculation logic in the converted parameter mapping rule is an executable query expression. After performing the calculation through the temporary table, the standardized parameter file is directly exported. Specifically: Parse the logical expression in the parameter mapping rule, convert the logical expression into a multi-conditional branch judgment expression containing bitwise operators, and build the core calculation unit of the dynamic query statement; Identify function identifiers referenced in logical expressions and embed predefined functions in query expressions; Executing a query statement containing the calculation unit through a database engine to complete the calculation of the original parameters into standardized parameters on the temporary table; Call the database kernel-level file export instruction to write the calculation result set directly into the file system to generate a standardized parameter file.

6. The method for standardizing original engineering parameters of a flight simulator according to claim 5, characterized in that: The multi-conditional branch judgment expression implements combinational logic judgment through bit operators, and the predefined function implements dynamic return value mapping based on input parameters.

7. A system for standardizing the original engineering parameters of a flight simulator, based on the method for standardizing the original engineering parameters of a flight simulator according to any one of claims 1 to 6, characterized in that: The system includes: A temporary table construction module is configured to parse a predefined configuration file and dynamically generate a database temporary table that matches the original data file structure based on the field structure information and parameter mapping rules defined in the configuration file; A loading module is configured to adopt a batch loading mechanism based on a file system path to directly load the original project parameter file into the temporary table and perform parallel import of multiple files based on a task queue; The export module is configured to convert the calculation logic in the parameter mapping rule into an executable query expression, and directly export the standardized parameter file after performing the calculation through the temporary table.

8. An electronic device, characterized in that: include: at least one processor; as well as a memory communicatively connected to at least one of the processors; wherein, The memory stores instructions that can be executed by the processor, and the instructions are used to be executed by the processor to implement the standardized processing method of original engineering parameters of a flight simulator as described in any one of claims 1-6.

Images