Browse Prior Art Database

Dynamic Generation of Rules from Properties to Improve Rule Processing Performance Disclosure Number: IPCOM000014005D
Original Publication Date: 2000-Jan-01
Included in the Prior Art Database: 2003-Jun-19

Publishing Venue



Rules can be used to provide a powerful, dynamic mechanism to provide configurability to a system without requiring users or administrators to resort to programming in some programming language. Using a rules syntax based on some easily understandable IF-THEN syntax, it is feasible for non-programmers to add significant configurability to a system. However, users and administrators are most used to making configuration changes by using "settings" of some type. Essentially these are properties, or some sort of key/value pairs. We would like to combine these two approaches to allow the use of properties where possible, and the use of rules where additional power and flexibility are needed. Hopefully then, with a small set of rules and a large set of settings or preferences, we can achieve the configurability we desire. The invention described herein would be useful to any system that uses rules to make decisions based on properties whose values are acquired from external sources, such as files or Web servers. At system start time, new rules are created representing property values read in from the external sources. The new rules encapsulate the identity and value of the properties. These rules are added to the collection of rules dynamically. Alternatively, new rules could be generated when properties are first accessed. The value of this invention is that it removes the need to continually access external sources for properties and it dynamically eliminates rules that always evaluate to "false". Thus, the rules engine's collection of rules is dynamically modified to match the set of properties. This results in a substantially more efficient rules evalution process. Let's assume that we use properties or preferences to alter some aspect of our system. However, under one situation we want to get one set of values, while in another situation we want to use a different set of values for some or all of the same properties. For example, if we are dealing with a network attached system, if information is being sent to low bandwidth links we may want to use a set of values to that cause us to minimize the amount of data sent, while for a high bandwidth link we might use other values because we have no need to limit data at all. We would like users of the system to be able to define the values as two different sets of properties (key/value pairs) and use rules to help determine which set to use. Additionally, however we would like our rules to be somewhat efficient in that they do not unnessarily check for every possible permutation. That is, given that there is no value for a given property specifiied for the low bandwidth case, we would like it if we did not check the low bandwidth source for the value when we try to resolve the value of that property. We'll assume that we have rules that determine which source of properties to look at first for values. For example, we may have rules that specify an ordering relation which specify first to look in one source (the set of properties for one situation above), and then another, and so on. We might define a different ordering relation depending on what value was being asked for. The question then becomes how to combine the collection of rules which tell from which source to take particular property values and the sources that contain property values themselves. We would like to attempt to access the source for the property if that property actually exists in that source. If the properties do not change while the system is running, it would be better if we could just make the property value itself available