Mutable general ledger account structure

Abstract

A computer program product and method for representing a general ledger account. The data structure includes an account type table, an account table, a segment type table, a segment table, and an association table. The account type table includes account type identification and an associated account type name. The account table includes account identification and an associated account type identification from the account type table. The segment type table includes one or more segment type identification and an associated segment type name, display position, status, length, and account type identification from the account type table. The segment table includes one or more segment identification and an associated segment value and segment type identification from the segment type table. The association table includes an association between the segment identification from the segment table and account identification from the account table.

Description

PRIORITY CLAIM

[0001] This application claims priority from Provisional Application Ser. Nos. 60/375,192 (Our Ref: FXAG.1.1001) and 60/375,202 (Our Ref: FXAG.1.1002) both of which were filed Apr. 22, 2002, and are hereby incorporated by reference.

FIELD OF THE INVENTION

[0002] This invention relates generally to general ledger software systems.

BACKGROUND OF INVENTION

[0003] A significant business problem exists for defining charts of accounts for business, government, and non-profit organizations. For conventional accounting information systems, the general ledger account structure must be chosen and fixed before the chart of accounts can be populated. (The account structure consists of a string of primarily numeric characters which is subdivided into segments. Each segment has a fixed starting position and a fixed length.) After financial transactions have been created, the structure of the general ledger account for these transactions cannot be changed.

[0004] This inability to change account structure is a particularly challenging problem for rapidly growing organizations whose business needs are changing. Currently, the only solution is to redefine the chart of accounts periodically to provide the additional required information content to the management of the organization. This either (1) creates a discontinuity between fiscal years for comparative purposes, or (2) requires a significant one-time software engineering effort to convert data from the old general ledger account structure to the new structure. Such conversions create major concerns for data integrity, system availability, and system reliability.

[0005] In case (2) above, data conversion is often beyond the means of a rapidly growing business because software development resources are scarce and expensive. Also, significant business risk is involved because the data conversion might not be 100% successful. Finally, software development resources are often needed to support the direct line of business.

[0006] The typical financial application handles only data. As far as the application is concerned, the structure is hard coded at compile time, the application is programmed about the hard coded structure, and then at run time the structure can be populated, but cannot be changed without tearing into the application programming.

[0007] Most chart of account systems rely on a fixed number of segments and often a fixed field length for each segment. The example described below is one of the more elegant versions of the current architecture. They allow the user to create variable number of segments of variable length. However, they require that the defined structure be “frozen” and thus becomes “fixed” once it has been defined. While the user may make changes to the structure, it cannot be done on-the-fly, nor can it be done without significant complications. Again, with our system, it can be changed on-the-fly and existing data remains consistent with the new structure.

[0008] The following text is from the Oracle Financials Handbook:

[0009] “It is also difficult to change your Accounting Flexfield after it has been frozen and has been used to capture data through transaction processing. Changing your structures after-the-fact may create data inconsistencies that could impact the behavior of your application or require a complex conversion program. As soon as you are satisfied, freeze your Accounting Flexfield structure to prohibit unnecessary modifications. You must freeze and compile your flexfield definition before you use your flexfield.”

[0010] The following illustrates an example of the above identified problem. FIGS. 1A-E illustrate a conventional model. Four tables represent a basic conventional model. The GLAccountType table is metadata that represents all segment types of each chart of accounts. The relative position of each segment type in a table defines the chart of accounts format. The GLSegmentType table, which represents metadata, constrains each segment type. The GLSegmentType table defines the name and each segment type length. The GLAccount table is data that represents each entry in the chart of accounts. The value of each segment occurs in the defined relative position for each segment type. The GLSegment table constrains each segment value, which is the data value of each segment. The database cannot enforce the constraints and therefore the application must enforce them.

[0011] Therefore, there exists a need for easily adaptable general ledger accounting software where adaptability is not performed through complex changes in the application program.

SUMMARY

