CN115809063B - Storage process compiling method, system, electronic equipment and storage medium - Google Patents
Storage process compiling method, system, electronic equipment and storage medium Download PDFInfo
- Publication number
- CN115809063B CN115809063B CN202211549760.9A CN202211549760A CN115809063B CN 115809063 B CN115809063 B CN 115809063B CN 202211549760 A CN202211549760 A CN 202211549760A CN 115809063 B CN115809063 B CN 115809063B
- Authority
- CN
- China
- Prior art keywords
- code
- intermediate representation
- representation
- module
- optimization
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Active
Links
- 238000000034 method Methods 0.000 title claims abstract description 119
- 230000008569 process Effects 0.000 title abstract description 51
- 238000004458 analytical method Methods 0.000 claims abstract description 79
- 238000005457 optimization Methods 0.000 claims abstract description 74
- 238000005206 flow analysis Methods 0.000 claims abstract description 21
- 230000014509 gene expression Effects 0.000 claims description 40
- 239000013598 vector Substances 0.000 claims description 32
- 238000004590 computer program Methods 0.000 claims description 16
- 238000012545 processing Methods 0.000 claims description 13
- 230000004083 survival effect Effects 0.000 claims description 13
- 230000003068 static effect Effects 0.000 claims description 11
- 230000008030 elimination Effects 0.000 claims description 8
- 238000003379 elimination reaction Methods 0.000 claims description 8
- 239000003795 chemical substances by application Substances 0.000 claims description 4
- 230000006870 function Effects 0.000 description 21
- 238000004891 communication Methods 0.000 description 8
- 238000010586 diagram Methods 0.000 description 5
- 101100328886 Caenorhabditis elegans col-2 gene Proteins 0.000 description 3
- 101100328884 Caenorhabditis elegans sqt-3 gene Proteins 0.000 description 3
- 230000000694 effects Effects 0.000 description 3
- 230000003993 interaction Effects 0.000 description 3
- 238000007726 management method Methods 0.000 description 3
- 230000003287 optical effect Effects 0.000 description 3
- 238000006243 chemical reaction Methods 0.000 description 2
- 238000013461 design Methods 0.000 description 2
- 230000004807 localization Effects 0.000 description 2
- 238000012986 modification Methods 0.000 description 2
- 230000004048 modification Effects 0.000 description 2
- 238000006467 substitution reaction Methods 0.000 description 2
- 241000282813 Aepyceros melampus Species 0.000 description 1
- 230000009471 action Effects 0.000 description 1
- 230000006978 adaptation Effects 0.000 description 1
- 230000003321 amplification Effects 0.000 description 1
- 238000003491 array Methods 0.000 description 1
- 238000013473 artificial intelligence Methods 0.000 description 1
- 230000009286 beneficial effect Effects 0.000 description 1
- 230000008901 benefit Effects 0.000 description 1
- 230000001413 cellular effect Effects 0.000 description 1
- 230000000295 complement effect Effects 0.000 description 1
- JHIVVAPYMSGYDF-UHFFFAOYSA-N cyclohexanone Chemical compound O=C1CCCCC1 JHIVVAPYMSGYDF-UHFFFAOYSA-N 0.000 description 1
- 230000007547 defect Effects 0.000 description 1
- 238000011161 development Methods 0.000 description 1
- 238000005516 engineering process Methods 0.000 description 1
- 239000011521 glass Substances 0.000 description 1
- 230000006872 improvement Effects 0.000 description 1
- 239000004973 liquid crystal related substance Substances 0.000 description 1
- 238000010801 machine learning Methods 0.000 description 1
- 230000007246 mechanism Effects 0.000 description 1
- 238000003199 nucleic acid amplification method Methods 0.000 description 1
- 239000013307 optical fiber Substances 0.000 description 1
- 238000011084 recovery Methods 0.000 description 1
- 238000004064 recycling Methods 0.000 description 1
- 230000009467 reduction Effects 0.000 description 1
- 230000010076 replication Effects 0.000 description 1
- 238000012216 screening Methods 0.000 description 1
- 239000004065 semiconductor Substances 0.000 description 1
- 230000001953 sensory effect Effects 0.000 description 1
- 230000002123 temporal effect Effects 0.000 description 1
- 238000013519 translation Methods 0.000 description 1
- 230000000007 visual effect Effects 0.000 description 1
Classifications
-
- Y—GENERAL TAGGING OF NEW TECHNOLOGICAL DEVELOPMENTS; GENERAL TAGGING OF CROSS-SECTIONAL TECHNOLOGIES SPANNING OVER SEVERAL SECTIONS OF THE IPC; TECHNICAL SUBJECTS COVERED BY FORMER USPC CROSS-REFERENCE ART COLLECTIONS [XRACs] AND DIGESTS
- Y02—TECHNOLOGIES OR APPLICATIONS FOR MITIGATION OR ADAPTATION AGAINST CLIMATE CHANGE
- Y02D—CLIMATE CHANGE MITIGATION TECHNOLOGIES IN INFORMATION AND COMMUNICATION TECHNOLOGIES [ICT], I.E. INFORMATION AND COMMUNICATION TECHNOLOGIES AIMING AT THE REDUCTION OF THEIR OWN ENERGY USE
- Y02D10/00—Energy efficient computing, e.g. low power processors, power management or thermal management
Landscapes
- Devices For Executing Special Programs (AREA)
Abstract
The invention discloses a storage process compiling method, a storage process compiling system, electronic equipment and a storage medium. Wherein the method comprises the following steps: and generating an intermediate representation of the stored program according to the syntax analysis module, optimizing the intermediate representation based on the data flow analysis optimization module, and generating locally executed codes according to the representation type of the intermediate representation according to the code generation module. The embodiment of the invention realizes the compiling optimization of the storage process and improves the execution efficiency of the code in the storage process.
Description
Technical Field
The present invention relates to the field of database technologies, and in particular, to a method, a system, an electronic device, and a storage medium for compiling a storage process.
Background
In modern databases, the storage process is widely used as a core function, the storage process can encapsulate a series of structured query statement (Structured Query Language, SQL) functional sets and control logic of specific operations on the database side, and the storage process only needs to be compiled once, so that the network interaction of the application and the database and the SQL analysis cost are greatly reduced. However, in the distributed database, the data size is huge, and the concurrent access is large, so that the execution speed of the storage process becomes a bottleneck of the database.
The compiling and executing of the existing storage process has the following problems:
1. the existing storage process module only compiles and executes partial expressions, and cannot realize complete execution optimization, so that the performance of the storage process module is not improved.
2. Only the machine code can be compiled and executed, the optimization of control logic such as conditions, loops and the like can not be realized, and only the control logic can be interpreted and executed, so that the execution efficiency of a storage process is low.
Disclosure of Invention
The invention provides a storage process compiling method, a system, electronic equipment and a storage medium, which are used for realizing compiling optimization of a storage process and improving execution efficiency of a storage process code.
According to an aspect of the present invention, there is provided a stored procedure compiling method, wherein the method includes:
generating an intermediate representation of the stored program according to the parsing module;
optimizing the intermediate representation based on a data flow analysis optimization module;
the locally executed code is generated according to the representation type of the intermediate representation according to the code generation module.
According to another aspect of the present invention, there is provided a stored procedure compiling system, wherein the system comprises:
a syntax analysis module for generating an intermediate representation of the stored program;
The data flow analysis optimizing module is used for optimizing the intermediate representation;
and the code generation module is used for generating the locally-executed code according to the representation type of the intermediate representation.
According to another aspect of the present invention, there is provided an electronic apparatus including:
at least one processor; and
a memory communicatively coupled to the at least one processor; wherein,,
the memory stores a computer program executable by the at least one processor to enable the at least one processor to perform the stored procedure compiling method according to any one of the embodiments of the invention.
According to another aspect of the present invention, there is provided a computer readable storage medium storing computer instructions for causing a processor to implement a stored procedure compiling method according to any embodiment of the present invention when executed.
According to the technical scheme of the embodiment of the invention, the intermediate representation of the storage program is generated according to the grammar analysis module, the intermediate representation is optimized based on the data flow analysis optimization module, the local execution code is generated according to the representation type of the intermediate representation by the code generation module, the compiling optimization of the storage process is realized, and the execution efficiency of the code in the storage process is improved.
It should be understood that the description in this section is not intended to identify key or critical features of the embodiments of the invention or to delineate the scope of the invention. Other features of the present invention will become apparent from the description that follows.
Drawings
In order to more clearly illustrate the technical solutions of the embodiments of the present invention, the drawings required for the description of the embodiments will be briefly described below, and it is apparent that the drawings in the following description are only some embodiments of the present invention, and other drawings may be obtained according to these drawings without inventive effort for a person skilled in the art.
FIG. 1 is a flow chart of a method for compiling a stored procedure according to a first embodiment of the present invention;
FIG. 2 is a flowchart of a method for compiling a stored procedure according to a second embodiment of the present invention;
FIG. 3 is a flow chart of a locally executed code generation process provided in accordance with a second embodiment of the present invention;
FIG. 4 is a flowchart of a method for compiling a stored procedure according to a third embodiment of the present invention;
FIG. 5 is a flowchart illustrating a stored procedure compiling system according to the third embodiment of the invention;
FIG. 6 is a schematic diagram of a storage process compiling system according to a fourth embodiment of the invention;
fig. 7 is a schematic structural diagram of an electronic device implementing a stored procedure compiling method according to an embodiment of the invention.
Detailed Description
In order that those skilled in the art will better understand the present invention, a technical solution in the embodiments of the present invention will be clearly and completely described below with reference to the accompanying drawings in which it is apparent that the described embodiments are only some embodiments of the present invention, not all embodiments. All other embodiments, which can be made by those skilled in the art based on the embodiments of the present invention without making any inventive effort, shall fall within the scope of the present invention.
It should be noted that the terms "first," "second," and the like in the description and the claims of the present invention and the above figures are used for distinguishing between similar objects and not necessarily for describing a particular sequential or chronological order. It is to be understood that the data so used may be interchanged where appropriate such that the embodiments of the invention described herein may be implemented in sequences other than those illustrated or otherwise described herein. Furthermore, the terms "comprises," "comprising," and "having," and any variations thereof, are intended to cover a non-exclusive inclusion, such that a process, method, system, article, or apparatus that comprises a list of steps or elements is not necessarily limited to those steps or elements expressly listed but may include other steps or elements not expressly listed or inherent to such process, method, article, or apparatus.
Example 1
Fig. 1 is a flowchart of a stored procedure compiling method according to an embodiment of the present invention, where the embodiment is applicable to a case of compiling and optimizing a stored procedure of source code and performing the stored procedure locally, and the method may be performed by a stored procedure compiling system according to an embodiment of the present invention and implemented by a software algorithm. As shown in fig. 1, the method for compiling a storage process provided in the first embodiment specifically includes the following steps:
s110, generating an intermediate representation of the stored program according to the grammar analysis module.
In the embodiment of the present invention, the parsing module may be understood as a software module for parsing source code, and illustratively, the parsing module may include a lexical analyzer, a syntax analyzer, a semantic analyzer, and the like. The stored program is understood to be a group of PL/SQL (Procedural Language for SQL) programs stored in a database and having a specific function, and the stored program may be created by a user according to actual service needs by using PL/SQL statements, may be predefined by a system, and may include a stored function, a stored procedure, and the like. Intermediate representation (Intermediate Representation, IR) may be understood as an intermediate instruction between source code and native execution code generated according to corresponding semantic rules that enables complete expression of the semantics of the source code and may be further converted into native execution code execution, and may include, but is not limited to, the following classes: jump instructions (JumpInstr/JumpCondInstr), assignment instructions (Setlnstr), return instructions (return nstr), SQL instructions (SQL lnstr), cursor open (OpenInstr), fetch (fetcnstr), and close instructions (CloseInstr), etc., which are not limiting to the practice of the present invention.
Specifically, the grammar analysis module can perform grammar and semantic analysis on the stored program of the source code, so as to convert the source code into an intermediate representation corresponding to the stored program, and the process of performing grammar and semantic analysis on the stored program of the source code can include, but is not limited to, three stages of lexical analysis, grammar analysis and semantic analysis, wherein the lexical analysis refers to scanning a character stream of the stored program, and then identifying words according to word forming rules; the grammar analysis refers to the grammar analysis of word strings after the lexical analysis according to the grammar rules of the source language, and if no grammar error exists, a correct grammar result is given, and illustratively, the grammar analysis method can comprise a top-down grammar analysis method, a bottom-up grammar analysis method and the like; semantic analysis refers to the examination of the contextually relevant properties, i.e., type examination, of structurally correct source code; on the basis of the parsing, the result of the parsing may be further converted into an intermediate representation, which may include forms of suffix, graph representation (abstract syntax tree, loop-free directed graph), and triple-address code (ternary, quaternary, indirect ternary), etc. Preferably, the intermediate representation used in the embodiments of the present invention may be an intermediate representation under LLVM (Low Level Virtual Machine, underlying language virtual machine) architecture that organizes instructions in the form of a triple address code, i.e., the basic form of LLVMIR is x=yop z, where x, y, and z may be names, constants, or temporary variables generated at compile time, and op represents an operation symbol.
And S120, optimizing the intermediate representation based on the data flow analysis optimization module.
In the embodiment of the invention, the data flow analysis optimizing module can be understood as a software module for optimizing the intermediate representation, and illustratively, the data flow analysis optimizing module can include optimizing modes such as local optimizing, circular optimizing, global optimizing and the like for the intermediate representation.
Specifically, the data flow analysis optimization module can further optimize the generated intermediate representation, namely, the compiled intermediate representation is equivalently transformed on the premise of not changing the running effect of the intermediate representation, so that more efficient target codes can be generated; methods of optimizing the intermediate representation may include, but are not limited to, the following: constant expression optimization (merging constant), common expression optimization (eliminating repeated operation), loop outer lifting of an unchanged expression, reduction of operation intensity, elimination of useless codes, copying propagation optimization, peephole optimization and the like; optimizing the intermediate representation requires that the following principles be satisfied: firstly, the equivalence principle is that the running result of the program should not be changed after optimization; secondly, the equivalent principle is that even if the running time of the generated object code after optimization is shorter, the occupied storage space is smaller; thirdly, the cost-effective principle is that better optimization effect should be achieved at lower cost as much as possible.
S130, generating the local execution code according to the representation type of the intermediate representation by the code generation module.
In an embodiment of the present invention, the code generation module may be understood as a software module for converting the intermediate representation into locally executed code, and illustratively the code generation module may include various types of code generators, such as CodeSmith, myGenerator and CodePlus, etc. The representation type of the intermediate representation may be understood as a kind for representing the intermediate representation, and illustratively, the representation type of the intermediate representation may include an arithmetic type, a logic type, a branch type, a loop type, an SQL statement type, a cursor type, a complex type (Record, collection), a complex expression type (a system function or the like), and the like. Native execution code may be understood as machine code executable under a particular machine architecture, and illustratively, native execution code may include assembly code, binary code, and the like.
Specifically, the code generation module can convert the intermediate representation into corresponding local execution codes according to different representation types of the intermediate representation, and if the representation types of the intermediate representation can be identified by a preset compiler (for example, an LLVM compiler), the intermediate representation can be converted into the local execution codes of corresponding architecture platforms (x 86, ARM, etc.) by calling an assembly conversion instruction of the compiler; if the representation type of the intermediate representation cannot be identified by the preset compiler, the intermediate representation can be rewritten by a program, the related rewrite can be performed by a related query optimization mode, and then the rewritten intermediate representation is executed by a corresponding engine callback (for example, an SQL engine, an expression engine of a database, etc.), so that the intermediate representation is converted into a corresponding local execution code.
According to the technical scheme of the embodiment, the intermediate representation of the storage program is generated according to the grammar analysis module, the intermediate representation is optimized based on the data flow analysis optimization module, the local execution code is generated according to the representation type of the intermediate representation by the code generation module, the compiling optimization of the storage process is realized, and the execution efficiency of the code in the storage process is improved.
Example two
Fig. 2 is a flowchart of a compiling method for a storage process according to a second embodiment of the present invention, which is further optimized and expanded based on the foregoing embodiment, and may be combined with each of the optional technical solutions in the foregoing embodiment. As shown in fig. 2, the method for compiling a storage process provided in the second embodiment specifically includes the following steps:
s210, carrying out grammar analysis on the stored program at a grammar analysis module to generate a grammar analysis result.
In the embodiment of the present invention, the parsing result may be understood as a parsing result generated after parsing, and illustratively, the parsing result may include a lexical parsing judgment result, a syntax parsing judgment result, a semantic parsing judgment result, and the like.
Specifically, the parsing module parses a stored program of the source code to generate a corresponding parsing result, where the process of parsing the stored program to generate the parsing result may include, but is not limited to, the following steps: the source code is scanned into individual words, wherein the words can comprise keywords, identifiers, constants, operators, separators and the like, for example, for sentences: int a=b+c, and a corresponding lexical analysis judgment result, namely an identifier (int), an operator (+) and constants (a, b, c) is obtained through scanning; secondly, the stored program is subjected to grammar analysis to generate a grammar analysis judging result, namely word sequences are combined into various grammar phrases such as a program, a sentence, an expression and the like on the basis of lexical analysis, then the grammar analysis program judges whether a source code is correct in structure or not, the structure of the source code can be described by a context-free grammar, for example, for the example sentence, the grammar analysis judging result is int a=b+c; thirdly, carrying out semantic analysis on the stored program to generate a semantic analysis judgment result, namely checking whether the source code has semantic errors or not, and collecting type information, namely the semantic analysis judgment result.
S220, performing static single assignment on the grammar analysis result according to the grammar analysis module, and then using the static single assignment as an intermediate representation.
In embodiments of the present invention, a static single assignment (Static Single Assignment, SSA) may be understood as an attribute of the intermediate representation that requires each variable to be assigned only once and each variable to be defined prior to use.
Specifically, the generated grammar analysis result is subjected to static single assignment through the grammar analysis module, and the assigned result can be used as an intermediate representation. In some embodiments, the feature that each variable can be assigned only once may be implemented by adding a subscript, for example, the following code: y =1; y =2; x: =y, it can be seen that the assignment of the first row is not necessary, since y is assigned again in the second row and the value of y is used in the third row. Under SSA, the code will convert the following form: y1: =1; y2 =2; x1: =y2.
S230, performing at least one of constant propagation optimization, copying propagation optimization, survival analysis and dead code elimination on the intermediate representation in the data flow analysis optimization model.
In an embodiment of the present invention, the data flow analysis optimization model may be understood as a model for performing analysis optimization on the intermediate representation, and illustratively, the data flow analysis optimization model may be implemented by a compiler, where the compiler may be a Multi-Pass compiler. Constant propagation optimization is understood to mean that when compiling an intermediate representation, for a variable that is able to directly calculate a result (which is often a constant), this variable will be replaced by the compiler by the directly calculated result constant. The following code: x=3; y=4; z=x+y; after constant propagation optimization is carried out on the obtained product, the obtained result is x=3; y=4; z=3+4. A replication propagation optimization may be understood as a compiler, when compiling an intermediate representation, replaces two or more identical variables with one variable, for example the following piece of code: a=d+e; b=d+e; c=d+e; after the copying propagation optimization is carried out on the obtained result, the obtained result is t=d+e; a=t; b=t; c=t. Survival analysis can be understood as the decision analysis by a compiler on the assignment of program points and registers when compiling intermediate representations. Dead code elimination is understood to mean that when compiling an intermediate representation, the compiler will remove code that has no effect on the result of the program run.
Specifically, the data flow analysis optimization model can perform analysis optimization on the intermediate representation under the condition that the operation result of the intermediate representation is correct, so as to improve the execution efficiency, and the manner of performing analysis optimization on the intermediate representation can include, but is not limited to, the following types: constant propagation optimization, duplicate propagation optimization, survival analysis, and dead code elimination. Illustratively, the optimization procedure is described below taking the survival analysis for register allocation as an example: when the code performs an operation, variables required for the operation need to be read from the memory into the registers, and if all the registers are filled at this time, part of the variables need to be fetched from the registers and stored back into the memory. The problem of how to allocate decisions to registers can be solved with the active variable set. Firstly, an active variable set at a program point where the operation is located is obtained, and if a variable v is stored in one register and a variable w is stored in the other register, and the variable w is in the active variable set, and the variable v is not in the set, then the compiler will take the variable v out of the register preferentially, and ensure that the variable w which is used soon afterwards will be stored in the register.
S240, judging the representation type of the intermediate representation according to the code generation module.
Specifically, the code generation module may further determine the representation type of the intermediate representation according to the type of compiler used. In some embodiments, the instruction types supported by the compiler, such as LLVM, may be checked to determine the representation types of the intermediate representation according to the type of the compiler used, and the LLVM compiler may support representable instructions such as arithmetic, logic, branches, loops, etc., but may not support complex types such as SQL statements, cursors, complex types (Collection), and complex expressions (system functions, etc.).
S250, if the representation type is the representable instruction type, the code generation module calls a preset compiler to generate a local execution code of the intermediate representation.
In the embodiment of the present invention, the representable instruction type may be understood as an instruction type that can be recognized by a preset compiler. The preset compiler may be understood as a preset compiler that converts the intermediate representation into corresponding native execution code, and may include, for example, an LLVM compiler, an OceanBase compiler, a MemSQL compiler, and the like.
Specifically, if the representation type is a representable instruction type that can be identified by a preset compiler, the code generation module may call the compiler to convert the intermediate representation into a corresponding native execution code. In some embodiments, the preset compiler may be an LLVM compiler, and the intermediate representation may be converted into native execution code of the corresponding architecture platform (x 86, ARM, etc.) by invoking assembly conversion instructions of the compiler.
And S260, if the expression type is a special type, the code generation module calls the proxy execution module to call back the intermediate expression and generates the corresponding local execution code.
In the embodiment of the present invention, a special type may be understood as an instruction type that cannot be recognized by a preset compiler. The proxy execution module may be understood as a software module for converting a particular type of intermediate representation into corresponding native execution code, and may illustratively include de-correlating rewrites of the intermediate representation.
Specifically, if the representation type is a special type that cannot be identified by the preset compiler, the code generation module may call the proxy execution module to recall the intermediate representation to the original Go run time, and further convert the intermediate representation into the corresponding local execution code. It should be appreciated that some of the intermediate representation is not localized, e.g., SQL instructions, where LLVM IR needs to be recalled back to the Go execution environment.
Further, on the basis of the above embodiment of the present invention, the process of survival analysis of the intermediate representation may include the steps of:
determining non-surviving vector memory in the intermediate representation;
the variable of the intermediate representation is controlled to multiplex non-surviving vector memory.
In the embodiment of the present invention, the non-surviving vector memory is understood to be the memory occupied by the vector that is no longer surviving during the execution of the program.
Specifically, during the compilation process of the storage process, the non-surviving vector memory in the intermediate representation can be queried, and the non-surviving vector memory can be directly multiplexed for the generated new variables. In some embodiments, the vectors that are no longer viable, i.e., non-viable vectors, may be monitored in real time as the vectors in execution are compiled for application of memory, and then the non-viable vectors may be reused directly as memory is applied for a new variable, thus avoiding frequent allocation and reclamation of memory and further improving the compilation performance.
As shown in fig. 3, the process of calling the proxy execution module to call back the intermediate representation and generating the corresponding native execution code may include the following steps:
s310, processing the intermediate representation into a structured query statement code or a complex expression code according to a preset optimization rule.
In the embodiment of the present invention, the preset optimization rule may be understood as an optimization rule that processes the intermediate representation so that an engine callback may be performed on the processing result, and the preset optimization rule may include, for example, a rewrite operation that de-associates the intermediate representation. Structured query statement code may be understood as statement code written by SQL, which is a standard query language for databases. A complex expression code may be understood as an expression in which two or more simple expressions, which may be single constants, variables, columns, scalar functions, etc., are connected together by operators, illustratively the following is an example of a complex expression code that counts the number of occurrences of anonymous fields in a user table: SELECT a. User_anon_name as anon_name, COUNT (a. User_anon name) as num FROM xm_user a GROUP BY a. User_anon_name.
Specifically, for a particular type of intermediate representation, it may be converted into structured query statement code or complex expression code according to preset optimization rules. In some embodiments, for code generation of the SQL statement, the intermediate representation may be rewritten in a related query optimization manner, and illustratively, the intermediate representation may be rewritten into a temporary table and a left related query statement form, and after a preset optimization rule is processed, the intermediate representation may be converted into a structured query statement code or a complex expression code.
S320, the structured query statement code is sent to a structured query statement engine callback.
In embodiments of the present invention, a structured query statement engine may be understood as converting a query statement into an operation on a database, which may include Hive, impala, presto and Spark SQL, etc., for example.
Specifically, the converted structured query statement code can be sent to a corresponding structured query statement engine, and then the corresponding local execution code can be obtained through callback execution.
S330, sending the complex expression code to an expression engine callback.
In embodiments of the present invention, an expression engine may be understood as an expression-based database engine, which may include Janino, QL, mvel and Juel, for example.
Specifically, the converted complex expression codes can be sent to corresponding expression engines, and then the corresponding local execution codes can be obtained through callback execution.
Further, on the basis of the above embodiment of the present invention, the preset optimization rule may include:
the associated query statement is replaced within the intermediate representation with the temporary table and the left associated query statement.
In the embodiment of the present invention, the related query statement may be understood as a statement that performs related query with respect to a data table in a certain database or service system, etc., and the following is an example of the related query statement: select from t1 join t2 on t1. Id=t2. Id, select from t1 join t2 on t1. Id=t2. Id=t3. Id t3 on t2. Id=t3. Id. A temporary table is understood to be a data table for storing some temporary data. A left associated query term may be understood as a way of using left association (left join) for two tables involved in the associated query term to find out the content that meets the requirements.
Specifically, the associated query statement in the intermediate representation may be replaced with the temporary table and the left associated query statement using preset optimization rules. Illustratively, the following is an example of one associated query statement substitution: select sum (t 4. Id) from temporary table ($progid, $vecidx) leftjoin t4 on col5 = t4.Id group by col5.
According to the technical scheme, the stored program is subjected to grammar analysis at the grammar analysis module to generate a grammar analysis result, static single assignment is carried out on the grammar analysis result according to the grammar analysis module, then the grammar analysis result is used as an intermediate representation, at least one of constant propagation optimization, copying propagation optimization, survival analysis and dead code elimination is carried out on the intermediate representation by the data flow analysis optimization model, the representation type of the intermediate representation is judged according to the code generation module, if the representation type is the representable instruction type, the code generation module calls a preset compiler to generate a local execution code of the intermediate representation, and if the representation type is the special type, the code generation module calls the proxy execution module to call the intermediate representation and generate a corresponding local execution code, so that compiling optimization of the stored process is realized, the execution efficiency of the codes of the stored process is improved, the data processing performance is improved, and the data concurrency and throughput are increased.
Example III
Fig. 4 is a flowchart of a method for compiling a storage process according to a third embodiment of the present invention. The embodiment provides an implementation manner of a storage process compiling method based on the embodiment, which can implement compiling optimization and local execution of a storage process of source code. Fig. 5 is a flowchart illustrating a stored procedure compiling system according to the third embodiment of the invention.
S410, carrying out grammar analysis on the stored program to generate a grammar analysis result.
In the embodiment of the invention, the compiler involved is a compiler designed for a storage program language PL/SQL, namely an SQL-oriented procedural language, and supported grammar mainly originates from a facts standard Oracle PL/SQL of PL/SQL. The compiler related to the embodiment of the invention is a Multi-Pass compiler framework based on LLVM, and can convert PL/SQL codes into intermediate representations of lower abstract LLVM, thereby generating local execution codes through the LLVM.
The following briefly describes the principles of a localization execution framework of a translation in an embodiment of the present invention, as an example.
CREATE FUNCTION plfunc(a INT,b INT)RETURN INT IS
c INT；
d INT；
e INT；
BEGIN
c:＝a+b；
select sum(t4.id)into d from t4 where c＝t4.id；
e:＝c-d；
RETURN e；
END；
The code simply defines a PL/SQL function that receives two integer parameters and returns one integer parameter, in the function declaration section, two integer variables c and d are declared. Logic within the function body is as follows: the first statement is that the incoming variables a and b are added and then assigned to the variable c; the second statement is that an SQL Query is executed, the Query accesses the table t4, the sum of id columns is calculated, and the screening condition is that id is equal to variable c; the next step is to assign this sum to variable d, then execute c-d and assign it to variable e, and finally return variable e.
The flow of the compilation phase is shown in fig. 5. The following SQL statement call is used as an example:
SELECT plfunc(col1,col2)FROM tb1；
after the grammar analysis is completed, an execution plan is generated, when the grammar analysis is completed, plfunc execution logic is loaded from a cache when the grammar analysis is completed, and then plfunc.VecEvalint is called to enter vectorization execution. The following is an example of pseudo code for localized execution generated from this SQL statement:
specifically, the localization execution flow of the sql statement is as follows:
1. first, col1, col2 is mapped into plfunc function logic (AddMapping in pseudo code);
2. calling the LLVM JIT execution engine to execute plfunc;
3. if LLVM IR operation, then continue execution during JIT (just in time) such as the a+b logic in pseudo code;
a) And traversing the vector a by taking the vector a as a reference, calculating all the variables c at one time, and storing the variables c into the memory space of the variables c.
4. If the SQL call is an external SQL call, calling an executeQuery interface of the proxy system, and transmitting the execution ID of the current function and the SQL to be executed;
a) the temporal table (1, 2) is a new syntax structure, and refers to a temporary table generated by PL/sqlfunit, where 1 indicates the execution ID of Function, that is, $progid, and 2 indicates the sequence number VecIdx of the temporary table corresponding to the Function execution memory vector.
b) The syntax with temporary tables will generate an execution plan, contain operators such as HashAggr, join, and rely on the TempScan (1, 2) operator.
5. Also taking the vector a as a reference, executing subtraction, multiplexing the memory space of the vector a, and writing the value of the variable e;
6. finally, the vector a is returned.
S420, performing static single assignment on the grammar analysis result to serve as an intermediate representation.
And S430, optimizing the generated intermediate representation.
In some embodiments, optimizing the intermediate representation may include constant propagation optimization, duplicate propagation optimization, survival analysis, and dead code elimination work.
Further, on the basis of the embodiment of the invention, the embodiment of the invention provides a data flow analysis optimizing system. In the distributed database according to the embodiment of the present invention, golang is adopted as the main body of the database, native Code (local Code) is adopted for localized execution, and since the memory used by Native Code is difficult to manage, the embodiment of the present invention designs a related memory allocation and recovery mechanism, and uses survival analysis to implement memory optimization in the compiling and executing stage of the database storage process, and then the above-mentioned pseudo Code for localized execution is introduced and described.
It can be seen from the above-mentioned pseudo code of compiling execution that, when executing, a memory is applied for a vector (the vector is a column), and two columns of col1 and col2 can be regarded as two vectors in the example. In a distributed database, if the data size of the table is large, the corresponding vector is large, and thus the applied memory is large. Therefore, if memory is frequently applied and reclaimed, a very large overhead is incurred to the database. It can be seen from the pseudo code that when e: =c-d is executed, the memory space of the same vector is not applied for the vector e again, but the memory of the a vector which is no longer viable is directly multiplexed, so that frequent allocation and recycling are avoided, and the compiling performance is further improved.
S440, corresponding local execution codes are generated according to the representation types of the intermediate representation.
In some embodiments, embodiments of the present invention provide a code generation system. The embodiment of the invention mainly adopts LLVM IR as low-level IR representation, because LLVM provides more types and procedural logic, instruction types can be represented in common types, arithmetic, logic, branches, loops and the like, and a code generation system directly calls an API (ApplicationProgram Interface, application programming interface) of the LLVM for creation; while specific representation types for non-LLVM adaptation logic include, for example, SQL statements, cursors, complex types (Collection), complex expressions (system functions, and the like), and the like.
Taking SQL statement code generation as an example, SQL statement code generation is closely related to the proxy execution system and the vector memory management system. According to the conventional stored program implementation manner, when a function contains SQL, the number of the finally executed SQL is the number of times of executing the function multiplied by the number of SQL in the function, taking plfunc in the above example as an example, where a select statement is contained, when the tb1 table has 10000 rows, the plfunc is executed ten thousand times in a manner of conventional interpretation and execution, and similarly, the select statement in the plfunc is executed ten thousand times. When SELECT pfunc (col 1, col 2) FROM tb1 is executed ten thousand times, SELECT in the function is executed 1 hundred million times, that is, O (n 2) is a relation, and this execution amplification has serious consequences, such as a possibility that a simple execution may cause database crash.
The embodiment of the invention adopts an innovative associated query optimization and code generation mode, so that the complexity of original O (n 2) is reduced to O (n), and the performance is greatly improved. An associated query refers to SQL that contains the parameters entered in the stored program, so that the parameters represent columns that reference the look, essentially forming associated sub-queries.
select sum(t4.id)from temporary table($progID,$vecIdx)left joint4 on col5＝t4.id group by col5
The above is an SQL statement rewritten after the code generation in the pseudo code, and it can be seen that an original select statement is rewritten into a temporary table and t4 join statement. The reason for being able to rewrite this is that the distributed database associated with embodiments of the present invention holds for the following assumptions: 1. the storage program is similar to a projection operator and can map vector data;
2. the storage program belongs to a simple operator, has no materialization cost, and is not like a Join operator needing materialization;
3. the stored program has complex logic inside but is a closure, invisible to the planning layer.
In the process of rewriting, a c variable in an original SQL statement exists in a vector, a temporary Table (Temp Table) and t4 are constructed by the c variable, and a physical temporary Table is not really generated, but an innovatively introduced TempScan operator is used in generating a plan. Note that left join is used because the vector dimension is to be maintained, so the vector dimension of c is the same as the dimension of the incoming parameter, so the assigned variable d is the same dimension, so left join is needed to keep the final result consistent with the dimension of variable c.
By using the decorrelation rewriting mode, the performance can be greatly improved. After the rewrite is completed, a proxy SQL call is generated and the SQL statement is then passed to the SQL engine for execution. Similarly, for complex expressions, a proxy call is generated, and then the solution of the complex expression is performed by the expression engine of the distributed database itself.
In some embodiments, an embodiment of the present invention provides a proxy execution system. The proxy execution system essentially provides a set of standard C interfaces that call back from Native Code to the distributed database. The core is that a proxy system of a part pipeline generated by compiling and executing is provided. The advantage of this is: firstly, the excessively long time spent on compiling is avoided when compiling is performed; secondly, development costs are reduced, especially for expression systems, which would be a significant cost if code generation were reused to write the expression engine, by way of execution of the cold expression logic callback.
The agent execution system and the vectorized memory management system complement each other, and in the embodiment of the present invention, the agent execution system is defined as follows:
//export execQueryfunc execQuery(progId int,queryChars*C.char)C.int{
The execution query interface of the input/output system is used for executing the sql statement positioned in the queryChars
}
The input execution ID, int corresponds to a ProgRunningProxy buffer
var ProgProxyManager＝map[int]*ProgRunningProxy{}
type ProgRunningProxy struct{
Input*sqltypes.ColumnarResult
}
When the progproxymanaager executes the stored programs in a JIT mode, a memory management center of each stored program is bound with a ProgRunningProxy when each stored program JIT executes, wherein Input is column data, and AddColumn, getColumn and other methods can be adopted to insert, read and update the data.
According to the technical scheme, the grammar analysis is carried out on the storage program to generate the grammar analysis result, the grammar analysis result is subjected to static single assignment and then is used as the intermediate representation, the intermediate representation is optimized, the corresponding local execution code is generated according to the representation type of the intermediate representation, the compiling optimization of the storage process is realized, the execution efficiency of the code in the storage process is improved, the data processing performance is improved, and the data concurrency and throughput are increased.
Example IV
Fig. 6 is a schematic structural diagram of a storage process compiling system according to a fourth embodiment of the invention. As shown in fig. 6, the system includes:
the syntax analysis module 61 is used for generating an intermediate representation of the stored program.
A data flow analysis optimization module 62 for optimizing the intermediate representation.
The code generation module 63 is configured to generate locally executed code according to the representation type of the intermediate representation.
According to the technical scheme of the embodiment, the intermediate representation of the storage program is generated according to the grammar analysis module, the intermediate representation is optimized based on the data flow analysis optimization module, the local execution code is generated according to the representation type of the intermediate representation by the code generation module, the compiling optimization of the storage process is realized, and the execution efficiency of the code in the storage process is improved.
Further, on the basis of the above embodiment of the invention, the parsing module 61 includes:
and the grammar analysis result generation unit is used for carrying out grammar analysis on the stored program in the grammar analysis module so as to generate a grammar analysis result.
And the intermediate representation generating unit is used for carrying out static single assignment on the grammar analysis result according to the grammar analysis module and then taking the static single assignment as an intermediate representation.
Further, on the basis of the above embodiment of the present invention, the data flow analysis optimization module 62 includes:
an intermediate representation optimization unit for performing at least one of constant propagation optimization, duplicate propagation optimization, survival analysis, and dead code elimination on the intermediate representation in the data stream analysis optimization model.
Further, on the basis of the above embodiment of the present invention, the survival analysis of the intermediate representation specifically includes: determining non-surviving vector memory in the intermediate representation; the variable of the intermediate representation is controlled to multiplex non-surviving vector memory.
Further, on the basis of the above embodiment of the invention, the code generating module 63 includes:
and the representation type judging unit is used for judging the representation type of the intermediate representation according to the code generating module.
The first generation unit of the local execution code is used for calling a preset compiler to generate the local execution code of the intermediate representation if the representation type is the representable instruction type.
And the second generation unit of the local execution code is used for calling the proxy execution module to call the intermediate representation and generating the corresponding local execution code if the representation type is a special type.
Further, on the basis of the above embodiment of the present invention, the local execution code second generating unit is specifically configured to:
processing the intermediate representation into a structured query statement code or a complex expression code according to a preset optimization rule; sending the structured query statement code to a structured query statement engine callback; the complex expression code is sent to the expression engine callback.
Further, on the basis of the above embodiment of the present invention, the preset optimization rule includes:
the associated query statement is replaced within the intermediate representation with the temporary table and the left associated query statement.
The storage process compiling system provided by the embodiment of the invention can execute the storage process compiling method provided by any embodiment of the invention, and has the corresponding functional modules and beneficial effects of the executing method.
Example five
Fig. 7 shows a schematic diagram of an electronic device 70 that may be used to implement an embodiment of the invention. Electronic devices are intended to represent various forms of digital computers, such as laptops, desktops, workstations, personal digital assistants, servers, blade servers, mainframes, and other appropriate computers. Electronic equipment may also represent various forms of mobile devices, such as personal digital processing, cellular telephones, smartphones, wearable devices (e.g., helmets, glasses, watches, etc.), and other similar computing devices. The components shown herein, their connections and relationships, and their functions, are meant to be exemplary only, and are not meant to limit implementations of the inventions described and/or claimed herein.
As shown in fig. 7, the electronic device 70 includes at least one processor 71, and a memory, such as a Read Only Memory (ROM) 72, a Random Access Memory (RAM) 73, etc., communicatively connected to the at least one processor 71, wherein the memory stores a computer program executable by the at least one processor, and the processor 71 may perform various suitable actions and processes according to the computer program stored in the Read Only Memory (ROM) 72 or the computer program loaded from the storage unit 78 into the Random Access Memory (RAM) 73. In the RAM 73, various programs and data required for the operation of the electronic device 70 may also be stored. The processor 71, the ROM 72 and the RAM 73 are connected to each other via a bus 74. An input/output (I/O) interface 75 is also connected to bus 74.
Various components in the electronic device 70 are connected to the I/O interface 75, including: an input unit 76 such as a keyboard, a mouse, etc.; an output unit 77 such as various types of displays, speakers, and the like; a storage unit 78 such as a magnetic disk, an optical disk, or the like; and a communication unit 79 such as a network card, modem, wireless communication transceiver, etc. The communication unit 79 allows the electronic device 70 to exchange information/data with other devices via a computer network, such as the internet, and/or various telecommunication networks.
Processor 71 may be a variety of general and/or special purpose processing components having processing and computing capabilities. Some examples of processor 71 include, but are not limited to, a Central Processing Unit (CPU), a Graphics Processing Unit (GPU), various specialized Artificial Intelligence (AI) computing chips, various processors running machine learning model algorithms, digital Signal Processors (DSPs), and any suitable processor, controller, microcontroller, etc. The processor 71 performs the various methods and processes described above, such as the stored procedure compilation method.
In some embodiments, the stored procedure compiling method may be implemented as a computer program, which is tangibly embodied on a computer readable storage medium, such as the storage unit 78. In some embodiments, part or all of the computer program may be loaded and/or installed onto the electronic device 70 via the ROM 72 and/or the communication unit 79. When the computer program is loaded into RAM 73 and executed by processor 71, one or more steps of the stored procedure compiling method described above may be performed. Alternatively, in other embodiments, processor 71 may be configured to perform the stored procedure compilation method in any other suitable manner (e.g., by means of firmware).
Various implementations of the systems and techniques described here above may be implemented in digital electronic circuitry, integrated circuit systems, field Programmable Gate Arrays (FPGAs), application Specific Integrated Circuits (ASICs), application Specific Standard Products (ASSPs), systems On Chip (SOCs), load programmable logic devices (CPLDs), computer hardware, firmware, software, and/or combinations thereof. These various embodiments may include: implemented in one or more computer programs, the one or more computer programs may be executed and/or interpreted on a programmable system including at least one programmable processor, which may be a special purpose or general-purpose programmable processor, that may receive data and instructions from, and transmit data and instructions to, a storage system, at least one input device, and at least one output device.
A computer program for carrying out methods of the present invention may be written in any combination of one or more programming languages. These computer programs may be provided to a processor of a general purpose computer, special purpose computer, or other programmable data processing apparatus, such that the computer programs, when executed by the processor, cause the functions/acts specified in the flowchart and/or block diagram block or blocks to be implemented. The computer program may execute entirely on the machine, partly on the machine, as a stand-alone software package, partly on the machine and partly on a remote machine or entirely on the remote machine or server.
In the context of the present invention, a computer-readable storage medium may be a tangible medium that can contain, or store a computer program for use by or in connection with an instruction execution system, apparatus, or device. The computer readable storage medium may include, but is not limited to, an electronic, magnetic, optical, electromagnetic, infrared, or semiconductor system, apparatus, or device, or any suitable combination of the foregoing. Alternatively, the computer readable storage medium may be a machine readable signal medium. More specific examples of a machine-readable storage medium would include an electrical connection based on one or more wires, a portable computer diskette, a hard disk, a Random Access Memory (RAM), a read-only memory (ROM), an erasable programmable read-only memory (EPROM or flash memory), an optical fiber, a portable compact disc read-only memory (CD-ROM), an optical storage device, a magnetic storage device, or any suitable combination of the foregoing.
To provide for interaction with a user, the systems and techniques described here can be implemented on an electronic device having: a display device (e.g., a CRT (cathode ray tube) or LCD (liquid crystal display) monitor) for displaying information to a user; and a keyboard and a pointing device (e.g., a mouse or a trackball) through which a user can provide input to the electronic device. Other kinds of devices may also be used to provide for interaction with a user; for example, feedback provided to the user may be any form of sensory feedback (e.g., visual feedback, auditory feedback, or tactile feedback); and input from the user may be received in any form, including acoustic input, speech input, or tactile input.
The systems and techniques described here can be implemented in a computing system that includes a background component (e.g., as a data server), or that includes a middleware component (e.g., an application server), or that includes a front-end component (e.g., a user computer having a graphical user interface or a web browser through which a user can interact with an implementation of the systems and techniques described here), or any combination of such background, middleware, or front-end components. The components of the system can be interconnected by any form or medium of digital data communication (e.g., a communication network). Examples of communication networks include: local Area Networks (LANs), wide Area Networks (WANs), blockchain networks, and the internet.
The computing system may include clients and servers. The client and server are typically remote from each other and typically interact through a communication network. The relationship of client and server arises by virtue of computer programs running on the respective computers and having a client-server relationship to each other. The server can be a cloud server, also called a cloud computing server or a cloud host, and is a host product in a cloud computing service system, so that the defects of high management difficulty and weak service expansibility in the traditional physical hosts and VPS service are overcome.
It should be appreciated that various forms of the flows shown above may be used to reorder, add, or delete steps. For example, the steps described in the present invention may be performed in parallel, sequentially, or in a different order, so long as the desired results of the technical solution of the present invention are achieved, and the present invention is not limited herein.
The above embodiments do not limit the scope of the present invention. It will be apparent to those skilled in the art that various modifications, combinations, sub-combinations and alternatives are possible, depending on design requirements and other factors. Any modifications, equivalent substitutions and improvements made within the spirit and principles of the present invention should be included in the scope of the present invention.
Claims (8)
1. A stored procedure compiling method, comprising:
generating an intermediate representation of the stored program according to the parsing module;
optimizing the intermediate representation based on a data flow analysis optimization module;
generating locally executed code according to the representation type of the intermediate representation according to a code generation module;
wherein the generating locally executed code according to the representation type of the intermediate representation according to the code generation module comprises:
Judging the representation type of the intermediate representation according to the code generation module;
if the representation type is the representable instruction type, the code generation module calls a preset compiler to generate the local execution code of the intermediate representation;
if the representation type is a special type, the code generation module calls an agent execution module to call back the intermediate representation and generates the corresponding local execution code;
the call agent execution module recalls the intermediate representation and generates the corresponding local execution code, including:
processing the intermediate representation into a structured query statement code or a complex expression code according to a preset optimization rule;
sending the structured query statement code to a structured query statement engine callback;
and sending the complex expression code to an expression engine callback.
2. The method of claim 1, wherein generating an intermediate representation of the stored program from the parsing module comprises:
parsing the stored program at the parsing module to generate a parsed result;
and carrying out static single assignment on the grammar analysis result according to the grammar analysis module to serve as the intermediate representation.
3. The method of claim 1, wherein the optimizing the intermediate representation based on the data flow analysis optimization module comprises:
at least one of constant propagation optimization, duplication propagation optimization, survival analysis, and dead code elimination is performed on the intermediate representation at the dataflow analysis optimization model.
4. A method according to claim 3, wherein the survival analysis of the intermediate representation comprises:
determining non-surviving vector memory within the intermediate representation;
and controlling the variable of the intermediate representation to multiplex the non-survival vector memory.
5. The method of claim 1, wherein the preset optimization rules comprise:
the associated query statement is replaced within the intermediate representation with the temporary table and the left associated query statement.
6. A stored procedure compiling system, comprising:
a syntax analysis module for generating an intermediate representation of the stored program;
the data flow analysis optimization module is used for optimizing the intermediate representation;
a code generation module for generating locally executed code according to the representation type of the intermediate representation;
wherein the code generation module comprises:
A representation type judging unit configured to judge the representation type of the intermediate representation according to the code generating module;
a first generation unit of local execution code, configured to, if the representation type is a representable instruction type, invoke a preset compiler to generate the local execution code of the intermediate representation;
the local execution code second generation unit is used for calling the proxy execution module to call back the intermediate representation and generating the corresponding local execution code if the representation type is a special type;
the second generation unit of the native execution code is specifically configured to:
processing the intermediate representation into a structured query statement code or a complex expression code according to a preset optimization rule; sending the structured query statement code to a structured query statement engine callback; and sending the complex expression code to an expression engine callback.
7. An electronic device, the electronic device comprising:
at least one processor; and
a memory communicatively coupled to the at least one processor; wherein,,
the memory stores a computer program executable by the at least one processor to enable the at least one processor to perform the stored procedure compiling method of any one of claims 1 to 5.
8. A computer readable storage medium storing computer instructions for causing a processor to implement the stored procedure compiling method of any one of claims 1 to 5 when executed.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202211549760.9A CN115809063B (en) | 2022-12-05 | 2022-12-05 | Storage process compiling method, system, electronic equipment and storage medium |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202211549760.9A CN115809063B (en) | 2022-12-05 | 2022-12-05 | Storage process compiling method, system, electronic equipment and storage medium |
Publications (2)
| Publication Number | Publication Date |
|---|---|
| CN115809063A CN115809063A (en) | 2023-03-17 |
| CN115809063B true CN115809063B (en) | 2023-08-22 |
Family
ID=85484946
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202211549760.9A Active CN115809063B (en) | 2022-12-05 | 2022-12-05 | Storage process compiling method, system, electronic equipment and storage medium |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN115809063B (en) |
Families Citing this family (2)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN116661804B (en) * | 2023-07-31 | 2024-01-09 | 珠海市芯动力科技有限公司 | Code compiling method, code compiling device, electronic device and storage medium |
| CN116755714B (en) * | 2023-08-16 | 2023-11-10 | 腾讯科技（深圳）有限公司 | Method, device, equipment and storage medium for operating deep neural network model |
Citations (7)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN110187885A (en) * | 2019-06-10 | 2019-08-30 | 合肥本源量子计算科技有限责任公司 | A kind of the intermediate code generation method and device of the compiling of quantum program |
| CN110673854A (en) * | 2019-09-24 | 2020-01-10 | 深圳前海微众银行股份有限公司 | SAS language compiling method, device, equipment and readable storage medium |
| CN112346730A (en) * | 2020-11-04 | 2021-02-09 | 星环信息科技(上海)股份有限公司 | Intermediate representation generation method, computer equipment and storage medium |
| CN112364053A (en) * | 2020-11-25 | 2021-02-12 | 成都佳华物链云科技有限公司 | Search optimization method and device, electronic equipment and storage medium |
| CN114064601A (en) * | 2020-06-22 | 2022-02-18 | 金篆信科有限责任公司 | Storage process conversion method, device, equipment and storage medium |
| CN114253554A (en) * | 2020-09-21 | 2022-03-29 | 华为技术有限公司 | Code processing method and device and storage medium |
| CN114327477A (en) * | 2021-12-26 | 2022-04-12 | 杭州趣链科技有限公司 | Intelligent contract execution method and device, electronic device and storage medium |
-
2022
- 2022-12-05 CN CN202211549760.9A patent/CN115809063B/en active Active
Patent Citations (7)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN110187885A (en) * | 2019-06-10 | 2019-08-30 | 合肥本源量子计算科技有限责任公司 | A kind of the intermediate code generation method and device of the compiling of quantum program |
| CN110673854A (en) * | 2019-09-24 | 2020-01-10 | 深圳前海微众银行股份有限公司 | SAS language compiling method, device, equipment and readable storage medium |
| CN114064601A (en) * | 2020-06-22 | 2022-02-18 | 金篆信科有限责任公司 | Storage process conversion method, device, equipment and storage medium |
| CN114253554A (en) * | 2020-09-21 | 2022-03-29 | 华为技术有限公司 | Code processing method and device and storage medium |
| CN112346730A (en) * | 2020-11-04 | 2021-02-09 | 星环信息科技(上海)股份有限公司 | Intermediate representation generation method, computer equipment and storage medium |
| CN112364053A (en) * | 2020-11-25 | 2021-02-12 | 成都佳华物链云科技有限公司 | Search optimization method and device, electronic equipment and storage medium |
| CN114327477A (en) * | 2021-12-26 | 2022-04-12 | 杭州趣链科技有限公司 | Intelligent contract execution method and device, electronic device and storage medium |
Also Published As
| Publication number | Publication date |
|---|---|
| CN115809063A (en) | 2023-03-17 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| CN110187885B (en) | Intermediate code generation method and device for quantum program compiling | |
| CN115809063B (en) | Storage process compiling method, system, electronic equipment and storage medium | |
| CN111309757B (en) | SQL interpreter and optimization method of HBase | |
| CN107038222B (en) | Database cache implementation method and system | |
| US9122540B2 (en) | Transformation of computer programs and eliminating errors | |
| US9164742B2 (en) | Method and a system for searching for parts of a computer program which affects a given symbol | |
| US7523125B2 (en) | Parsing system | |
| CN110209668B (en) | Dimension table association method, device and equipment based on stream calculation and readable storage medium | |
| CN108369591B (en) | System and method for caching and parameterizing IR | |
| Spies et al. | Transfinite Iris: resolving an existential dilemma of step-indexed separation logic | |
| CN110780879B (en) | Decision execution method, device, equipment and medium based on intelligent compiling technology | |
| CN113296786B (en) | Data processing method, device, electronic equipment and storage medium | |
| CN111309751A (en) | Big data processing method and device | |
| CN111221852A (en) | Mixed query processing method and device based on big data | |
| CN114691148A (en) | Model reasoning acceleration method and device, electronic equipment and storage medium | |
| US10839124B1 (en) | Interactive compilation of software to a hardware language to satisfy formal verification constraints | |
| CN114356964A (en) | Data blood margin construction method and device, storage medium and electronic equipment | |
| CN111221888A (en) | Big data analysis system and method | |
| CN108664238A (en) | A kind of execution method and device of explanation type script C-SUB | |
| CN116204550A (en) | Database query statement optimization method, storage medium and device | |
| JP7344259B2 (en) | Pattern transformation methods, apparatus, electronic devices, computer storage media and computer program products in deep learning frameworks | |
| CN111221841A (en) | Real-time processing method and device based on big data | |
| CN112114817A (en) | COBOL language-based data dictionary field information acquisition method and device | |
| CN116560667B (en) | Splitting scheduling system and method based on precompiled delay execution | |
| CN115563183B (en) | Query method, query device and program product |
Legal Events
| Date | Code | Title | Description |
|---|---|---|---|
| PB01 | Publication | ||
| PB01 | Publication | ||
| SE01 | Entry into force of request for substantive examination | ||
| SE01 | Entry into force of request for substantive examination | ||
| GR01 | Patent grant | ||
| GR01 | Patent grant |