CN110688402A - Directory query method, device, equipment and computer readable storage medium - Google Patents
Directory query method, device, equipment and computer readable storage medium Download PDFInfo
- Publication number
- CN110688402A CN110688402A CN201910893910.XA CN201910893910A CN110688402A CN 110688402 A CN110688402 A CN 110688402A CN 201910893910 A CN201910893910 A CN 201910893910A CN 110688402 A CN110688402 A CN 110688402A
- Authority
- CN
- China
- Prior art keywords
- directory
- mds
- message queue
- queried
- fetch operation
- 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.)
- Granted
Links
- 238000000034 method Methods 0.000 title claims abstract description 88
- 239000012634 fragment Substances 0.000 claims abstract description 58
- 230000008569 process Effects 0.000 claims abstract description 50
- 230000000977 initiatory effect Effects 0.000 claims abstract description 20
- 238000004590 computer program Methods 0.000 claims description 11
- 238000010586 diagram Methods 0.000 description 3
- 230000003993 interaction Effects 0.000 description 3
- 238000012986 modification Methods 0.000 description 2
- 230000004048 modification Effects 0.000 description 2
- 238000013500 data storage Methods 0.000 description 1
- 238000005516 engineering process Methods 0.000 description 1
- 238000000125 metastable de-excitation spectroscopy Methods 0.000 description 1
- 230000000750 progressive effect Effects 0.000 description 1
- 230000004044 response Effects 0.000 description 1
Images
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F16/00—Information retrieval; Database structures therefor; File system structures therefor
- G06F16/20—Information retrieval; Database structures therefor; File system structures therefor of structured data, e.g. relational data
- G06F16/24—Querying
- G06F16/245—Query processing
- G06F16/2455—Query execution
Landscapes
- Engineering & Computer Science (AREA)
- Theoretical Computer Science (AREA)
- Computational Linguistics (AREA)
- Data Mining & Analysis (AREA)
- Databases & Information Systems (AREA)
- Physics & Mathematics (AREA)
- General Engineering & Computer Science (AREA)
- General Physics & Mathematics (AREA)
- Information Retrieval, Db Structures And Fs Structures Therefor (AREA)
Abstract
The invention discloses a method, a device, equipment and a computer readable storage medium for directory query, which comprises the following steps: starting a new target process on the MDS where the inode corresponding to the directory to be queried is located to process the directory query request sent by the daemon interface; initiating fetch operation of N fragments in a target process; judging whether data exists in the message queue, if so, processing the data in the message queue and storing directory information; judging whether the number of fragments executing the fetch operation is N or not, if so, circularly executing the operation of judging whether data exists in the message queue or not, and judging whether the number of fragments executing the fetch operation is N or not until the processing of all the fragments in the directory to be inquired is completed; and returning the generated target directory information to the daemon interface. The method, the device, the equipment and the computer readable storage medium provided by the invention can quickly inquire the large directory.
Description
Technical Field
The present invention relates to the field of big data storage technologies, and in particular, to a method, an apparatus, a device, and a computer-readable storage medium for directory query.
Background
In large data stores, large directories may appear, containing hundreds of thousands, or even millions, of files. Directory lookups are currently implemented via ls commands. ls, when querying, eventually calls the readdir method. In readdir, files under the directory fragments are sequentially obtained from the MDS. For a large directory, it is impossible to load all of the directory into memory for our direct use. Therefore, the MDS also needs to perform a fetch operation, read directory information in the corresponding OSD, and load it into the mdcache. All the operations are executed by threads, so that the method is very time-consuming, and when the operations are loaded into the mdcache, the cache used by the service can be lost by the trim, and the service performance is influenced.
From the above, it can be seen that how to quickly query a large directory is a problem to be solved at present.
Disclosure of Invention
The invention aims to provide a directory query method, a directory query device, equipment and a computer readable storage medium, so as to solve the problem that the directory query method in the prior art is long in time consumption and can affect service performance.
In order to solve the above technical problem, the present invention provides a method for directory query, including: s1: after the original MDS receives a directory query request sent by a daemon interface, judging whether the MDS where the inode corresponding to the directory to be queried is located is on the original MDS; s2: if the MDS where the inode corresponding to the directory to be queried is located is on the original MDS, starting a new target process on the original MDS to process the directory query request; s3: initiating fetch operation of N fragments in the target process so as to obtain data of each fragment in the directory to be queried and returning the obtained data to a message queue; s4: judging whether data exists in the message queue or not, if so, processing the data in the message queue, and acquiring and storing directory information to the message queue; s5: judging whether the number of the fragments which are executing fetch operation is N; s6: if the number of the slices executing the fetch operation is N, circularly executing the steps S4 to S6 until the processing of all the slices in the directory to be inquired is completed; s7: and generating target directory information of the directory to be queried according to the directory information of each fragment in the directory to be queried, which is stored in the message queue, and returning the target directory information to the daemon interface.
Preferably, after the original MDS receives the directory query request sent by the daemon interface, the step of determining whether the MDS where the inode corresponding to the directory to be queried is located is on the original MDS further includes:
if the MDS where the inode corresponding to the directory to be inquired is not located on the original MDS, forwarding the directory inquiry request to the MDS where the inode corresponding to the directory to be inquired is located, and processing the directory inquiry request by using the MDS where the inode corresponding to the directory to be inquired is located.
Preferably, the processing the directory query request by using the MDS in which the inode corresponding to the directory to be queried is located includes:
and processing the directory query request by utilizing the dispatcher process of the MDS where the inode corresponding to the directory to be queried is located.
Preferably, the determining whether the number of slices executing the fetch operation is N further includes:
and if the number of the fragments which are executing the fetch operation is less than N, continuously initiating the fetch operation in the target process until the number of the fragments which are executing the fetch operation is N.
Preferably, if there is data in the message queue, processing the data in the message queue, and acquiring and storing directory information to the message queue includes:
and if the data exists in the message queue, starting a new process to process the data in the message queue, acquiring directory information, and storing the directory information into the message queue.
The invention also provides a device for directory query, which comprises:
the system comprises a first judgment module, a second judgment module and a third judgment module, wherein the first judgment module is used for judging whether the MDS where the inode corresponding to a directory to be inquired is located is on the original MDS or not after the original MDS receives a directory inquiry request sent by a daemon interface;
the process starting module is used for starting a new target process on the original MDS to process the directory query request if the MDS where the inode corresponding to the directory to be queried is located is on the original MDS;
the initiating module is used for initiating fetch operation of the N fragments in the target process so as to obtain data of each fragment in the directory to be inquired and returning the obtained data to a message queue;
the data processing module is used for judging whether data exist in the message queue or not, if so, processing the data in the message queue, and acquiring and storing directory information to the message queue;
the second judgment module is used for judging whether the number of the fragments which are executing fetch operation is N or not;
the loop module is used for executing the starting step of the data processing module if the number of the fragments which are executing fetch operation is N until the processing of all the fragments in the directory to be inquired is completed;
and the generating module is used for generating target directory information of the directory to be queried according to the directory information of each fragment in the directory to be queried, which is stored in the message queue, and returning the target directory information to the daemon interface.
Preferably, the first determining module further comprises:
and the forwarding module is used for forwarding the directory query request to the MDS where the inode corresponding to the directory to be queried is located if the MDS where the inode corresponding to the directory to be queried is located is not located on the original MDS, and processing the directory query request by utilizing the MDS where the inode corresponding to the directory to be queried is located.
Preferably, the second determining module further comprises:
and the fetch operation initiating module is used for continuously initiating the fetch operation in the target process if the number of the fragments which are executing the fetch operation is less than N until the number of the fragments which are executing the fetch operation is N.
The invention also provides a device for directory query, which comprises:
a memory for storing a computer program; a processor for implementing the steps of the above-mentioned directory querying method when executing the computer program.
The present invention also provides a computer-readable storage medium having stored thereon a computer program which, when executed by a processor, implements the steps of a method of directory enquiry as described above.
The directory query method provided by the invention is realized by using a daemon interface. And when the daemon interface receives a directory query request, sending the directory query request to the original MDS. And when the original MDS receives the directory query request, searching the MDS where the inode corresponding to the directory to be queried is located. And judging whether the MDS where the inode corresponding to the directory to be inquired is located is the original MDS, if so, starting a new target process on the original MDS to process the directory inquiry request. And initiating fetch operation of the N fragments in the target process so as to acquire data of each fragment in the directory to be queried and returning the acquired data to a message queue. And judging whether data exist in the message queue or not, if so, processing the data, acquiring directory information in the data, and storing the directory information to the message queue. And judging whether the number of the fragments executing the fetch operation is N or not, if so, circularly executing the operation of judging whether data exists in the message queue or not, and judging whether the number of the fragments executing the fetch operation is N or not until the processing of all the fragments in the directory to be inquired is completed. And generating target directory information of the directory to be inquired according to the directory information of each fragment stored in the message queue, and returning the target directory information to the daemon interface so that the daemon interface can display the target directory information on a display screen. The directory query method provided by the invention starts a new directory query processing request, thereby reducing the influence on MDS service. The invention simultaneously initiates the fetch operation of N sub-slices, thereby improving the directory query efficiency; and data acquired by the fetch operation are stored in the message queue, and the data do not need to be stored in the mdcache any more, so that the message interaction among MDS is reduced, and the influence on the service is reduced to the greatest extent while the quick query of the large directory is realized.
Drawings
In order to more clearly illustrate the embodiments or technical solutions of the present invention, the drawings used in the description of the embodiments or the prior art will be briefly described below, and it is obvious that the drawings in the following description are only some embodiments of the present invention, and it is obvious for those skilled in the art that other drawings can be obtained based on these drawings without creative efforts.
FIG. 1 is a flowchart of a directory lookup method according to a first embodiment of the present invention;
FIG. 2 is a timing diagram illustrating a directory lookup method according to an embodiment of the present invention;
FIG. 3 is a flowchart of a second embodiment of a directory lookup method according to the present invention;
fig. 4 is a block diagram of a directory querying apparatus according to an embodiment of the present invention.
Detailed Description
The core of the invention is to provide a method, a device, equipment and a computer readable storage medium for directory query, which can improve the speed and efficiency of large directory query and reduce the influence on business.
In order that those skilled in the art will better understand the disclosure, the invention will be described in further detail with reference to the accompanying drawings and specific embodiments. It is to be understood that the described embodiments are merely exemplary of the invention, and not restrictive of the full scope of the invention. All other embodiments, which can be derived by a person skilled in the art from the embodiments given herein without making any creative effort, shall fall within the protection scope of the present invention.
Referring to fig. 1, fig. 1 is a flowchart illustrating a directory lookup method according to a first embodiment of the present invention; the specific operation steps are as follows:
step S101: after the original MDS receives a directory query request sent by a daemon interface, judging whether the MDS where the inode corresponding to the directory to be queried is located is on the original MDS;
in this embodiment, a daemon interface is newly added, and the command format is as follows: icfs daemonnds.0 get _ count _ file path; wherein, path is the directory to be queried. And adding new command logic in the dispatcher process of the daemon of the MDS.
Step S102: if the MDS where the inode corresponding to the directory to be queried is located is on the original MDS, starting a new target process on the original MDS to process the directory query request;
step S103: initiating fetch operation of N fragments in the target process so as to obtain data of each fragment in the directory to be queried and returning the obtained data to a message queue;
step S104: judging whether data exists in the message queue or not, if so, processing the data in the message queue, and acquiring and storing directory information to the message queue;
step S105: judging whether the number of the fragments which are executing fetch operation is N;
step S106: if the number of the fragments executing the fetch operation is N, circularly executing the steps S104 to S106 until the processing of all the fragments in the directory to be inquired is completed;
step S107: and generating target directory information of the directory to be queried according to the directory information of each fragment in the directory to be queried, which is stored in the message queue, and returning the target directory information to the daemon interface.
As shown in fig. 2, when the daemon interface receives a directory query request, the directory query request is sent to mds.0. Judging whether the MDS of the inode corresponding to the directory to be inquired is on mds.0, and if the MDS of the inode corresponding to the directory to be inquired is on mds.0, starting a new process to process the directory request to be inquired. Batch initiating fetch operation of N fragments, and returning the obtained data to the message queue. And judging whether data exists in the message queue, and if so, processing the data to acquire the file name. Judging whether the number of fragments executing the fetch operation reaches N, if not, continuing to initiate the fetch operation until the distribution number of the executing fetch operation reaches N, circularly executing to judge whether data exists in the message queue, and if so, processing the data to acquire a file name; and judging whether the number of the fragments executing the fetch operation reaches N, if not, continuing to initiate the fetch operation until the distribution number of the executing fetch operation reaches N, and returning a response message until all the fragments of the directory to be inquired are processed.
In the embodiment, the directory query request is processed by using an independent thread, and when fetch operation is executed, data is not stored in the mdcache but is directly processed, so that the influence on the service of the MDS is very small; the batch fetch operation is adopted, and the execution efficiency is improved. The fetch operation directly processes data, so that the message does not need to be distributed to the MDS where the fragments are located for processing, and message interaction among the MDS is reduced.
Based on the above embodiment, in this embodiment, if the MDS in which the inode corresponding to the directory to be queried is located is not in mds.0, the directory query request is forwarded to the MDS in which the inode corresponding to the directory to be queried is located, and the directory query request is processed by using the dispatcher process on the MDS in which the inode corresponding to the directory to be queried is located.
Referring to fig. 3, fig. 3 is a flowchart illustrating a directory query method according to a second embodiment of the present invention; the specific operation steps are as follows:
step S301: after the original MDS receives a directory query request sent by a daemon interface, whether a target MDS where an inode corresponding to a directory to be queried is located is on the original MDS is judged;
step S302: if the target MDS where the inode corresponding to the directory to be queried is located is not located on the original MDS, forwarding the directory query request to the target MDS, and processing the directory query request by using a dispatcher process of the target MDS;
step S303: starting a new target process on the target MDS to process the directory query request;
step S304: initiating fetch operation of N fragments in the target process so as to obtain data of each fragment in the directory to be queried and returning the obtained data to a message queue;
step S305: judging whether data exists in the message queue or not, if so, processing the data in the message queue, and acquiring and storing directory information to the message queue;
in the embodiment provided by the invention, data in the message queue can be processed by using a single thread or even multiple threads, so that the query of a large directory is realized more quickly.
Step S306: judging whether the number of the fragments which are executing fetch operation is N;
step S307: if the number of the fragments which are executing the fetch operation is smaller than N, continuously initiating the fetch operation in the target process until the number of the fragments which are executing the fetch operation is N;
step S308: circularly executing the step S305 to the step S307 until the processing of all the fragments in the directory to be inquired is completed;
step S309: generating target directory information of the directory to be queried according to the directory information of each fragment in the directory to be queried, which is stored in the message queue;
step S310: and returning the target directory information to the daemon interface so that the daemon interface can send the target directory information to a display screen to display the target directory information.
In the embodiment, the independent thread is adopted to process the directory query request, so that the influence on the MDS service is reduced; simultaneously, catch operation of a plurality of directory fragments is initiated, so that the directory query efficiency is effectively improved; data acquired by the fetch operation are stored in the message queue for processing, and the data do not need to be stored in the mdcache any more, so that message interaction between MDSs is reduced. The directory query method provided by the embodiment reduces the influence on the MDS service to the maximum extent while realizing the rapid query of the large directory.
Referring to fig. 4, fig. 4 is a block diagram illustrating a directory querying apparatus according to an embodiment of the present invention; the specific device may include:
the first judging module 100 is configured to, after the original MDS receives a directory query request sent by the daemon interface, judge whether an MDS where an inode corresponding to a directory to be queried is located is on the original MDS;
a process starting module 200, configured to start a new target process on the original MDS to process the directory query request if the MDS in which the inode corresponding to the directory to be queried is located is on the original MDS;
the initiating module 300 is configured to initiate fetch operation of the N segments in the target process so as to obtain data of each segment in the directory to be queried, and return the obtained data to a message queue;
a data processing module 400, configured to determine whether data exists in the message queue, and if data exists in the message queue, process the data in the message queue, and obtain and store directory information in the message queue;
a second determining module 500, configured to determine whether the number of slices executing the fetch operation is N;
a loop module 600, configured to execute the starting step of the data processing module if the number of the slices executing the fetch operation is N, until the processing of all the slices in the directory to be queried is completed;
a generating module 700, configured to generate target directory information of the directory to be queried according to directory information of each segment in the directory to be queried, where the directory information is stored in the message queue, and return the target directory information to the daemon interface.
The device for directory query of this embodiment is used to implement the foregoing method for directory query, and therefore specific implementations of the device for directory query may be found in the foregoing embodiments of the method for directory query, for example, the first determining module 100, the process starting module 200, the initiating module 300, the data processing module 400, the second determining module 500, the loop module 600, and the generating module 700, which are respectively used to implement steps S101, S102, S103, S104, S105, S106, and S107 in the method for directory query, so that specific implementations thereof may refer to descriptions of corresponding embodiments of each part, and are not described herein again.
The specific embodiment of the present invention further provides a device for directory query, including: a memory for storing a computer program; a processor for implementing the steps of the above-mentioned directory querying method when executing the computer program.
The specific embodiment of the present invention further provides a computer-readable storage medium, where a computer program is stored on the computer-readable storage medium, and when the computer program is executed by a processor, the computer program implements the steps of the above directory query method.
The embodiments are described in a progressive manner, each embodiment focuses on differences from other embodiments, and the same or similar parts among the embodiments are referred to each other. The device disclosed by the embodiment corresponds to the method disclosed by the embodiment, so that the description is simple, and the relevant points can be referred to the method part for description.
Those of skill would further appreciate that the various illustrative elements and algorithm steps described in connection with the embodiments disclosed herein may be implemented as electronic hardware, computer software, or combinations of both, and that the various illustrative components and steps have been described above generally in terms of their functionality in order to clearly illustrate this interchangeability of hardware and software. Whether such functionality is implemented as hardware or software depends upon the particular application and design constraints imposed on the implementation. Skilled artisans may implement the described functionality in varying ways for each particular application, but such implementation decisions should not be interpreted as causing a departure from the scope of the present invention.
The steps of a method or algorithm described in connection with the embodiments disclosed herein may be embodied directly in hardware, in a software module executed by a processor, or in a combination of the two. A software module may reside in Random Access Memory (RAM), memory, Read Only Memory (ROM), electrically programmable ROM, electrically erasable programmable ROM, registers, hard disk, a removable disk, a CD-ROM, or any other form of storage medium known in the art.
The method, apparatus, device and computer-readable storage medium for directory lookup provided by the present invention are described in detail above. The principles and embodiments of the present invention are explained herein using specific examples, which are presented only to assist in understanding the method and its core concepts. It should be noted that, for those skilled in the art, it is possible to make various improvements and modifications to the present invention without departing from the principle of the present invention, and those improvements and modifications also fall within the scope of the claims of the present invention.
Claims (10)
1. A method of directory lookup, comprising:
s1: after the original MDS receives a directory query request sent by a daemon interface, judging whether the MDS where the inode corresponding to the directory to be queried is located is on the original MDS;
s2: if the MDS where the inode corresponding to the directory to be queried is located is on the original MDS, starting a new target process on the original MDS to process the directory query request;
s3: initiating fetch operation of N fragments in the target process so as to obtain data of each fragment in the directory to be queried and returning the obtained data to a message queue;
s4: judging whether data exists in the message queue or not, if so, processing the data in the message queue, and acquiring and storing directory information to the message queue;
s5: judging whether the number of the fragments which are executing fetch operation is N;
s6: if the number of the slices executing the fetch operation is N, circularly executing the steps S4 to S6 until the processing of all the slices in the directory to be inquired is completed;
s7: and generating target directory information of the directory to be queried according to the directory information of each fragment in the directory to be queried, which is stored in the message queue, and returning the target directory information to the daemon interface.
2. The method of claim 1, wherein after the original MDS receives a directory query request sent by a daemon interface, the determining whether the MDS where an inode corresponding to a directory to be queried is located is on the original MDS further comprises:
if the MDS where the inode corresponding to the directory to be inquired is not located on the original MDS, forwarding the directory inquiry request to the MDS where the inode corresponding to the directory to be inquired is located, and processing the directory inquiry request by using the MDS where the inode corresponding to the directory to be inquired is located.
3. The method of claim 2, wherein the processing the directory query request with the MDS in which the inode corresponding to the directory to be queried is located comprises:
and processing the directory query request by utilizing the dispatcher process of the MDS where the inode corresponding to the directory to be queried is located.
4. The method of claim 1, wherein determining whether the number of slices in which a fetch operation is being performed is N further comprises:
and if the number of the fragments which are executing the fetch operation is less than N, continuously initiating the fetch operation in the target process until the number of the fragments which are executing the fetch operation is N.
5. The method of claim 1, wherein if there is data in the message queue, processing the data in the message queue, and obtaining and storing directory information to the message queue comprises:
and if the data exists in the message queue, starting a new process to process the data in the message queue, acquiring directory information, and storing the directory information into the message queue.
6. An apparatus for directory queries, comprising:
the system comprises a first judgment module, a second judgment module and a third judgment module, wherein the first judgment module is used for judging whether the MDS where the inode corresponding to a directory to be inquired is located is on the original MDS or not after the original MDS receives a directory inquiry request sent by a daemon interface;
the process starting module is used for starting a new target process on the original MDS to process the directory query request if the MDS where the inode corresponding to the directory to be queried is located is on the original MDS;
the initiating module is used for initiating fetch operation of the N fragments in the target process so as to obtain data of each fragment in the directory to be inquired and returning the obtained data to a message queue;
the data processing module is used for judging whether data exist in the message queue or not, if so, processing the data in the message queue, and acquiring and storing directory information to the message queue;
the second judgment module is used for judging whether the number of the fragments which are executing fetch operation is N or not;
the loop module is used for executing the starting step of the data processing module if the number of the fragments which are executing fetch operation is N until the processing of all the fragments in the directory to be inquired is completed;
and the generating module is used for generating target directory information of the directory to be queried according to the directory information of each fragment in the directory to be queried, which is stored in the message queue, and returning the target directory information to the daemon interface.
7. The apparatus of claim 6, wherein the first determining module further comprises:
and the forwarding module is used for forwarding the directory query request to the MDS where the inode corresponding to the directory to be queried is located if the MDS where the inode corresponding to the directory to be queried is located is not located on the original MDS, and processing the directory query request by utilizing the MDS where the inode corresponding to the directory to be queried is located.
8. The apparatus of claim 6, wherein the second determining module further comprises:
and the fetch operation initiating module is used for continuously initiating the fetch operation in the target process if the number of the fragments which are executing the fetch operation is less than N until the number of the fragments which are executing the fetch operation is N.
9. An apparatus for directory queries, comprising:
a memory for storing a computer program;
a processor for implementing the steps of a method of directory enquiry as claimed in any one of claims 1 to 5 when executing said computer program.
10. A computer-readable storage medium, having stored thereon a computer program which, when being executed by a processor, carries out the steps of a method for directory enquiry as claimed in any one of claims 1 to 5.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN201910893910.XA CN110688402B (en) | 2019-09-20 | 2019-09-20 | Method, device and equipment for querying directory and computer readable storage medium |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN201910893910.XA CN110688402B (en) | 2019-09-20 | 2019-09-20 | Method, device and equipment for querying directory and computer readable storage medium |
Publications (2)
| Publication Number | Publication Date |
|---|---|
| CN110688402A true CN110688402A (en) | 2020-01-14 |
| CN110688402B CN110688402B (en) | 2022-06-07 |
Family
ID=69109653
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN201910893910.XA Active CN110688402B (en) | 2019-09-20 | 2019-09-20 | Method, device and equipment for querying directory and computer readable storage medium |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN110688402B (en) |
Citations (3)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US20120259823A1 (en) * | 2011-04-08 | 2012-10-11 | Symantec Corporation | Partitioning a directory while accessing the directory |
| US20180095984A1 (en) * | 2015-06-19 | 2018-04-05 | Hitachi, Data Systems Engineering Uk Limited | A fast and efficient multi-threaded algorithm for deleting an arbitrarily wide and deep directory tree using limited system resources |
| CN108920631A (en) * | 2018-06-29 | 2018-11-30 | 郑州云海信息技术有限公司 | A kind of file polling method, apparatus, equipment and readable storage medium storing program for executing |
-
2019
- 2019-09-20 CN CN201910893910.XA patent/CN110688402B/en active Active
Patent Citations (3)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US20120259823A1 (en) * | 2011-04-08 | 2012-10-11 | Symantec Corporation | Partitioning a directory while accessing the directory |
| US20180095984A1 (en) * | 2015-06-19 | 2018-04-05 | Hitachi, Data Systems Engineering Uk Limited | A fast and efficient multi-threaded algorithm for deleting an arbitrarily wide and deep directory tree using limited system resources |
| CN108920631A (en) * | 2018-06-29 | 2018-11-30 | 郑州云海信息技术有限公司 | A kind of file polling method, apparatus, equipment and readable storage medium storing program for executing |
Also Published As
| Publication number | Publication date |
|---|---|
| CN110688402B (en) | 2022-06-07 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| US9560165B2 (en) | BT offline data download system and method, and computer storage medium | |
| CN109614377B (en) | File deletion method, device, equipment and storage medium of distributed file system | |
| CN107872528B (en) | Message pushing method and device | |
| CN110162529B (en) | Data processing method, service server and data processing system | |
| CN110427386B (en) | Data processing method, device and computer storage medium | |
| EP3054386B1 (en) | Execution plan storage method, device and system | |
| CN107329976B (en) | Webpage paging method and device, computer equipment and computer readable storage medium | |
| CN110851474A (en) | Data query method, database middleware, data query device and storage medium | |
| CN107665235B (en) | Cache processing method and device, computer equipment and storage medium | |
| WO2017075520A1 (en) | Cloud file processing method and apparatus | |
| CN110764688A (en) | Method and device for processing data | |
| CN108595121B (en) | Data storage method and device | |
| CN110688402B (en) | Method, device and equipment for querying directory and computer readable storage medium | |
| CN111966682B (en) | White list protection matching method, system, terminal and storage medium | |
| CN110633300A (en) | Breakpoint continuous operation method and device for nested query | |
| CN111026669A (en) | Test log management method, test log management device, and storage medium | |
| CN114218317B (en) | Progress information management and control method, micro-service device, electronic equipment and storage medium | |
| CN112286878A (en) | File scanning method, device, terminal and storage medium | |
| CN110852603A (en) | High-throughput wind control data processing method, device, equipment and storage medium | |
| CN113296977B (en) | Message processing method and device | |
| CN111261206B (en) | Read-write method and device, electronic equipment and readable storage medium | |
| CN112395057B (en) | Data processing method and device based on timing task and computer equipment | |
| CN106446080B (en) | Data query method, query service equipment, client equipment and data system | |
| CN112950370A (en) | Service processing method, device, equipment and storage medium | |
| WO2020019450A1 (en) | Split asynchronous loading method and apparatus, terminal device, and storage medium |
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 |