[0012] The present invention provides a computer program product that includes a data structure for representing a general ledger account. The data structure includes an account type table, an account table, a segment type table, a segment table, and an association table. The account type table includes one or more account type identification and an associated account type name, wherein one of the account type names is primary account. The account table includes one or more account identification and an associated account type identification from the account type table. The segment type table includes one or more segment type identification and an associated segment type name, display position, status, length, and account type identification from the account type table. The segment table includes one or more segment identification and an associated segment value and segment type identification from the segment type table. The association table includes an association between the segment identification from the segment table and account identification from the account table.

[0013] In accordance with another embodiment of the present invention, the computer program product includes a graphical user interface (GUI). The GUI allows for entering an account type into the data structure, for entering a segment into the data structure, and for changing display positions in the segment type table. The graphical user interface component further allows for deactivating a segment, changing the size of a segment, and changing the segment value in the segment table.

[0014] BRIEF DESCRIPTION OF THE DRAWINGS

[0015] The preferred and alternative embodiments of the present invention are described in detail below with reference to the following drawings.

[0016] FIG. 1A-E are pictorial representations of a prior art database model for a general ledger account structure;

[0017] FIG. 2 is a pictorial representation of a structural database model for a general ledger account structure formed in accordance with the present invention;

[0018] FIGS. 3-7 are tables that represent the structural database model shown in FIG. 2;

[0019] FIGS. 8-11, 13, 14, 18, 20, 21, and 23 are example graphical user interfaces formed in accordance with the present invention for interacting with the database model; and

[0020] FIGS. 12, 15-17, 19, and 22 are tables that illustrate the actions performed in the graphical user interfaces.

DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENT

[0021] As shown in FIG. 2, the present invention is a database model 40 for a general ledger account. In the model 40, a GLAccount is comprised of an arbitrary number of GLSegments. GLSegmentType describes each GLSegment. Each GLSegmentType and GLAccount has a GLAccountType.

[0022] GLAccountType indicates how an account is used, e.g., recording transactions for actual events, budgeting, or consolidation.

[0023] GLSegmentType defines each segment of the multipartite GL account, e.g., company, department, and account.

[0024] GLSegment stores the segment number and title, e.g., “4420.10 Salary Expense.”

[0025] GLAccount and the many-to-many relationship between GLAccount and GLSegment assemble the segment numbers and titles into a single complete GL account.

[0026] A common occurrence in Chart of Accounts reorganizations is the addition of a new account segment. This example shows the contents of the tables shown in FIG. 2 before and after addition of a segment. The account in the “before” case consists of a company and an account segment. In the “after” case, it consists of company, department, and account. This simple example demonstrates that none of the extant data in the tables GLAccount, GLSegment, and GLAccountSegment is altered for this reorganization. Only the metadata in GLSegmentType is changed.

[0027] “Before” Case: Company-Account 1 GLAccountType ID Name AT1 Actuals AT2 Budget GLSegmentType Display ID Name Position Status MaxLength GLAccountType ST1 Company 1 Active 3 AT1 ST2 Account 2 Active 6 AT1 GLSegment ID Value GLSegmentType S1 100 ST1 S2 442001 ST2 GLAccount ID GLAccountType A1 AT1 GLAccountSegment GLAccount GLSegment A1 S1 A1 S2 “After” Case: Company-Department-Account Changes are underlined and italicized. GLAccountType ID Name AT1 Actuals AT2 Budget

GLSegmentType

[0028] Note that the second row in this table is the only change to a record that exists in the “Before” case; and that this table contains metadata, not the fundamental transactional data of an enterprise. 2 Display- Max- ID Name Position Status Length GLAccountType ST1 Company 1 Active 3 AT1 ST2 Account 3 Active 6 AT1 ST3 Department 2 Active 2 AT1 GLSegment ID Value GLSegmentType S1 100 ST1 S2 442001 ST2 S3 70 ST3 GLAccount ID GLAccountType A1 AT1 GLAccountSegment GLAccount GLSegment A1 S1 A1 S2 A1 S3

