An active database system automatically triggers rules in response to certain events occuring. Events are issued by transactions or action parts of rules. Repeated executions of rules can be caused by the structure of the initial triggering transaction program and by the structure and execution semantics of rules. Repeated calculations of rules may incur costly redundant computations in rule conditions or actions. The central contribution of this paper is to propose technics for analyzing the behaviour of a transaction and a set of rules triggered by this transaction in order to derive: (i) if a given rule is processed more than once, and (ii) a fine indication of the database changes that may occur between two consecutive executions of the rule. Knowing these changes, it is possible to use existing algorithms that compute useful intermediate expressions in a rule that can be cached and incrementally maintained in order to avoid redundant computations. A notable property of our analysis technics is that they are parametrized by a few essential semantics parameters that define the execution semantics of an active rule language. Thus, our analysis apply to a large class of existing active rule systems.