FR2883652A1 - Sub markup e.g. digital image, accessing method for use during extensible markup language file, involves verifying existence of index in file, in response to request of access to sub markup, by verifying presence of index in sub markup - Google Patents

Abstract

The method involves verifying an existence of an index associated to a mother markup and represented in the form of a table, in a extensible markup language file, in response to an access request to a chosen sub markup. A carriage return is inserted at an end of the index. The index existence is verified by verifying the index presence in the sub markup. An identifier of a request is compared with table identifiers based on a comparison and search law if the index existence verification result is positive. The position of the sub markup is obtained and the sub markup is directly accessed. Independent claims are also included for the following: (1) a device for accessing a sub markup during reading a markup language file (2) an information medium readable by a computer system and comprising instructions of a computer program for implementing a method of accessing the sub markup (3) a computer program stored on an information medium including instructions permitting to implement a sub markup accessing method.

Description

The present invention relates to access to a sub-tag during the

  reading a file written in markup language.

  It finds a general application in the processing of data flows written in markup language and more particularly in XML, an acronym for eXtensible Markup Language, that is to say extensible tag language.

  XML is a computer language used to format documents using Markup tags.

  In practice, XML is a data description format and not their representation or display.

  The XML format is increasingly used for storing and transmitting digital data. For example, to represent a photo album.

  This is not without generating a number of problems. In particular, when the amount of data to be represented is important. Access to these data can then take a long time.

  This is particularly the case when only a subset of these data is needed, for example a digital photograph from a photo album.

  Rather than having access to all the photographs, there is usually the problem of knowing if a particular photograph is contained in the album (for example to check whether the person making the request is authorized to view this photograph) .

  XML is not an indexed format. It is therefore not possible to directly access information concerning only a particular photograph.

  More seriously, trying to do so would inevitably miss the namespace declarations that encompass this data.

  A known solution is to use a database to automatically index XML data. However, this solution is slow and restrictive. Slow because access to a single file, no matter how big, is faster than access to a database, even powerful.

  Binding because it is more difficult to update the entire database than a simple file. Moreover, a file can be more easily shared between several computers, in a conventional system of load sharing, than a database, which instead forms a bottleneck.

  It is therefore useful to be able to easily index an XML file.

  However, for reasons of ease of use, this indexing must be included directly in the XML file and not in a separate file.

  Moreover, the XML file thus indexed must be readable by any XML parser, even if it is not compatible with an index (in this case, obviously, the indexing will not be available, but the data will be fully readable as if the index was not present).

  The Applicant has had the problem of adding such an index to an XML file.

  The present invention provides a solution to this problem. It relates to a method of accessing a sub-tag when reading a file written in markup language.

  According to a general definition of the invention, the method is characterized in that it comprises the following steps: 1) in response to a request for access to a chosen sub-tag contained in a mother tag and accompanied by an identifier , checking in the file, the existence of an index associated with the mother tag and represented in the form of a table contained in said file and comprising, for each sub-tag of the mother tag, at least one line of correspondence between an identifier assigned to the sub-tag and at least the position of the sub-tag in the file, 2) in the case of positive verification, go to the table and compare the identifier of the request with the identifiers of said table according to a law of search and comparison chosen, 3) in case of a positive comparison, obtain the position of the sub-tag and directly access the sub-tag from said position thus obtained.

  In one embodiment, the identifiers are ranked in the index in a chosen order and the law of search and comparison is of the dichotomous type.

  In practice, the storage order of the identifiers is of ascending type.

  In another embodiment, provision is made beforehand to create an index according to the following steps: i) to create a table comprising, for each sub-tag, at least one line of correspondence between an identifier assigned to the sub-tag and the tag; minus the position of the sub-file in the file, ii) sort the correspondence lines in a chosen order according to the identifier, and iii) write in markup language the index from the table thus created in the file to a chosen place.

  In practice, the verification of the existence of an index consists in verifying the presence of a comment tag written in markup language and capable of containing said index.

  Such an index stored in a comment tag does not interfere with analyzers (parsers) not including the invention. The index is automatically ignored by such parsers.

  For example, the comment tag is placed at the end of the file.

  Alternatively, the comment tag is the first subtag of the parent tag.

  In another embodiment, the verification of the existence of an index consists in verifying the presence of a predetermined attribute in the mother tag.

  According to yet another embodiment, in each line of correspondence the identifier is in a reduced form according to the application of a reduction law, the law of search and comparison using said law of reduction.

  In practice, the law of reduction is stored in the file.

  The present invention also relates to a device for accessing a sub-tag when reading a file written in markup language.

  According to another aspect of the invention, the device comprises: means capable of verifying, in response to a request for access to a chosen sub-tag contained in a mother tag accompanied by an identifier, to be checked in the file , the existence of an index associated with the mother tag and represented in the form of a table contained in said file and comprising, for each sub-tag of the mother tag, at least one line of correspondence between an identifier assigned to the sub-tag and at least the position of the sub-tag in the file; processing means capable, in the case of a positive verification, to go into the table and to compare the identifier of the request with the identifiers of said table, according to a chosen law of search and comparison; and - access means capable, in the case of a positive comparison, to obtain the position of the sub-beacon and to directly access the sub-beacon from said position thus obtained.

  According to one embodiment, the device further comprises authoring means capable of creating a table comprising for each sub-tag at least one line of correspondence between an identifier assigned to the sub-tag and at least the position of the sub-tag in the file. , sorting the correspondence lines according to an order chosen according to the identifier and writing in markup language the index from the table thus created in the file at a chosen location.

  The present invention also relates to an information medium readable by a computer system characterized in that it comprises instructions of a computer program for implementing the access method referred to above, when the program is loaded. and executed by a computer system.

  The present invention also relates to a removable information medium partially or completely readable by a computer system, characterized in that it comprises instructions of a computer program for implementing an access method referred to ci before when the program is loaded and executed by a computer system.

  Finally, a subject of the present invention is a computer program stored on an information medium, said program comprising instructions for implementing an access method referred to above when the program is loaded and executed by a system. computer.

  Other features and advantages of the invention will become apparent in the light of the detailed description and the drawings in which: FIG. 1 is a flowchart illustrating the algorithm for searching for a sub-tag when reading a XML file according to the invention-Figure 2 is a flowchart illustrating the search by dichotomy according to the invention; FIG. 3 is a flowchart illustrating the basic steps of the method according to the invention; FIG. 4 is a flowchart illustrating the algorithm for creating an index according to the invention; FIG. 5 is a flowchart illustrating the writing algorithm of the index according to the invention; and FIG. 6 schematically represents the physical resources of a computer capable of implementing the invention.

  Referring to FIG. 1, there is shown a flowchart illustrating the steps of an algorithm for searching for a sub-tag (for example an image or digital photograph) when reading an XML file (for example containing a photo album).

  In practice, each digital photograph or image has a unique identifier (the key, in the rest of the algorithm).

  For the last image of the file, the identification has for example the value 4191 bl dd-f302-6a48-a99b-2366f4d0ec1b. This value uniquely identifies the image among all albums, and therefore especially for that one.

  It is considered to run the algorithm that one seeks to obtain the digital data concerning this particular image.

  We know that this is the last image, but the parser or the parser of the computer will know that by browsing the entire XML file 5 to finally reach this image.

  The process starts from an XML file (step E1), opens the file (Step E2) and goes to the end of the file (Step E3).

  According to step E4, the method in a preferred embodiment reads the XML file by the end (since that is where the index is).

  According to step E5, the method verifies that the file ends with a comment, otherwise the process does a search without index (step E6).

  According to step E7, the method reads the field preceding the end of the comment and verifies (Step E8) that it is equal to http: // crf. gun. en / oml / xml-index. This URI indicates the presence of an index in the format specified by the invention. The method implements a search without index in the opposite case.

  Arrived at this stage, the method knows that one has an index conforming to the format according to the invention.

  According to step E9, the method reads the preceding field. This is the pointer (relative distance) to the beginning of the index.

  In accordance with step E10, the method accesses the beginning of the index directly, and reads the next field (Step E11).

  In accordance with step E12, the method verifies that it is an opening comment. If not, the method sets up a search without index (Step E13).

  According to step E14, the method verifies that the following field is the URI http://crf.canon.fr/oml/xml-index (optional). The purpose of this step is to double the check in case the index has been corrupted during the first check.

  The method then successively reads the size o of the offset field, the size c of the key field, and the number n of records.

  The index being sorted by increasing keys, the method then performs according to step E15 a search by dichotomy to (possibly) find the desired key.

  The process is then repeated until the method falls on the key (Steps E16 or E18) or on a zero interval corresponding to an unsuccessful search (Steps E16 and E17).

  The dichotomous search is 0 (log (n)) instead of 0 (n) for the sequential search, that is, it is much faster because it requires fewer comparisons. Because keys and offsets are all the same size, it is relatively easy to point to any entry in the index.

  The process returns the offset of the key, if it actually found it. Otherwise it returns the value zero (Step E17).

  The method directly accesses the beacon sought via the offset obtained above (Step E18).

  Referring to Figure 2, the dichotomy search is described in detail. The initial steps E50 to E56 consist in defining the beginning of the file P1 (Steps E50), the end of the file P2 (Step E52), and the middle of the file Pm containing the index (Steps E54 and E56). The search by dichotomy accesses the middle of the file containing the index and reads the corresponding entry Pm (Step E58). If the middle key of the file corresponds (Step E60) to the searched key (equality of the identifiers), the corresponding offset (offset) is returned (Step E62). In case of inequality, depending on whether the middle key is larger or smaller than the key to be searched for (Step E64), the process continues the search between the beginning and the middle (Step E70) or the middle and end of the search. file (Step E82). The process is then repeated until the method results in the key to be searched (equality of the identifiers) (Steps E80 or E84) or on a zero interval (Step E88).

  The algorithm described with reference to FIG. 1 thus allows direct access to an XML tag. In the example, once the offset of the known tag, the method accesses directly on the last IMG tag, the one whose CONTENT ID attribute contains the value 4191 bl ddf302-6a48-a99b-2366f4d0ec1 b.

  In practice, the algorithm is modified to work with XML namespace.

  XML namespaces allow two users to create tags of the same name. Conflict is avoided by prefixing these tags with a different prefix. For example: <namespacel: IMG> <namespace2: IMG> The problem could again arise from two users defining the same namespace.

  To solve this problem permanently, a namespace is uniquely defined by a URI. It is the URI (eg http: // canon.cf / en / ns / one), not its reference (eg namespacel) which is used for all comparisons.

  These naming URls define themselves on a tag. For example, below, we unambiguously define the two prefixes namespacel and namespace 2: <COLLECTION xmins: namespacel = "http://crf.canon.fr/ns/one" xmins: namespace1 = "http: // crf .canon en / ns / two "> To manage namespaces correctly, it is necessary to analyze them (parser).

  Therefore, the following new step E19 is inserted between the preceding steps E17 and E18. This step is used to manage namespaces.

  Thus according to step E19, the method reads as conventionally the XML file from the beginning to the following comment, which indicates the beginning of the point where it can use the index without having any problem with the namespaces (since now it has read declarations of namespaces and so knows their values): <! - http://crf.canon. en / oml / xmlindex-start -!> Alternatively, the comment tag is not only an indicator of the possibility of using the index but the index itself. Thus, the index itself can be provided in the first sub-tag of the mother tag.

  In another variant, the presence of the index can also be indicated by a predetermined attribute on the mother tag, for example: <COLLECTION xmlns: index = "http://crf.canon.fr/oml/index" index: INDEXED = "true"> In the example of the photo album, all images have a unique identifier. This may not be the case, it may have to be built, or at least reduced in size. Reducing the size reduces the number of character comparisons to be made. Indeed, using the index, it is necessary constantly to compare the value of the searched key with the information contained in the index. The longer the key, the longer this comparison takes. On large files, this time is not negligible.

  However, the way to reduce the keys differs according to the applications. It is therefore not possible to impose a common way.

  To overcome this drawback, the method according to the invention directly insert in the XML file the way to reduce the keys.

  In practice, after the size of the index (fifth field from the beginning of the index), we add the following field: Value of the reduction function (that is to say hash) used. Two examples of this field's value are: hash = "id.value ()" hash = "id.value () [1] + id.value () [- 1]" In the first case above, it's is the identity function. In the second, we use as a hash value a key its first and last character.

  In practice, the JavaScript programming language is used for the definition of the hash values. This language is well known to those skilled in the art and readily available.

  With reference to FIG. 3, the basic steps of the algorithm for searching for a particular image (sub-tag) during the reading of an XML file are described. These basic steps include a step E90 of defining a position P in the file; a file positioning step E92 of said position P thus defined; an E94 step of reading the offset; a key reading step E96; and a data return step E98.

  With reference to FIG. 4, the steps illustrating the algorithm for creating the index according to the invention have been described.

  To use the index, you must first create it.

  The creation can be done: either during the generation of XML data; either in a post-processing step, once all the data available.

  In the following, only the second algorithm is considered. The first is easily deductible.

  The type of element to be indexed is considered to be provided by an XPath path.

  XPath is a syntax for describing the path to an XML node.

  In the case of the album of digital photographs, one wishes to index all the IMG tags. These tags are sub-tags contained in the COLLECTION parent tag. So we indicate as XPath path: "COLLECTION / IMG" At the same time, we want to indicate that the value of the keys 25 is contained in the attribute: CONTENT ID. This information is added directly to the XPath path, which becomes: "COLLECTION / IMG @ CONTENT_ID" Alternatively, a second XPath path is used to indicate the value of the keys, as they can be stored at a different location than the XML document.

  Using two XPath paths, one for tags, the other for keys, has the further advantage that the first XPath path can now contain conditions. For example, you can use: "COLLECTION / IMG [position ()> 5]" to index all but the first five images.

  If it is desired to reduce the size of the keys, as previously indicated, a hash function will also be provided.

  With this information, it is now possible to index this subpart of the XML document.

  The creation algorithm and index is as follows: According to step E100, the method consists of creating an empty array t. It will contain the index at the end of the algorithm.

  In step E102, it is expected to initialize the variable i to one. In accordance with step E104, the method traverses the XML document until it finds the searched tag.

  According to step E106, the method notes the o position of this tag in the file (i.e., the number of characters from the beginning of the file, to the <starting tag).

  According to step E108, the method passes the attributes of this tag and identifies (El 10) that containing the key.

  According to step E112, the method reads the value c of the attribute containing the key. If necessary, it is planned to replace c by the hash value of c. According to the step E114, the method stores (o, c) in the table t (] According to the step E116, it is expected to increment i.

  Then the process skips the tags or sub-tags, reads the closing tag (of the searched tag) and reads the next tag (Step E118). If there are no more, the process proceeds to step E122.

  If it is again a tag to be indexed, the method continues in step E106. Otherwise, it continues in step E118.

  According to step E122, the method sorts the array t according to the order of the increasing keys.

  According to step E124, the method writes the index.

  With reference to FIG. 5, the writing algorithm of the index according to the invention has been described.

  The actual writing of the index is carried out as follows in a preferred embodiment: According to step E200, it is planned to open the XML file. According to step E202, the method is positioned at the same time. extreme end of the file.

  It is planned to verify that there is not already an index and if necessary, to eliminate it.

  According to step E204, the method notes the current position p (i.e. the beginning of the index).

  According to step E206, the method writes an opening comment.

  For example, the comment is http://crf.canon.fr/oml/xml-index (Step E208).

  The process writes the length of the offset field (this is the length of the smallest string that will contain the largest offset in the table t). For example, the length of the offset field is equal to 7 (step E210).

  The method writes the length of the key field (Step E212). In the example of the photo album, all the keys are of identical lengths. The method writes the size of the array t (Step E214).

  According to step E222, the method traverses the array t, and for each element, writes the offset, then the key.

  According to step E224, the method writes the variable p. According to step E226, the method writes the comment http://crf.canon.fr/oml/xml-index, and according to step E228, it writes the comment 25 finally closing and closing the file (Step E230).

  As a variant, as mentioned with reference to FIG. 1, the comment is written not at the end of the file but in the first sub-tag of the mother tag requiring indexing.

  In another variant, the comment is written by writing a predetermined attribute in the mother tag requiring indexing.

  For the sake of simplicity, above, we have omitted the space entries that separate the fields.

  On the other hand, if you want the index to be easily read by a human being, you have to insert a carriage return: after the index header; after each key; at the end of the index.

  In addition, for all offsets to be the same size, it may be necessary to add zeros in the header. Thus, the offset 123 will become for example: 0000123, which allows to have all the offsets on 7 characters.

  One may want to index several subparts of the same XML document.

  In this case, the index is modified as follows (other variants are possible): The index contains several subindices.

  A master index is used to list the different subindices. This is the main index that is contained at the very end of the file.

  A compact representation of these sub-indexes, which fits into a single XML comment, is as follows: Commentaire Comment opening http http: // crf. canon.fr/oml/xml-index É Index offset field size 1 É Index key field size 1 É Index size 1 É Offset1, i É Clef1, i É Offset2,1 É Clef2 Offset, 1 Key, i Offset field size of index n Key index field size n Index size n Offset1, nKey1, n Offset2, n É Clef2, n É Offsetn, n É Clefn, n É Offset of the beginning of the index 1 É Offset of the beginning of the index 2 É Offset of the beginning of the index n É Number of index É http: // crf .cc / oml / xml-index E Comment closing With reference to FIG. 6, the physical resources of a programmable device 200 capable of implementing the invention have been represented.

  The apparatus 200 comprises a communication bus 202, to which are connected: a central processing unit 203 (microprocessor, CPU) which controls the exchanges between the various elements of the apparatus; a read-only memory (ROM) 204 that can comprise the programs of the invention (Prog1, Prog2); a random access memory (RAM) 206; a hard disk 212 may include the aforementioned programs; a keyboard 210; a digital camera 201; a screen 208; a diskette drive 214 adapted to receive a floppy disk 216 and to read or write there documents treated or to be treated according to the invention; A communication interface 218 connected to a communication network 220, for example the Internet network, the interface being able to transmit and receive documents.

  The communication bus 202 allows communication and interoperability between the various elements included in the device or connected to it. The representation of the bus is not limiting and, in particular, the central unit is capable of communicating instructions to any element of the apparatus directly or via another element of the apparatus.

  The executable code of each program enabling the programmable device to implement the processes according to the invention can be stored for example in the hard disk 212 or in the read-only memory 204.

  According to an alternative embodiment, the floppy disk 216 may contain documents as well as the executable code of the aforementioned programs which, once read by the apparatus, is stored in the hard disk 212.

  According to another embodiment, the executable code of the programs can be received via the communication network, via the interface 106, to be stored identically to that described above.

  Floppies can be replaced by any information medium such as, for example, a compact disc (CD ROM) or a memory card. In general, an information storage means, visible by a computer or by a microprocessor, whether or not integrated into the device, possibly removable, is adapted to store one or more programs whose execution allows the implementation of the process according to the invention.

  More generally, the program or programs can be loaded into one of the storage means of the device before being executed.

  The central unit 203 controls and directs the execution of the instructions or portions of software code of the program or programs according to the invention, instructions which are stored in the hard disk 212 or the read-only memory 204, or else in the other storage elements supra. When powering on, the program or programs that are stored in a non-volatile memory, for example the hard disk 212 or the ROM 204, are transferred into the RAM RAM 206 which will then contain the executable code of the program or programs. according to the invention, as well as registers for memorizing the variables of the parameters necessary for the implementation of the invention.

  It should be noted that the programmable apparatus comprising the device according to the invention may also be a programmed apparatus.

  This device then contains the code of the computer program or programs, for example fixed in a specific application integrated circuit (ASIC).

Claims (16)

  1. A method of accessing a sub-tag when reading a file written in markup language, the method being characterized in that it comprises the following steps: 1) in response to an access request to a chosen sub-tag contained in a mother tag and accompanied by an identifier, checking in the file, the existence of an index associated with the mother tag and represented in the form of a table contained in said file and including, for each sub-tag of the mother tag, at least one line of correspondence between an identifier assigned to the sub-tag and at least the position of the sub-tag in the file, 2) in case of positive verification, go to the table and compare the identifier of the request with the identifiers of said array according to a chosen search and comparison law, 3) in the case of a positive comparison, obtain the position of the sub-tag and directly access the sub-tag from of said position thus obtained.   2. Method according to claim 1, wherein the identifiers are arranged in the index in a chosen order and the law of search and comparison is of the dichotomous type.   3. Method according to claim 2, wherein the storage order of the identifiers is of ascending type.   4. Method according to any one of the preceding claims, wherein it is planned in advance to create an index according to the following steps: i) create a table comprising, for each sub-tag, at least one line of correspondence between an identifier assigned to the sub-tag and at least the position of the sub-tag in the file, ii) sorting the match lines according to an order chosen according to the identifier, iii) writing in markup language the index from the array created in the file at a chosen location.   5. Method according to one of the preceding claims, wherein the verification of the existence of an index is to verify the presence of a comment tag written in markup language and able to contain said index.   6. The method of claim 5, wherein said comment tag is placed at the end of the file.   The method of claim 5, wherein said comment tag is the first subtag of the mother tag.   8. The method according to one of claims 1 to 4, wherein verifying the existence of an index consists in verifying the presence of a predetermined attribute in the mother tag.   9. Method according to one of the preceding claims, characterized in that in each line of correspondence the identifier is in a reduced form according to the application of a reduction law, the law of search and comparison using said law of reduction.   10. Method according to claim 9, characterized in that the reduction law is stored in the file.   11. The method of claim 9 or 10, characterized in that the reduction law is a hash function.   12. Device for accessing a sub-tag when reading a file written in markup language, characterized in that it comprises: -suitable verification means, in response to a request for access to a underlines selected contained in a mother tag accompanied by an identifier, to check in the file, the existence of an index associated with the mother tag and represented in the form of a table contained in said file and including, for each sub tag of the mother tag, at least one line of correspondence between an identifier assigned to the sub-tag and at least the position of the sub-tag in the file; processing means capable, in the case of a positive verification, to go into the table and to compare the identifier of the request with the identifiers of said table, according to a chosen law of search and comparison; and - access means capable, in the case of a positive comparison, to obtain the position of the sub-beacon and to directly access the sub-beacon from said position thus obtained.   13. Device according to claim 12, characterized in that it further comprises creation means able to create a table comprising for each sub-tag at least one line of correspondence between an identifier assigned to the sub-tag and at least the position of the sub-tag in the file, to sort the lines of correspondence according to an order chosen according to the identifier and to write in markup language the index from the table thus created in the file at a chosen location .   14. Information medium readable by a computer system, characterized in that it comprises instructions of a computer program for implementing an access method according to any one of claims 1 to 11, when this program is loaded and executed by a computer system.   15. Information carrier removable, partially or completely readable by a computer system, characterized in that it comprises instructions of a computer program for implementing an access method according to any one of the claims. 1 to 11, when the program is loaded and executed by a computer system.   16. A computer program stored on an information medium, said program comprising instructions for implementing an access method according to any one of claims 1 to 11, when the program is loaded and executed by a computer system.