[0029] As shown in FIGS. 3-7, five tables (stored in memory) represent the database 15 model 40. As shown in FIG. 3, a GLAccountType table 60 includes metadata that represents each chart of accounts. The GLAccountType table 60 includes a glAccountTypeID column and a glAccountType/Name column. One of the items in the glAccountType ID column is identified as a primary chart of accounts. Any number of alternate charts of accounts are also present in the GLAccountType table 60.

[0030] As shown in FIG. 4, a GLAccount table 70 is data that represents the chart of accounts. The GLAccount table 70 includes a glAccountID column and a glAccountTypeID column.

[0031] As shown in FIG. 5, a GLSegmentType table 80 is metadata that represents each segment type of a chart of accounts. The GLSegmentType table 80 includes a glSegmentType ID column, a glSegmentTypeName column, a displayPosition column, a status column, a maxLength column, and a glAccountTypeID column. There could be any number of segment types in the GLSegmentType table 80, such as company, department, project, program, product, etc. Each chart of accounts represents segments in any order. Each chart can have different segment types. The GLSegmentType table 80 allows the user to change the number, order, and length of segment types that make up each chart of accounts. The GLSegmentType table 80 also allows a segment to be active or inactive.

[0032] As shown in FIG. 6, a GLSegment table 90 includes the value of each segment. The GLSegment table 90 includes a gISegmentID column, a glSegrnentValue column, and a glSegmentTypeID column.

[0033] As shown in FIG. 7, a GLAccount_GLSegment association table 100 represents the relationship between the GLAccount table 70 and the GLSegment table 90. The GLAccount_GLSegment table 100 includes a glAccountID column and a glSegmentID column.

[0034] FIGS. 8-11, 13, 14, 18, 20, 21, and 23 illustrate exemplary Graphical User Interfaces (GUIs) and various database structural functions that can be performed using the GUIs. As shown in FIG. 8, the GUI is a window 200 that includes the following alterable fields: General Ledger Account Type field 208; Segment Type field 210; Display Position field 212; and Maximum Length field 214. The entries in the fields corresponds to storage locations in one or more of the above described tables. The window 200 also includes Active/Inactive status selection fields 220, and Save, Cancel, and Edit buttons. The General Ledger Account Type field 208 and the Segment Type field 210 are pull-down menus that allow the user to select from predefined lists of associated entries or create new entries.

[0035] Changing the Order of Segments:

[0036] In one example, a company (user) has set up an order (display order) of chart of account segments as follows:

[0037] Company: Account: Department: Project

[0038] The user decides that the following order would make it easier to report on the chart using a new generic report writer:

[0039] Company: Department: Account: Project

[0040] In order accomplish this change, the user simply changes the relative display position values in the Display Position fields 212 in the Account segment Type window 200 and a Department segment Type window 240 (FIG. 9). The Display Position field 212 of the Account segment type window 200 is changed from 2 to 3 (FIGS. 8, 10) and the Display Position field 212 of the Department segment type window 240 is changed from 3 to 2 (FIGS. 9, 11). As shown in FIG. 12, the change that occurred in FIGS. 10 and 11 is illustrated in the GLSegmentType table 80.

[0041] Add a New Segment (Record):

[0042] In one embodiment, a company has grown and decided to add a product segment to the chart of accounts in order to track detail by product. The user adds a new record to the General Ledger Segment Type table called “Product” using the GUI window 200. The order of the chart of accounts now becomes:

[0043] Company: Department: Account: Project: Product

[0044] FIG. 13 illustrates a GUI window 280 before the addition of a new record. FIG. 14 illustrates the GUI window 290 after the addition of a record of a Segment Type Product with Display Position equal to 5. The Active status is marked and an arbitrary Maximum Length value is inserted. As shown in FIGS. 15-17, new records are entered into the bottom rows of the GLSegmentType table 80, the GLSegment table 90 and the GLAccountGLSegment association table 100.

