A portion of the disclosure of this patent document contains material that is subject to copyright protection. The copyright owner has no objection to the facsimile reproduction by anyone of the patent document or patent disclosure as it appears in the Patent and Trademark Office patent file or records, but otherwise reserves all copyright rights whatsoever.
Data entry and processing environments may provide for data entries, e.g., that are input by a user. Alternatively, the data entries may be input in other ways, for example, automatically in response to some event or process. The data entries may be structured in an infinite number of ways. For example, in one instance, the data entries may be structured to include two data elements. The first data element may be a numerical value. The second data element may be a character array of 10 characters. In another instance, the data entries may be structured to include three data elements. The first data element may be a character array of 5 characters. The second and third data elements may each be a numerical value. A particular data element of a data entry can itself be structured to include more data elements.
Computer applications, e.g., software, may operate upon the data entries. Since the data entries may be structured in various ways, the application that operates upon the data entries may require information that describes the structure of the data entries. Otherwise, the application may treat the data entries improperly. For example, without the information, the application may treat as a numerical value a data element that is a character array. Consequently, a data entry may need to conform to a predefined structure. In this way, information that describes the predefined structure, and by extension the structure of the data entry, may be made available. The data structure definition may be used as the information that describes the predefined structure. A file that includes a collection of data elements of a data entry with a description of each data element may then be generated. The description may be in terms associated with the data structure definition. The application that is to operate upon the data entry may operate upon the described data elements of the data entry that is within the file, and thereby correctly operate upon each data element of the data entry in accordance with the information. Alternatively, the generation of the collection of data elements with descriptions may be eliminated and the application itself may instead be programmed to correctly operate upon the data entry. According to this latter instance, a data structure definition defines the structure according to which a data entry conforms, and also manipulates the functionalities of an application.
Often computer applications of one data processing environment provide functionalities not provided by computer applications of other data processing environments. Consequently, the possibility arises that a data entry, input within one data processing environment, may be operated upon by an application of a different data processing environment.
However, data processing environments may differ in the way in which to define a data structure. If a data structure is defined in one data processing environment, the data structure definition may not be interpreted by a second data processing environment. Also, the definition of the data structure in one data processing environment may not manipulate the functionalities of an application of a second data processing environment. The possibility therefore arises that the application that is to operate upon the data entry is unable to do so because the application cannot interpret the data structure definition and because the functionalities of the application have not been manipulated to correctly process data entries. For example, a data structure may be defined in and for a lottery game management system. Point of sale devices of the lottery game management system may be used for inputting lottery game transaction data entries. Other data management applications of the lottery game management system may be used to store the inputted data entries, and to keep track of winning lottery data entries. Still further tasks to be performed upon the data entries, e.g., statistics reporting, may be outsourced to data processing applications that may not be of the lottery game management system. However, these latter applications may not be able to perform their assigned tasks since they are not applications of the system in which the data structure for the lottery data entries was defined. Other systems in which this problem may arise include, e.g., bill pay systems, pre-paid phone card systems, government licensing systems, e.g., systems of the department of motor vehicles, event ticket sales systems, and other transaction processing systems.
Accordingly, there is a need in the art for a system and/or method that extracts data entries input in a first processing environment and converts the data entries so that an application of a second processing environment, that cannot operate upon data entries that are in accordance with a data structure defined in the first processing environment, can operate upon the data entries.
Embodiments of the present invention generally relate to conversion of data entries input in accordance with one data structure. The data entries may be converted to be in accordance with another data structure. More particularly, embodiments relate to an extraction utility that creates extraction classes to convert data entries input in accordance with a legacy data structure to be in accordance with an industry-standard data structure and to be operated upon by non-legacy applications.
A data entry is in accordance with a legacy data structure when applications of the legacy processing environment may operate upon the data entry, but applications of other processing environments may not be able to operate upon the data entry. This circumstance may arise when the data entry is input within a legacy processing environment. When input, a data entry may be in the form of a collection of bits within memory. Since the data entry, entered within the legacy processing environment, is in accordance with the legacy data structure, applications of the legacy processing environment may operate upon the bits, but applications of other processing environments may not be able to operate upon the data entry bits.
A data entry is in accordance with an industry-standard data structure when data of the data entry is expressed in terms associated with the industry-standard data structure. When in accordance with the industry-standard data structure, the data entry may be in the form of a document that includes a collection of data elements and descriptions, rather than a collection of bits. The descriptions may describe the data elements in terms associated with the industry-standard data structure. In this latter form, applications that are not of the legacy processing environment may operate upon the data entry.
A legacy language may be a language with which only a select subset of data processing environments can operate, e.g., a proprietary language. An industry-standard language may be a language with which most, if not all, data processing environments can operate. If a language is one with which a data processing environment can operate, then, e.g., an application of the environment can be manipulated by program instructions written in the language. If a data entry is input in accordance with a data structure defined by the language, then the application of the environment can operate upon the data entry.
A legacy data structure may be a data structure defined according to a legacy language. By contrast, an industry-standard data structure may be a data structure defined according to an industry-standard language. For example, an application that is not of a processing environment that operates using the ‘C’ language, often will not be able to operate upon a data entry input in accordance with a data structure defined in the ‘C’ language. However, a data entry that is input in accordance with, or that has been interpreted to be in accordance with a data structure defined in the Extensible Markup Language (XML) may be in a form upon which applications of most data processing environments can operate, since XML is an industry-standard language.
Consequently, in one example embodiment of the present invention, each time a legacy data structure is defined in the legacy language in 100, a corresponding extraction class may be generated, in 105, to convert a data entry input in accordance with the defined legacy data structure. To this end, the extraction utility may detect a new legacy data structure definition and generate an extraction class for the detected new legacy data structure.
In an example embodiment of the present invention, a particular legacy data structure may be subject to versioning. The extraction utility may detect the definition of the new version of the legacy data structure and may generate an extraction class to convert data entries to be in accordance with an industry-standard data structure that is representative of the new version of the legacy data structure. The extraction utility may replace an extraction class, generated to convert data entries input in accordance with the first version of the legacy data structure, with another extraction class, generated to convert data entries input in accordance with the second version of the legacy data structure.
According to this embodiment, in 225, the extraction utility may determine which data entry was input according to the first version of the legacy data structure and which data entry was input after the definition of and in accordance with the second version of the legacy data structure. In 230, the extraction utility may also determine which extraction class corresponds to the first version of the legacy data structure and which extraction class corresponds to the second version of the legacy data structure. Based on these determinations, in 235, the data entries may be converted, the first data entry by the first extraction class, and the new data entry by the second extraction class.
To determine by which version of a data extraction class a data entry is to be converted, a key may be associated with each extraction class and with each data entry. An example key may be a date, or more particularly a time. For example, a key associated with a version of an extraction class may be the time when the version of the legacy data structure to which the extraction class corresponds was defined. The key associated with a data entry may be the time when the data entry was input. If, for example, the time of the data entry is earlier than the time of the definition of a third version of the legacy data structure but later than the time of the definition of a second version of the legacy data structure, then an extraction class that corresponds to the second version of the legacy data structure may be used to convert the data entry to be in accordance with an industry-standard data structure.
In an example embodiment of the present invention, a legacy data structure, in accordance with which a data entry is input, may be partly defined and partly based on legacy data entry applications used for inputting the data entry. For example, using the ‘C’ language, a data structure may be defined. Additionally, a data entry application programmed in the ‘C’ language may be used for inputting data entries. The data entry application may format and store data elements of the data entries in a particular way. The reason the data entry application formats and/or stores the data elements in the particular way may be, for example, based on efficiency concerns. Data elements may be stored, for example in an order reverse of the order in which the data elements were input. In another example embodiment, the legacy data entry application may encode data of the data entries in nibbles, rather than in bytes. The extraction utility may generate extraction classes that convert data entries input in accordance with a legacy data structure, even when the legacy data structure is partly based on data manipulation by legacy data entry applications, aside from legacy data structure definitions.
For example, a legacy data structure definition may define a data structure with an integer data element and then a character array data element. A legacy data entry application may store a data entry so that the character array data element is stored in an anterior memory location and so that the integer data element is stored in a posterior memory location. The extraction class may properly convert the data entry to reflect that the anteriorly stored data element is the character array data element and that the posteriorly stored data element is the integer data element.
In an example embodiment of the present invention, data entries may include data that corresponds to some legacy data structures and may omit data that corresponds to other legacy data structures. For example, a legacy data structure may be defined for input of a set of numbers for a lottery ticket. A second legacy data structure may be defined for input of winnings information, e.g, a winnings amount, for the lottery ticket. However, not all lottery tickets are winnings tickets. Therefore, some data entries, e.g., where a data entry includes all data concerning a lottery game transaction, may omit data that corresponds to the defined winnings data structure.
A bitmap may be used to indicate which of the defined data structures are represented in a particular data entry. In an example embodiment of the present invention, the extraction class may decode bitmaps and convert data entries accordingly.
In an example embodiment of the present invention, the extraction class may be platform independent. Platforms may vary between various computers. For example, one computer may use a 32 bit architecture, in which the computer operates on a 32 bit word, while another computer may use a 16 bit architecture, in which the computer operates upon a 16 bit word. A definition of a data element of type “int” may allow for 16 bits of data if the data entry is input using the computer of 16 bit architecture, and 32 bits of data if the data entry is input using a computer of 32 bit architecture. Similarly, one computer may use a big-endian architecture, while another computer may use a little-endian architecture. The extraction utility may generate an extraction class that extracts and converts data entries, regardless of the computer architecture according to which the data entry was input.
In an example embodiment of the present invention a filtering mechanism may be provided that enables the selection of particular data elements of the extracted data entries to be converted. Depending on the particular jobs performed by a particular computer application, some data elements of a data entry may be relevant, while other data elements of the data entry may be irrelevant. In one example embodiment, in accordance with the filtering mechanism, the data extraction class may convert only the selected data elements. In an alternative embodiment, the extraction class may convert the entire data entry to be in accordance with the industry-standard data structure, but then output only relevant data elements to a computer application.
According to the latter embodiment, the extraction class may output data elements of a particular data entry to a number of computer applications. For each computer application, the relevant data elements may differ. Consequently, the data elements output by the extraction class to the various computer applications may differ between computer applications.
In one example embodiment, the filtering mechanism may be automatically implemented based on the particular computer application to which the converted data entry is to be outputted. In an alternative embodiment, the extraction utility may provide a user interface. The extraction utility may construct a list of data elements, e.g., one for each industry-standard data structure defined within the extraction utility. The extraction utility may provide the list to a user via the user interface. The list may be in any conventional form for providing lists. The user may select which of the listed data elements the extraction class is to convert (or output). For example, a user may click on a particular listed data element to indicate a selection of the data element. Alternatively, the user may enter in a text box a selected data element. Other conventional ways to select an item from a list may be used. The data extraction class may then be adapted to perform its tasks according to the selections.
In an example embodiment of the present invention, a filtering mechanism may be provided that enables the selection of particular data elements of data entries to be extracted by the data extraction class. According to this embodiment, a data store, e.g., a data buffer, may contain data, for example of many data entries input in a number of transactions. For particular computer applications, only some data entries may be relevant for the computer applications' jobs. The filtering mechanism may cause the data extraction class to extract only those portions of the data store that are relevant. The filtering mechanism may indicate to the data extraction class a set of criteria. The data extraction class may then check the data within the data store to determine whether a particular portion of the data is of a data entry that meets the criteria. If the portion of the data is of a data entry that meets the criteria, the data extraction class may extract and convert the portion of the data. Like the filtering mechanism discussed in the previous embodiments, this filtering mechanism may be automatically triggered according to the computer applications that are implemented, or, alternatively, may be triggered by user selections.
In an example embodiment of the present invention, a data entry input in accordance with a legacy data structure and converted to be in accordance with an industry-standard data structure, may include lottery game related data.
In alternative example embodiments of the present invention, a data entry input in accordance with a legacy data structure and converted to be in accordance with an industry-standard data structure, may include data of bill pay systems, pre-paid phone card systems, government licensing systems, e.g., systems of the department of motor vehicles, event ticket sales systems, and other transaction processing systems.
The generated extraction class may then be repeatedly used for all data entries input in accordance with the defined legacy data structure. To that end, in 435, the extraction class may wait for a data entry. In 440, after a data entry has been input, the extraction class may extract data of the data entry, e.g., from a data buffer. In 445, the extraction class may convert the extracted data entry to be in accordance with the defined industry-standard data structure. In 450, the extraction class may output the converted data entry for transmission. In 455, the converted data entry may be transmitted to data processing applications, for example by using a communications protocol, such as TCP/IP, or any conventional communications protocol.
In an example embodiment of the present invention, the extraction class may be a Java extraction class, written in the Java programming language. The Java extraction class may call external Java routines to perform its tasks. For example, the Java extraction class may include two subroutines, one for retrieving into Java classes data entries from, for example data buffers, and another for converting the retrieved data so that it is in accordance with the defined industry-standard data structure.
The Java extraction class may use Java Document Object Models (JDOM) to convert data to be in accordance with the industry-standard data structure, e.g., an XML data structure.
In an example embodiment of the present invention, the extraction class may use particular Java subroutines to convert some data elements of a data entry but not other data elements of the data entry. For example, the ‘C’ language supports an unsigned integer data type. Java supports only signed data types. If an integer is signed, then the left-most bit, for example, may indicate the sign of the number. If an integer is unsigned, so that all values are, for example, positive, then the left-most bit is part of the number. For example, if an integer is made up of 8 bits and is unsigned, then the 8 bits can represent 256 possible values, in the range of 0 to 255. If the 8 bit integer is signed, then the 8 bits can only represent 128 possible values, in the range of 0 to 127. Consequently, a Java integer may not be able to represent any value of the unsigned integer type that is in the range of 128 to 255. If the ‘C’ language defined data structure includes a data element that is an unsigned integer type, the extraction class may call a Java routine to assign a Java data type that can handle values of an unsigned integer. For example, the called Java routine may assign to the data element a Long data type.
According to an example embodiment of the invention, the extraction class may further include in the resulting XML the relationship among data elements of a data entry. For example, a structure called “CUSTOMER” may be defined. This structure may be defined, for example, to include an integer called Myint. The structure may further include another defined structure called “ADDRESS.” In ADDRESS may be defined another integer called Myint. The extraction utility may include XML tags, for example, that identify a particular data element's place in the hierarchy of the data structure. For example, the data may be converted to:
In this way, programs to which the converted data entries are output may generate relational databases based upon the data entries received from the extraction class.
For example, a first structure may be defined to include a number of data elements, including an integer called “Myint”; a number of instances of a second structure; and a single instance of a third structure. The second and third structures may each also include an integer called “Myint.” A relational database may be generated to include a table for the first structure, listing the first structure's data elements; and a table for the second structure, listing the second structure's elements. Since only one instance of the third structure is defined, a table may not be generated for the third structure. Rather, the third structure may be listed only as an element of the first structure. For each structure may be listed the integer “Myint.” Without a tag that identifies the Myint hierarchy, the structure to which a particular Myint belongs is not known when stored in a database. With the additional hierarchy information, each Myint may be tied to its structure when stored within a relational database. A table for the first structure would then have, for example, “first_structure_Myint,” “second_structure_Myint,” etc.; rather than “Myint” and “Myint.”
Data entry application 1020 may be used to receive input of data entries, e.g., from a user. The data entries may be stored in data buffer 1025. Extraction class 1015 may extract, for example in response to a request or at set times, the data entries, convert the data entries to be in accordance with the industry-standard data structure, and output the converted data entries. The outputted data entries may be transmitted towards data processing application 1030. Data processing application 1030 may then operate upon, manipulate, and/or use the data entries.
Those skilled in the art can appreciate from the foregoing description that the present invention can be implemented in a variety of forms. Therefore, while the embodiments of this invention have been described in connection with particular examples thereof, the true scope of the embodiments of the invention should not be so limited since other modifications will become apparent to the skilled practitioner upon a study of the drawings, specification, and following claims.