[0045] Remove a Segment Type:

[0046] In another embodiment, the company decides the use of the product segment has become too cumbersome and wants to suspend use. The user marks the product segment type as inactive using Active/Inactive status selection fields 220 (See FIG. 18). The status field is changed in the GLSegment table 80 as shown in FIG. 19. The order of the chart of accounts now is as follows:

[0047] Company: Account: Department: Project

[0048] Change the Size of a Segment Field

[0049] The company realizes that their department identifier length is too short (Maximum Length field 214) and they need to expand the field and change all the department codes. As shown in FIGS. 20 and 21, the user changes the maximum length value in the Maximum Length field 214. The change in length is reflected in the GLSegment table 80, as shown in FIG. 22.

[0050] Change the Value of a Segment

[0051] The company decides to reorganize the order of departments and wants to change the department numbers throughout the organization. As shown in FIG. 23, a General Ledger Segments window 360 allows a user to change the segment value of affected segments in a Segment Value field 370. The General Ledger Segments window 360 also includes a General Ledger Account Type pull-down field 372, a Segment Type pull-down field 374, a Segment Description field 380, and Status field section 390 that allows selection of Active, Inactive, or Report. The window 360 also includes Save, Cancel, and Exit buttons. The changes performed in the window 360 are reflected in one or more of the corresponding tables.

[0052] While the preferred embodiment of the invention has been illustrated and described, as noted above, many changes can be made without departing from the spirit and scope of the invention. Accordingly, the scope of the invention is not limited by the disclosure of the preferred embodiment. By way of example and not limitation, in one alternate embodiment, this invention can be used in conjunction with the invention described in our co-pending application entitled FOOD TRACING AND TRACKING SYSTEM AND METHOD (Serial number not yet assigned) filed on Apr. 22, 2003, and which is hereby incorporated by reference.

Claims

1. A computer program product comprising a data structure for representing a general ledger account, the data structure comprising:

an account type table including one or more account type identification;

an account table including one or more account identification and an associated account type identification from the account type table;

a segment type table including one or more segment type identification and account type identification from the account type table;

a segment table including one or more segment identification and segment type identification from the segment type table; and

an association table including an association between the segment identification from the segment table and account identification from the account table.

2. The computer program product of claim 1, further comprising:

a graphical user interface component comprising:

a first component for entering a segment into the data structure; and

a second component for changing display positions in the segment type table.

3. The computer program product of claim 2, wherein the first component includes one or more of the following fields: an account type field, a segment type field, a display position field, one or more length fields; and a status selection component.

4. The computer program product of claim 2, wherein the graphical user interface component further comprises a third component for deactivating a segment.

5. The computer program product of claim 2, wherein the graphical user interface component further comprises a third component for changing the size of a segment.

6. The computer program product of claim 2, wherein the graphical user interface component further comprises a third component for changing the segment value in the segment table.

7. A method for representing a general ledger account, the method comprising:

storing an account type table including one or more account type identification;

storing an account table including one or more account identification and an associated account type identification from the account type table;

storing a segment type table including one or more segment type identification and account type identification from the account type table;

storing a segment table including one or more segment identification and segment type identification from the segment type table; and

storing an association table including an association between the segment identification from the segment table and account identification from the account table.

8. The method of claim 7, further comprising:

entering a segment into the data structure using a graphical user interface; and

changing display positions in the segment type table using the graphical user interface.

9. The method of claim 8, wherein the graphical user interface includes an account type field, a segment type field, a display position field, one or more length fields, and a status selection component.

10. The method of claim 8, further comprising deactivating a segment using the graphical user interface.

11. The method of claim 8, further comprising changing the size of a segment using the graphical user interface.

12. The method of claim 8, further comprising changing the segment value in the segment table using the graphical user interface.