head	1.31;
access;
symbols
	Version_2_1:1.19
	Version_2:1.10;
locks; strict;
comment	@ * @;


1.31
date	92.03.11.02.20.18;	author mer;	state Exp;
branches;
next	1.30;

1.30
date	91.12.15.00.18.12;	author dpassage;	state Exp;
branches;
next	1.29;

1.29
date	91.12.07.17.18.25;	author dpassage;	state Exp;
branches;
next	1.28;

1.28
date	91.12.04.01.58.45;	author glass;	state Exp;
branches;
next	1.27;

1.27
date	91.11.18.22.23.29;	author mer;	state Exp;
branches;
next	1.26;

1.26
date	91.11.12.23.30.14;	author mer;	state Exp;
branches;
next	1.25;

1.25
date	91.11.11.23.06.06;	author hong;	state Exp;
branches;
next	1.24;

1.24
date	91.10.01.16.27.36;	author glass;	state Exp;
branches;
next	1.23;

1.23
date	91.04.23.14.54.53;	author sp;	state Exp;
branches;
next	1.22;

1.22
date	91.04.11.21.29.47;	author sp;	state Exp;
branches;
next	1.21;

1.21
date	91.04.10.16.06.37;	author sp;	state Exp;
branches;
next	1.20;

1.20
date	91.04.08.18.12.50;	author sp;	state Exp;
branches;
next	1.19;

1.19
date	91.02.25.16.52.12;	author sp;	state Exp;
branches;
next	1.18;

1.18
date	91.02.24.19.57.10;	author sp;	state Exp;
branches;
next	1.17;

1.17
date	91.02.24.12.34.43;	author sp;	state Exp;
branches;
next	1.16;

1.16
date	91.02.08.17.37.12;	author sp;	state Exp;
branches;
next	1.15;

1.15
date	91.01.09.18.58.47;	author sp;	state Exp;
branches;
next	1.14;

1.14
date	90.10.16.17.15.28;	author sp;	state Exp;
branches;
next	1.13;

1.13
date	90.08.19.15.29.13;	author sp;	state Exp;
branches;
next	1.12;

1.12
date	90.08.18.00.40.35;	author cimarron;	state Exp;
branches;
next	1.11;

1.11
date	90.08.17.08.53.01;	author cimarron;	state Exp;
branches;
next	1.10;

1.10
date	90.07.18.18.41.04;	author sp;	state Version_2;
branches;
next	1.9;

1.9
date	90.07.17.20.33.27;	author sp;	state Exp;
branches;
next	1.8;

1.8
date	90.05.21.15.14.40;	author sp;	state Exp;
branches;
next	1.7;

1.7
date	90.05.14.20.30.18;	author sp;	state Exp;
branches;
next	1.6;

1.6
date	90.05.10.16.20.34;	author sp;	state Exp;
branches;
next	1.5;

1.5
date	90.04.19.19.41.26;	author sp;	state Exp;
branches;
next	1.4;

1.4
date	90.04.03.17.02.27;	author sp;	state Exp;
branches;
next	1.3;

1.3
date	90.03.07.17.14.17;	author sp;	state Exp;
branches;
next	1.2;

1.2
date	90.01.30.23.20.24;	author sp;	state Exp;
branches;
next	1.1;

1.1
date	90.01.11.14.46.05;	author sp;	state Exp;
branches;
next	;


desc
@All the PRS2 definitions/declarations you need to know about..
@


1.31
log
@turn of debug output
@
text
@/*
 * FILE:
 *   prs2.h
 *
 * IDENTIFICATION:
 *   $Header: /users/mer/pg/src/lib/H/rules/RCS/prs2.h,v 1.30 1991/12/15 00:18:12 dpassage Exp mer $
 *
 * DESCRIPTION:
 *   All you need to include if you are a PRS2 person!
 */

/*
 * Include this file only once...
 */
#ifndef Prs2Included
#define Prs2Included

#include "tmp/postgres.h"

#include "access/heapam.h"
#include "access/tupdesc.h"
#include "nodes/pg_lisp.h"
#include "storage/buf.h"
#include "utils/rel.h"

#include "rules/params.h"

/*------------------------------------------------------------------
 * Include PRS2 lock definition
 * These defs were put in a separate file because they are included
 * bit "htup.h" and that created a circular dependency...
 */
#include "rules/prs2locks.h"

/*------------------------------------------------------------------
 * Comment out the following line to supress debugging output
 * #define PRS2_DEBUG 1
 */

/*==================================================================
 * --Prs2RuleData--
 *
 * This is the structure where we keep all the information
 * needed to define a rule.
 *
 * ruleText:
 *     the text of the rule (i.e. a string)
 * ruleName:
 *     the name of the rule
 * ruleId:
 *     the oid of the rule.
 *     NOTE: we do NOT know it until we add the rule in the system
 *     catalogs!
 * isInstead:
 *     is this an "instead" rule ??
 * eventType:
 *     the event type that triggers the rule
 * actionType:
 *     the type of the action that will be executed if the rule istriggered.
 * eventRelationOid:
 * eventRelationName:
 *     oid & name of the relation referenced in the "event" clause of the rule.
 * eventAttributeNumber:
 * eventAttributeName:
 *     the number & name of the attribute referenced in the "event" clause
 *     of the rule. If no such attribute exists (i.e. "on retrieve to EMP" -
 *     a view rule) then this is an InvalidAttributeNumber & NULL
 *     respectively.
 * updatedAttributeNumber:
 *     The attribute no of the attribute that is updated from the rule.
 *     For instance "on retrieve ... then do replace CURRENT(attr = ...)"
 *     or "on retrieve to ... then do retrieve (attr = ....)"
 * parseTree:
 *     the parse tree for the rule definition.
 * ruleQual:
 *     the qualification of the rule
 * ruleAction:
 *     a list of all the actions.
 * paramParseTree:
 * paramRuleQual:
 * paramRuleAction:
 *     same as the parseTree, ruleQual & ruleAction but with all the
 *     Var nodes that reference the CURRENT and/or NEW relations changed
 *     into the appropriate Param nodes...
 * 
 */
typedef struct Prs2RuleDataData {
    ObjectId		ruleId;
    char		*ruleText;
    Name		ruleName;
    bool		isInstead;
    EventType		eventType;
    ActionType		actionType;
    ObjectId		eventRelationOid;
    Name		eventRelationName;
    AttributeNumber	eventAttributeNumber;
    Name		eventAttributeName;
    AttributeNumber	updatedAttributeNumber;
    List		parseTree;
    List		ruleQual;
    List		ruleAction;
    List		paramParseTree;
    List		paramRuleQual;
    List		paramRuleAction;
} Prs2RuleDataData;

typedef Prs2RuleDataData *Prs2RuleData;

/*==================================================================
 * PRS2 MAIN ROUTINES
 *
 * These are almost all the routines a non Prs2 person wants to know
 * about!
 *==================================================================
 */


/*------------------------------------------------------------------
 * return true if the executor must call the rule manager, or
 * false if there is no need to do so (no rules defined).
 */
extern
bool
prs2MustCallRuleManager();/* BAD PROTOTYPE DELETED -- glass */
/*    ARGS((
    RelationInfo	relationInfo,
    HeapTuple           oldTuple,
    Buffer              oldBuffer,
    int			operation
));*/

/*------------------------------------------------------------------
 * prs2Main
 * The rule manager itself! Normally this should only be called
 * from within the executor...
 */

typedef int Prs2Status;

#define PRS2_STATUS_TUPLE_UNCHANGED	1
#define PRS2_STATUS_TUPLE_CHANGED	2
#define PRS2_STATUS_INSTEAD	3

extern
Prs2Status
prs2Main(); /* BAD PROTOTYPE DELETED -- glass */
/*ARGS((
    EState		estate,
    RelationInfo	scanRelInfo,
    int                 operation,
    int                 userId,
    Relation            relation,
    HeapTuple           oldTuple,
    Buffer              oldBuffer,
    HeapTuple           newTuple,
    Buffer              newBuffer,
    HeapTuple           rawTuple,
    Buffer              rawBuffer,
    AttributeNumberPtr  attributeArray,
    int                 numberOfAttributes,
    HeapTuple           *returnedTupleP,
    Buffer              *returnedBufferP
));
*/
/*==================================================================
 * PRS2 LOCKS
 *==================================================================
 */

/*------------------------------------------------------------------
 * prs2FreeLocks
 *    free the space occupied by a rule lock
 */
extern
void
prs2FreeLocks ARGS((
    RuleLock lock
));

/*------------------------------------------------------------------
 * prs2MakeLocks
 *    return a pointer to a 'Prs2LocksData' structure containing
 *    no locks, i.e. numberOfLocks = 0;
 */
extern
RuleLock
prs2MakeLocks ARGS((
));

/*------------------------------------------------------------------
 * prs2AddLock
 *    Add a new lock (filled in with the given data) to a 'prs2Locks'
 *    Note that this frees the space occupied by 'prs2Locks' and reallocates
 *    some other. So this routine should be used with caution!
 */
extern
RuleLock
prs2AddLock ARGS((
    RuleLock		oldLocks,
    ObjectId		ruleId,
    Prs2LockType	lockType,
    AttributeNumber	attributeNumber,
    Prs2PlanNumber	planNumber,
    int			partialindx,
    int		 	npartial
));

/*------------------------------------------------------------------
 * prs2GetOneLockFromLocks
 *    Given a 'RuleLock' return a pointer to its Nth lock..
 *    (the first locks is lock number 0).
 */
extern
Prs2OneLock
prs2GetOneLockFromLocks ARGS((
    RuleLock	locks,
    int		n
));

/*------------------------------------------------------------------
 * prs2OneLocksAreTheSame
 * return true iff the two 'Prs2OneLock' are the same...
 */
extern
bool
prs2OneLocksAreTheSame ARGS((
    Prs2OneLock	oneLock1,
    Prs2OneLock	oneLock2
));

/*------------------------------------------------------------------
 * prs2OneLockIsMemberOfLocks
 * return true iff the given `Prs2OneLock' is one of the locks of
 * `locks'
 */
extern
bool
prs2OneLockIsMemberOfLocks ARGS((
    Prs2OneLock	oneLock,
    RuleLock	locks
));

/*------------------------------------------------------------------
 * prs2GetLocksFromTuple
 *  Extract the locks from a tuple. It returns a 'RuleLock',
 *  (NOTE:it will never return NULL! Even if the tuple has no
 *  locks in it, it will return a 'RuleLock' with 'numberOfLocks'
 *  equal to 0.
 *  The returned rule lock is a copy, and must be pfreed to avoid memory leaks.
 */
extern
RuleLock
prs2GetLocksFromTuple ARGS((
    HeapTuple		tuple,
    Buffer		buffer
));

/*------------------------------------------------------------------
 * prs2PutLocksInTuple
 *    given a tuple, update its rule lock.
 *    NOTE: the old rule lock is pfreed!
 */
extern
void
prs2PutLocksInTuple ARGS((
    HeapTuple	tuple,
    Buffer	buffer,
    Relation	relation,
    RuleLock	newLocks
));

/*------------------------------------------------------------------
 * prs2PrintLocks
 *    print the prs2 locks in stdout. Used for debugging...
 */
extern
void
prs2PrintLocks ARGS((
    RuleLock	locks
));

/*------------------------------------------------------------------
 * prs2RemoveOneLockInPlace
 *
 * remove a rule lock in place (i.e. no copies)
 */
extern
void
prs2RemoveOneLockInPlace ARGS((
    RuleLock	locks,
    int		n
));

/*------------------------------------------------------------------
 * prs2RemoveAllLocksOfRuleInPlace
 *
 * remove all locks of a given rule in place (i.e. no copies)
 * returns true if the lcoks have changed, false otherwise (i.e.
 * if no locks for this rule were found).
 */
extern
bool
prs2RemoveAllLocksOfRuleInPlace ARGS((
    RuleLock	locks,
    ObjectId	ruleId
));

/*------------------------------------------------------------------
 * prs2RemoveAllLocksOfRule
 *    remove all the locks that have a ruleId equal to the given.
 *    the old `RuleLock' is destroyed and should never be
 *    referenced again.
 *    The new lock is returned.
 */
extern
RuleLock
prs2RemoveAllLocksOfRule ARGS((
    RuleLock	oldLocks,
    ObjectId	ruleId
));

/*------------------------------------------------------------------
 * prs2CopyLocks
 *    Make a copy of a prs2 lock..
 */
extern
RuleLock
prs2CopyLocks ARGS((
    RuleLock	locks
));

/*------------------------------------------------------------------
 * prs2GetLocksFromRelation
 *   Get locks from the RelationRelation
 */
extern
RuleLock
prs2GetLocksFromRelation ARGS((
    Name relationName
));

/*------------------------------------------------------------------
 * prs2LockUnion
 *   Create the union of two RuleLock.
 */
extern
RuleLock
prs2LockUnion ARGS((
    RuleLock	lock1,
    RuleLock	lock2
));

/*------------------------------------------------------------------
 * prs2LockDifference
 *   Create the difference of two RuleLock.
 */
extern
RuleLock
prs2LockDifference ARGS((
    RuleLock	lock1,
    RuleLock	lock2
));

/*------------------------------------------------------------------
 * prs2FindLocksOfType
 *	return a copy of all the locks of a given type.
 */
extern
RuleLock
prs2FindLocksOfType ARGS((
    RuleLock		locks,
    Prs2LockType	locktype
));

/*------------------------------------------------------------------
 * prs2RemoveLocksOfTypeInPlace
 * remove all the lcoks of the given type in place (i.e. No copies)
 */
extern
void
prs2RemoveLocksOfTypeInPlace ARGS((
    	RuleLock	locks,
	Prs2LockType	lockType
));

/*------------------------------------------------------------------
 * RuleLockToString
 *   greate a string containing a representation of the given
 *   lock, more suitable for the human brain & eyes than a
 *   sequence of bytes.
 */
extern
char *
RuleLockToString ARGS((
    RuleLock	lock
));

/*------------------------------------------------------------------
 * StringToRuleLock
 *   the opposite of 'RuleLockToString()'
 */
extern
RuleLock
StringToRuleLock ARGS((
    char 	*string
));

/*==================================================================
 * Routine to extract rule info from the ParseTree
 *==================================================================
 */
#define GetRuleHintFromParse(p)		(CADR(nth(1,p)))
#define GetRuleNameFromParse(p)		(nth(2,p))
#define GetRuleEventTypeFromParse(p)	(nth(0,nth(3,p)))
#define GetRuleEventTargetFromParse(p)	(nth(1,nth(3,p)))
#define GetRuleQualFromParse(p)		(nth(2,nth(3,p)))
#define GetRuleInsteadFromParse(p)	(nth(3,nth(3,p)))
#define GetRuleActionFromParse(p)	(nth(4,nth(3,p)))
#define GetRuleRangeTableFromParse(p)	(nth(4,p))

/*------------------------------------------------------------------
 * Various routines...
 *------------------------------------------------------------------
 */

/*====================== FILE: prs2define.c ============================*/
/*------------------------------------------------------------------
 * prs2DefineTupleRule
 *    Define a PRS2 rule (tuple level proccessing)
 */
extern
void
prs2DefineTupleRule ARGS((
    LispValue	parseTree,
    char	*ruleText
));

/*------------------------------------------------------------------
 * prs2RemoveTupleRule
 *    Remove a prs2 rule given its name.
 */
extern
void
prs2RemoveTupleRule ARGS((
    Name	ruleName
));

extern Prs2RuleData prs2FindRuleData();
extern ObjectId prs2InsertRuleInfoInCatalog();
extern void prs2DeleteRuleInfoFromCatalog();
extern void prs2InsertRulePlanInCatalog();
extern void prs2DeleteRulePlanFromCatalog();
extern LispValue prs2GenerateActionPlans();
extern EventType prs2FindEventTypeFromParse();
extern ActionType prs2FindActionTypeFromParse();
extern void changeReplaceToRetrieve();
extern bool prs2AttributeIsOfBasicType();

/*====================== FILE: prs2putlocks.c ============================*/

/*------------------------
 * prs2AddTheNewRule
 * 	add a new rule. Decide what kind of lock to use (tuple-level or
 * 	relation-level lock). Add locks and/or stubs and the appropriate
 *	system catalog info.
 *------------------------
 */
extern
void
prs2AddTheNewRule ARGS((
    Prs2RuleData	r,
    List		hint
));

/*------------------------
 * prs2DeleteTheOldRule
 *	delete a rule given its rule oid. Find if it was a tuple-level
 *	lock or a relation-level lock rule and do the right thing
 *	(delete locks/stubs & system catalog info).
 *------------------------
 */
extern
void
prs2DeleteTheOldRule ARGS((
	ObjectId	ruleId
));

extern void prs2FindLockTypeAndAttrNo();
extern LispValue prs2FindConstantQual();
extern LispValue prs2FindConstantClause();
extern bool prs2IsATupleLevelLockRule();

/*====================== FILE: prs2tup.c ============================*/
extern bool prs2DefTupleLevelLockRule();
extern RuleLock prs2FindLocksThatWeMustPut();
extern bool prs2DoesStubDependsOnAttribute();
extern bool prs2LockWritesAttributes();
extern void prs2FindAttributesOfQual();
extern void prs2UndefTupleLeveLockRule();
extern void prs2RemoveTupleLeveLocksAndStubsOfManyRules();

/*====================== FILE: prs2rel.c ============================*/
extern void prs2DefRelationLevelLockRule();
extern void prs2UndefRelationLevelLockRule();
extern void prs2RemoveRelationLevelLocksOfRule();
extern void prs2SetRelationLevelLocks();
extern void prs2AddRelationLevelLock();
 
/*===================================================================
 * RULE PLANS
 *
 * The rule plans are stored in the "pg_prs2plans" relation.
 * There are different types of plans.
 * Each "plan" contains appart from one or more parsetrees/plans
 * some rule information.
 * The first item of all the plans is a string describing the type of the
 * plan. This string can be "action" for the ACTION plans, and "export"
 * for the EXPORT plans.
 * The second item is the plan information itself, and its format depends
 * on the type of plan:
 *
 * a) ACTION PLANS:
 *	They are a list with at least two items:
 *
 *	The first item is a list giving some info for the rule.
 *	Currently this can have the following elements:
 *	The first element is an integer, equal to 1 if the rule is an
 *	instead rule, 0 otherwise.
 *	The second is the "event attribute" number, i.e. the attrno
 *	of the attribute specified in the "on <action> to <rel>.<attr>"
 *	rule clause.
 *	The third is the "updated attribute" number, i.e. the attrno 
 * 	of the attribute updated by a backward chaining rule.
 *
 *	The second item is the qualification of the rule.
 *	This should be tested before and only if it succeeds should the
 *	action part of the rule be executed.
 *	This qualifcation can be either "nil" which means that
 *	there is no qualification and the action part of the rule should be
 *	always executed, or a 2 item list, the first item beeing the parse
 *	tree corresponding to the qualification and the second one the plan.
 *
 *	Finally the (optional) rest items are the actions of the rule.
 *	Each one of them can be either a 2 item list (parse tree + plan)
 *	or the string "abort" which means that the current Xaction should be
 *	aborted.
 *
 * b) EXPORT PLANS:
 *	this is the kind of plan to be executed when an export
 *	lock is broken.
 *	The first item of the plan is a list with information
 *	about this export lock. This information consists of the
 *	following items:
 *		1) a string containing the lock (use `lockin' to recreate
 *		the lock).
 *	Then there is the plan to be run in order to add/delete
 *	rule locks when this export lock is broken. This plan is actually
 * 	a two item list conatining the parsetree and the actual plan.
 *	
 *===================================================================
 */

#define Prs2RulePlanType_EXPORT			("export")
#define Prs2RulePlanType_ACTION			("action")

#define prs2GetTypeOfRulePlan(x)		(CAR(x))
#define prs2GetPlanInfoFromRulePlan(x)		(CDR(x))

#define prs2GetRuleInfoFromActionPlan(x)	(CAR(CDR(x)))
#define prs2GetQualFromActionPlan(x)		(CADR(CDR(x)))
#define prs2GetActionsFromActionPlan(x)		(CDR(CDR(CDR(x))))

#define prs2GetLockInfoFromExportPlan(x)	(CAR(CDR(x)))
#define prs2GetActionPlanFromExportPlan(x)	(CADR(CDR(x)))

extern
Boolean
prs2IsRuleInsteadFromRuleInfo ARGS((
    LispValue ruleInfo
));

extern
AttributeNumber
prs2GetEventAttributeNumberFromRuleInfo ARGS((
    LispValue ruleInfo
));

extern
AttributeNumber
prs2GetUpdatedAttributeNumberFromRuleInfo ARGS((
    LispValue ruleInfo
));

#define prs2GetParseTreeFromOneActionPlan(x)	(CAR(x))
#define prs2GetPlanFromOneActionPlan(x)		(CADR(x))

/*
 * prs2GetRulePlanFromCatalog
 * Given a rule id and a plan number get the appropriate plan
 * from the system catalogs. At the same time construct a list
 * with all the Param nodes contained in this plan.
 */
extern
LispValue
prs2GetRulePlanFromCatalog ARGS((
    ObjectId		ruleId,
    Prs2PlanNumber	planNumber,
    ParamListInfo	*paramListP
));

/*==================================================================
 * AttributeValues stuff...
 *==================================================================
 *
 * These definitions & routines make possible to use an array of
 * attribute values instead of a tuple, thus making easier to change
 * these values without having to make multiple copies of the tuple.
 * It also makes easier to keep some extra information about how the value
 * of attributes were calculated.
 * 
 * Explanation of the fileds of a 'AttributesValuesData':
 * For each attribute of the tuple there is a corresponding
 * 'AttributeValuesData' structure, with the following fields:
 *	value:	the value of this attribute. This is initially
 *		initialized to the value stroed in the tuple.
 *	isNull: true if the coresponding attribute in the tuple is
 *		null.
 *	isCalculated: Initially false. It becomes true if we have
 *		checked this attribute for possibly applicable
 *		rules, and we have finally calculated its correct value.
 *	isChanged: If an attribute has been checked for rules (i.e.
 *		has its 'isCalculated' field equal to true), then two
 *		things can happen. Either thre was no applicable rule
 *		found, in which case we have used the value stored
 *		in the tuple and 'isChanged' is equal to false,
 *		or there was a rule that calculated a value for
 *		this attribute, in which case 'isChanged' is true, and
 *		'value' is this new value.
 */

typedef struct AttributeValuesData {
    Datum	value;
    Boolean	isNull;
    Boolean	isCalculated;
    Boolean	isChanged;
} AttributeValuesData;

typedef AttributeValuesData *AttributeValues;
#define InvalidAttributeValues ((AttributeValues)NULL)

/*---------------------------------------------------------------------
 * attributeValuesCreate
 *    Given a tuple create the corresponding 'AttributeValues' array.
 *    Note that in the beginning all the 'value' entries are copied
 *    from the tuple and that 'isCalculated' are all false.
 */
extern
AttributeValues
attributeValuesCreate ARGS((
    HeapTuple tuple,
    Buffer buffer,
    Relation relation
));

/*---------------------------------------------------------------------
 * attributeValuesFree
 *    Free a previously allocated 'AttributeValues' array.
 */
extern
void
attributeValuesFree ARGS((
    AttributeValues a,
    Relation relation
));

/*--------------------------------------------------------------------
 * attributeValuesMakeNewTuple
 *    Given the old tuple and the values that the new tuple should have
 *    create a new tuple.
 *    Returns 1 if a new tuple has been created (stored in *newTupleP)
 *    and 0 if the old tuple is the same as the new tuple, in which
 *    case we can use 'tuple' instead, in order to avoid a redudant
 *    copy operation.
 */
extern
int
attributeValuesMakeNewTuple ARGS((
    HeapTuple tuple,
    Buffer buffer,
    AttributeValues attrValues,
    RuleLock locks,
    Prs2LockType lockType,
    Relation relation,
    HeapTuple *newTupleP
));

/*--------------------------------------------------------------------
 * attributeValuesCombineNewAndOldTuple
 *    In the case of a replace command, given the 'raw' tuple, i.e.
 *    the tuple as retrieved by the AM (*not* changed by any backward
 *    chaining rules) and the 'new' tuple (the one with all backward
 *    chaning rules activated + with all user updates)
 *    form the tuple that will finally replace the old one.
 */
extern
HeapTuple
attributeValuesCombineNewAndOldTuple ARGS((
    AttributeValues rawAttrValues,
    AttributeValues newAttrValues,
    Relation relation,
    AttributeNumberPtr attributeArray,
    AttributeNumber numberOfAttributes
));

/*========================================================================
 * EState Rule Info + Rule Stack
 *
 * This structure (which is kept inside the executor state node EState)
 * contains some information used by the rule manager.
 *
 * RULE DETECTION MECHANISM:
 * prs2Stack: A stack where enough information is ketp in order to detect
 *	rule loops.
 * prs2StackPointer: the next (free) stack entry
 * prs2MaxStackSize: number of stack entries allocated. If
 *      prs2StackPointer is >= prs2MaxStackSize the stack is full
 *	and we have to reallocate some more memory...
 *
 * MISC INFO:
 * 
 *========================================================================
 */
typedef struct Prs2StackData {
    ObjectId		ruleId;		/* OID of the rule */
    ObjectId		tupleOid;	/* the tuple that activated the rule*/
    AttributeNumber	attrNo;		/* the locked attribute */
} Prs2StackData;

typedef Prs2StackData *Prs2Stack;

typedef struct Prs2EStateInfoData {
    Prs2Stack	prs2Stack;	/* the stack used for loop detection */
    int		prs2StackPointer;	/* the next free stack entry */
    int		prs2MaxStackSize;	/* the max number of entries */
} Prs2EStateInfoData;

typedef  Prs2EStateInfoData *Prs2EStateInfo;

/*
 * prs2RuleStackPush
 *    Add a new entry to the rule stack. First check if there is enough
 *    stack space. otherwise reallocate some more memory...
 */
extern
void
prs2RuleStackPush ARGS((
    Prs2EStateInfo p,
    ObjectId ruleId,
    ObjectId tupleOid,
    AttributeNumber attributeNumber
));

/*
 * prs2RuleStackPop
 *    Discard the top entry of the stack
 */
extern
void
prsRuleStackPop ARGS((
    Prs2EStateInfo p
));

/*
 * prs2RuleStackSearch
 *   Search for a stack entry matching the given arguments.
 *   Return true if found, false otherwise...
 */
extern
bool
prs2RuleStackSearch ARGS((
    Prs2EStateInfo p,
    ObjectId ruleId,
    ObjectId tupleOid,
    AttributeNumber attributeNumber
));

/*
 * prs2RuleStackInitialize
 *   Intialize the stack.
 */
extern
Prs2EStateInfo
prs2RuleStackInitialize ARGS((
));

/*
 * prs2RuleStackFree
 *   Free the memory occupied by the stack.
 */
extern
void
prs2RuleStackFree ARGS((
    Prs2EStateInfo p
));

/*========================================================================
 * VARIOUS ROUTINES....
 *========================================================================
 */
/*
 * PlanToString
 *
 * Given a plan (or an arbritary (?) lisp structure, transform it into a
 * a strign which has the following two properties
 *  a) it is readable by (some) humans
 *  b) it can be used to recreate the original plan/lisp structure
 *     (see routine "StringToPlan").
 *
 *
 * XXX Maybe this should be placed in another header file...
 */
extern
char *
PlanToString ARGS((
    LispValue lispStructure
));

/*========================================================================
 * These routines are some 'internal' routines. 
 *========================================================================
 */

extern LispValue StringToPlan();
extern LispValue StringToPlanWithParams();

/* XXX this causes circular dependency!
extern EState CreateExecutorState();
*/

extern Prs2Status prs2Retrieve();
extern Prs2Status prs2Append();
extern Prs2Status prs2Delete();
extern Prs2Status prs2Replace();
extern RuleLock prs2FindLocksForNewTupleFromStubs();

/*
 * These are functions in prs2plans.c
 */
/*extern LispValue prs2GetRulePlanFromCatalog(); -glass */
extern int prs2CheckQual();
extern void prs2RunActionPlans();
extern int prs2RunOnePlanAndGetValue();
extern void prs2RunOnePlan();
extern LispValue prs2MakeQueryDescriptorFromPlan();

/*
 * functions in prs2bkwd.c
 */
extern void prs2CalculateAttributesOfParamNodes();
extern void prs2ActivateBackwardChainingRules();
extern void prs2ActivateForwardChainingRules();

/*
 * functions in prs2impexp.c
 */
extern RuleLock prs2FindNewExportLocksFromLocks();
extern RuleLock prs2GetExportLockFromCatalog();
extern void prs2ActivateExportLockRulePlan();

/*============== RULE STATISTICS ============================*/
/*
 * the following variables/routines are used to print stats about
 * the tuple level system usage.
 * (all this stuff is defined in "rules/prs2/prs2main.c")
 */
extern int Prs2Stats_rulesActivated;
extern int Prs2Stats_rulesTested;
extern void ResetPrs2Stats();
extern void ShowPrs2Stats();

#endif Prs2Included

@


1.30
log
@fixed prototype for attributeFreeValue
@
text
@d6 1
a6 1
 *   $Header: RCS/prs2.h,v 1.29 91/12/07 17:18:25 dpassage Exp $
d37 1
a38 1
#define PRS2_DEBUG 1
@


1.29
log
@deleted spurious semicolon in prototype for attributeValuesFree()
@
text
@d6 1
a6 1
 *   $Header: RCS/prs2.h,v 1.28 91/12/04 01:58:45 glass Exp Locker: dpassage $
d672 2
a673 1
    AttributeValues a
@


1.28
log
@unterminated comment
@
text
@d6 1
a6 1
 *   $Header: ../src/lib/H/rules/RCS/prs2.h,v 1.27 91/11/18 22:23:29 mer Exp Locker: glass $
d672 1
a672 1
    AttributeValues a;
@


1.27
log
@prototypes finale
@
text
@d6 1
a6 1
 *   $Header: /users/mer/postgres/src/lib/H/rules/RCS/prs2.h,v 1.26 1991/11/12 23:30:14 mer Exp mer $
d668 1
d808 1
a808 1

@


1.26
log
@prototype fix
@
text
@d6 1
a6 1
 *   $Header: /users/mer/postgres/src/lib/H/rules/RCS/prs2.h,v 1.25 1991/11/11 23:06:06 hong Exp $
d471 2
a472 1
    Prs2RuleData	r
d690 1
@


1.25
log
@clean up for prototyping
@
text
@d6 1
a6 1
 *   $Header: RCS/prs2.h,v 1.24 91/10/01 16:27:36 glass Exp Locker: hong $
d339 1
a339 1
    Relation relation
@


1.24
log
@initial ansi c compatibility checkin
@
text
@d6 1
a6 1
 *   $Header: RCS/prs2.h,v 1.23 91/04/23 14:54:53 sp Exp Locker: sp $
a831 1
extern LispValue MakeQueryDesc();
@


1.23
log
@some declarations for variables/routines used to collect
rule usage statistics.
@
text
@d6 1
a6 1
 *   $Header: RCS/prs2.h,v 1.22 91/04/11 21:29:47 sp Exp Locker: sp $
d124 2
a125 1
prs2MustCallRuleManager ARGS((
d130 1
a130 1
));
d146 2
a147 1
prs2Main ARGS((
d164 1
a164 1

d203 1
a203 1
    Prs2PlanNumber	planNumber
d228 1
a228 1
    Prs2OneLock	oneLock2,
d240 1
a240 1
    RuleLock	locks;
d255 1
a255 1
    Buffer		buffer,
d329 1
a329 1
    RuleLock	locks;
d350 1
a350 1
    RuleLock	lock1
d361 1
a361 1
    RuleLock	lock1
d372 1
a372 1
    Prs2LockType	locktype;
d659 3
a661 3
    HeapTuple tuple;
    Buffer buffer;
    Relation relation;
d685 6
a690 6
    HeapTuple tuple;
    Buffer buffer;
    AttributeValues attrValues;
    RuleLock locks;
    Relation relation;
    HeapTuple *newTupleP;
d766 1
a766 1
    Prs2EStateInfo p;
d779 1
a779 1
    ObjectId tupleOid;
d799 1
a799 1
    Prs2EStateInfo p;
d846 1
a846 1
extern LispValue prs2GetRulePlanFromCatalog();
@


1.22
log
@new function 'prs2MustCallRuleManager'
@
text
@d6 1
a6 1
 *   $Header: RCS/prs2.h,v 1.21 91/04/10 16:06:37 sp Exp $
d864 11
@


1.21
log
@the format of the rule plans has slightly changed...
@
text
@d6 1
a6 1
 *   $Header: RCS/prs2.h,v 1.20 91/04/08 18:12:50 sp Exp Locker: sp $
d119 13
d146 2
d155 2
@


1.20
log
@misc changes to support locking more than one path in the rule
qualification's tree...
@
text
@d6 1
a6 1
 *   $Header: RCS/prs2.h,v 1.19 91/02/25 16:52:12 sp Exp Locker: sp $
d226 5
a230 4
 *    Extract the locks from a tuple. It returns a 'RuleLock',
 *    (NOTE:it will never return NULL! Even if the tuple has no
 *    locks in it, it will return a 'RuleLock' with 'numberOfLocks'
 *    equal to 0.
a236 1
    TupleDescriptorData	tupleDescriptor
d547 1
a547 1
#define prs2GetPlanInfoFromRulePlan(x)		(CADR(x))
d549 3
a551 3
#define prs2GetRuleInfoFromActionPlan(x)	(CAR(CADR(x)))
#define prs2GetQualFromActionPlan(x)		(CADR(CADR(x)))
#define prs2GetActionsFromActionPlan(x)		(CDR(CDR(CADR(x))))
d553 2
a554 2
#define prs2GetLockInfoFromExportPlan(x)	(CAR(CADR(x)))
#define prs2GetActionPlanFromExportPlan(x)	(CADR(CADR(x)))
@


1.19
log
@'GetRuleHintFromParse' added.
@
text
@d6 1
a6 1
 *   $Header: RCS/prs2.h,v 1.18 91/02/24 19:57:10 sp Exp $
d180 7
a186 5
    RuleLock       oldLocks,
    ObjectId	    ruleId,
    Prs2LockType    lockType,
    AttributeNumber attributeNumber,
    Prs2PlanNumber  planNumber
d202 23
d335 11
d493 8
a500 1
 * They are a list with at least two items:
d502 2
a503 4
 * The first item is a list giving some info for the rule.
 * Currently this can have the following elements:
 * The first element is an integer, equal to 1 if the rule is an
 * instead rule, 0 otherwise.
d505 9
a513 7
 * The second item is the qualification of the rule.
 * This should be tested before and only if it succeeds should the
 * action part of the rule be executed.
 * This qualifcation can be either "nil" which means that
 * there is no qualifcation and the action part of the rule should be
 * executed, or a 2 item list, the first item beeing the parse tree
 * corresponding to the qualifcation and the second one the plan.
d515 25
a539 4
 * Finally the (optional) rest items are the actions of the rule.
 * Each one of them can be either a 2 item list (parse tree + plan)
 * or the string "abort" which means that the current Xaction should be
 * aborted.
d543 2
a544 3
#define prs2GetRuleInfoFromRulePlan(x)	(CAR(x))
#define prs2GetQualFromRulePlan(x)	(CADR(x))
#define prs2GetActionsFromRulePlan(x)	(CDR(CDR(x)))
d546 10
d810 1
d812 1
d840 7
@


1.18
log
@2 new routines: prs2RemoveLocksOfTypeInPlace() and 
prs2FindLocksForNewTupleFromStubs().
@
text
@d6 1
a6 1
 *   $Header: RCS/prs2.h,v 1.17 91/02/24 12:34:43 sp Exp Locker: sp $
d357 1
@


1.17
log
@A lot of changes (tuple-level-locking is here to stay!)
@
text
@d6 1
a6 1
 *   $Header: RCS/prs2.h,v 1.16 91/02/08 17:37:12 sp Exp Locker: sp $
d321 11
d746 1
@


1.16
log
@Now 'prs2PutLocks' makes the update in place (i.e. it does NOT
create a copy of the tuple).
@
text
@d6 1
a6 1
 *   $Header: RCS/prs2.h,v 1.15 91/01/09 18:58:47 sp Exp Locker: sp $
d41 69
a116 10
/*------------------------------------------------------------------
 * prs2DefineTupleRule
 *    Define a PRS2 rule (tuple level proccessing)
 */
extern
void
prs2DefineTupleRule ARGS((
    LispValue	parseTree,
    char	*ruleText
));
a118 10
 * prs2RemoveTupleRule
 *    Remove a prs2 rule given its name.
 */
extern
void
prs2RemoveTupleRule ARGS((
    Name	ruleName
));

/*------------------------------------------------------------------
d239 26
d310 11
d359 4
a362 4
/*
 * prs2InsertRuleInfoInCatalog
 *    add information about the rule to the system catalogs.
 *    returns the OID of the rule.
d365 4
a368 3
ObjectId
prs2InsertRuleInfoInCatalog ARGS((
    Name	ruleName
d371 3
a373 10

/*
 * prs2GenerateActionPlans
 *    Generate the plans for the action part of the rule
 *    The input argument is a list with the parsetrees for all
 *    the commands specified in the action part of the rule + the
 *    rule qualification.
 *    The returned value is a list with one item per command.
 *    Each one of them is a list with a (possibly modified)
 *    parse tree and the corresponding plan.
a375 12
LispValue
prs2GenerateActionPlans ARGS((
    int		isRuleInstead,
    LispValue	ruleQual,
    LispValue	ruleAction
));

/*
 * prs2InsertRulePlanInCatalog
 *    Insert a rule plan into the appropriate system catalogs.
 */
extern
d377 2
a378 4
prs2InsertRulePlanInCatalog ARGS((
    ObjectId		ruleId,		/* the OID of the rule */
    Prs2PlanNumber	planNumber,	/* the PlanNumber for this plan*/
    LispValue		rulePlan
d381 19
a399 4
/*
 * prs2PutRelationLevelLocks
 *    Put all the appropriate locks in the RelationRelation
 *    (relation level locking...).
d403 2
a404 5
prs2PutRelationLevelLocks ARGS((
    ObjectId		ruleId,		/* the OID of the rule */
    Prs2LockType	lockType	/* the type of lock */
    ObjectId		eventRelationOid; /* the OID of the locked relation */
    AttributeNumber	attrNo;		/* the attribute to be locked */
d407 6
a412 4
/*
 * prs2RemoveRelationLevelLocks
 *    Remove the lock put by 'prs2PutRelationLevelLocks'
 *    (relation level locks)
d416 2
a417 3
prs2RemoveRelationLevelLocks ARGS((
    ObjectId	ruleId,			/* the OID of the rule */
    ObjectId	eventRelationOid	/* OID of the locked relation */
d420 4
d425 16
a734 2
extern EventType prs2FindEventTypeFromParse();
extern ActionType prs2FindActionTypeFromParse();
@


1.15
log
@Some functions have been renamed...
@
text
@d6 1
a6 1
 *   $Header: RCS/prs2.h,v 1.14 90/10/16 17:15:28 sp Exp $
d167 2
a168 2
 *    given a tuple, create a copy of it and put the given locks in its
 *    t_lock field...
d171 1
a171 1
HeapTuple
@


1.14
log
@'prs2RunOnePlan' now does not return a value...
@
text
@d6 1
a6 1
 *   $Header: RCS/prs2.h,v 1.13 90/08/19 15:29:13 sp Exp Locker: sp $
d316 1
a316 1
 * prs2PutLocksInRelation
d322 1
a322 1
prs2PutLocksInRelation ARGS((
d330 3
a332 3
 * prs2RemoveLocks
 *    Remove the lock put by 'prs2PutLocks'
 *    For the time being only relation level locking is implemented.
d336 1
a336 1
prs2RemoveLocks ARGS((
a637 1
extern void Prs2PutLocks();
@


1.13
log
@Some #defines have been moved to prs2locks.h
@
text
@d6 1
a6 1
 *   $Header: RCS/prs2.h,v 1.12 90/08/18 00:40:35 cimarron Exp Locker: sp $
d647 1
a647 1
extern LispValue prs2RunOnePlan();
@


1.12
log
@eliminated less significant .h files
@
text
@d6 1
a6 1
 *   $Header: RCS/prs2.h,v 1.11 90/08/17 08:53:01 cimarron Exp Locker: cimarron $
d30 1
a30 1
 * These defs were put in a separate file becuase they are included
a100 31

/*------------------------------------------------------------------
 * Routines to access/set Prs2Lock data...
 * It is highly recommended that these routines are used instead
 * of directly manipulating the variosu structures invloved..
 *------------------------------------------------------------------
 */

#define prs2OneLockGetRuleId(l)			((l)->ruleId)
#define prs2OneLockGetLockType(l)		((l)->lockType)
#define prs2OneLockGetAttributeNumber(l)	((l)->attributeNumber)
#define prs2OneLockGetPlanNumber(l)		((l)->planNumber)

#define prs2OneLockSetRuleId(l, x)		((l)->ruleId = (x))
#define prs2OneLockSetLockType(l, x)		((l)->lockType = (x))
#define prs2OneLockSetAttributeNumber(l, x)	((l)->attributeNumber = (x))
#define prs2OneLockSetPlanNumber(l, x)		((l)->planNumber = (x))

/*------------------------------------------------------------------
 * prs2LockSize
 *    return the size needed for a 'Prs2LocksData' structure big enough
 *    to hold 'n' of 'Prs2OneLockData' structures...
 */
#define prs2LockSize(n) (sizeof(Prs2LocksData) \
			+ ((n)-1)*sizeof(Prs2OneLockData))

/*------------------------------------------------------------------
 * prs2GetNumberOfLocks
 *    return the number of locks contained in a 'RuleLock' structure.
 */
#define prs2GetNumberOfLocks(x)	((x)->numberOfLocks)
@


1.11
log
@added pathnames to #include statements
@
text
@d6 1
a6 1
 *   $Header: RCS/prs2.h,v 1.10 90/07/18 18:41:04 sp Version_2 Locker: cimarron $
d18 1
a18 1
#include "tmp/c.h"
a23 1
#include "tmp/datum.h"
@


1.10
log
@Yet anothet parsetree change...
@
text
@d6 1
a6 1
 *   $Header: RCS/prs2.h,v 1.9 90/07/17 20:33:27 sp Exp $
d18 1
a18 8
#include "c.h"
#include "pg_lisp.h"
#include "datum.h"
#include "heapam.h"
#include "rel.h"
#include "tupdesc.h"
#include "buf.h"
#include "params.h"
d20 9
d34 1
a34 1
#include "prs2locks.h"
@


1.9
log
@changed some macros because of new parsetree format
@
text
@d6 1
a6 1
 *   $Header: RCS/prs2.h,v 1.8 90/05/21 15:14:40 sp Exp $
d291 6
a296 5
#define GetRuleEventTypeFromParse(p)	(nth(3,p))
#define GetRuleEventTargetFromParse(p)	(nth(4,p))
#define GetRuleQualFromParse(p)		(nth(5,p))
#define GetRuleInsteadFromParse(p)	(nth(6,p))
#define GetRuleActionFromParse(p)	(nth(7,p))
@


1.8
log
@RuleLockToString and StringToRuleLock declared here...
@
text
@d6 1
a6 1
 *   $Header: RCS/prs2.h,v 1.7 90/05/14 20:30:18 sp Exp $
d295 1
a295 1
#define GetRuleActionFromParse(p)	(lispCons(nth(7,p),LispNil))
@


1.7
log
@I changed the "parse tree" #defines so now they agree with what the
parser produces...
@
text
@d6 1
a6 1
 *   $Header: RCS/prs2.h,v 1.6 90/05/10 16:20:34 sp Exp $
d264 21
@


1.6
log
@definitions for 'Prs2RuleListItem' have been moved to 'rulescan.h'
@
text
@d6 1
a6 1
 *   $Header: RCS/prs2.h,v 1.5 90/04/19 19:41:26 sp Exp Locker: sp $
d269 6
a274 6
#define GetRuleNameFromParse(p)		(nth(1,p))
#define GetRuleEventTypeFromParse(p)	(nth(2,p))
#define GetRuleEventTargetFromParse(p)	(nth(3,p))
#define GetRuleQualFromParse(p)		(nth(4,p))
#define GetRuleInsteadFromParse(p)	(nth(5,p))
#define GetRuleActionFromParse(p)	(nthCdr(6,p))
@


1.5
log
@Some new stuff for the rule info stored in the scan state.
@
text
@d6 1
a6 1
 *   $Header: RCS/prs2.h,v 1.4 90/04/03 17:02:27 sp Exp $
a605 93

/*========================================================================
 *
 * SCAN STATE RULE INFORMATION
 *
 * In every scan node we have to stroe some information about rules.
 * So, `CommonScanState' (see execnodes.h) contain a field called
 * 'css_ruleInfo' where all this information is stored.
 * This information should be correctly initialized at the same time the
 * rest of `ScanState' is also initialized (this happens when the
 * executor is called to perform the EXEC_START operation).
 * 
 * The scan state rule information contains the current fields:
 * 
 * ruleList: this is a linked list of records containing information
 * about all the 'view' like rules, i.e. rules of the form
 *       ON retrieve to <relation>
 *       DO [ instead ] retrieve ......
 * These rules are processed first by the executor (i.e. before we even
 * call the access methods for the first time) to retrieve (one by one)
 * all the tuples returned by the action pat of the rule.
 * Then if none of these 'view' rules was an "instead" rule, we process
 * the "real" tuples (the ones returned by the access methods).
 * 
 * Each record in ruleList can be either a ruleId - plan number pair, 
 * or a plan (a LispValue) corresponding to a rule (NOTE: each rule
 * can have more than one plans!) or a query descriptor - EState
 * pair (in which case we have started retrieving tuples, one by one).
 * A NULL ruleList means that there are no (more) rules to be processed.
 * 
 * insteadRuleFound: True if there was at least one "instead"
 * rule was encountered, false otherwise.
 *
 * relationLock: the (relation level) rule locks for the scanned
 * relation (found in the Relation relation)
 * 
 */

#define PRS2_RULELIST_RULEID	1
#define PRS2_RULELIST_PLAN	2
#define PRS2_RULELIST_QUERYDESC	3
#define PRS2_RULELIST_DONE	99
#define PRS2_RULELIST_INVALID	100

typedef struct Prs2RuleListItem {
    int type;
    struct Prs2RuleListItem *next;
    union {
	struct ruleId {
	    ObjectId ruleId;
	    Prs2PlanNumber planNumber;
	} ruleId;
	struct rulePlan {
	    LispValue plan;
	} rulePlan;
	struct {
	    LispValue queryDesc;
	    struct EState *estate; /* XXXXX THIS IS A HACK! */
	} queryDesc;
    } data;
} Prs2RuleListItem;

typedef Prs2RuleListItem *Prs2RuleList;

typedef struct ScanStateRuleInfoData {
    Prs2RuleList ruleList;
    bool insteadRuleFound;
    RuleLock relationLocks;
} ScanStateRuleInfoData;

typedef ScanStateRuleInfoData *ScanStateRuleInfo;

/*-------------
 * Create and initialize a 'ScanStateRuleInfo'
 */
extern
ScanStateRuleInfo
prs2MakeScanStateRuleInfo ARGS((
    Relation relation
));

/*-------------
 * Activate the "view" rules & return one by one all the appropriate
 * tuples...
 */
extern
HeapTuple
prs2GetOneTupleFromViewRules ARGS((
    ScanStateRuleInfo	scanStateRuleInfo,
    Prs2EStateInfo	prs2EStateInfo,
    Relation		explainRel
));

@


1.4
log
@Some new function declarations...
@
text
@d6 1
a6 1
 *   $Header: RCS/prs2.h,v 1.3 90/03/07 17:14:17 sp Exp $
d608 93
d711 1
a711 2
 *     (see routine "StringToPlan".
 * NOTE: used to be called "plan_to_string"
d749 1
@


1.3
log
@Added a new attribute `prs2QueryDesc' in Prs2EstateInfo
@
text
@d6 1
a6 1
 *   $Header: RCS/prs2.h,v 1.2 90/01/30 23:20:24 sp Exp $
d380 5
a384 1
#define prs2IsRuleInsteadFromRuleInfo(x) (!strcmp(CString(CAR(x)),"instead"))
d386 12
d498 18
a530 2
 * prs2QueryDesc: the query descriptor of a recursive call made by the
 *      rule manager to the executor.
a542 1
    LispValue	prs2QueryDesc;
@


1.2
log
@added some more rutine declarations...
@
text
@d6 1
a6 1
 *   $Header: RCS/prs2.h,v 1.1 90/01/11 14:46:05 sp Exp $
d136 5
a140 1
#define prs2FreeLocks(x)	pfree((x))
d380 1
a380 1
#define prs2IsRuleInsteadFromRuleInfo(x) (CInteger(CAR(x)))
d485 2
a486 5
 * The following has to do with a rule loop detection mechanism.
 * The 'Prs2EStateInfo' is a pointer to a structure that contains
 * all the appropriate info. Note that this is kept inside the
 * executor state node EState.
 * Initially this should be NULL.
d488 12
d511 2
a514 1
    Prs2Stack	prs2Stack;	/* the stack used for loop detection */
@


1.1
log
@Initial revision
@
text
@d6 1
a6 1
 *   $Header: RCS/prs2.h,v 1.6 90/01/11 00:22:27 sp Exp Locker: sp $
d78 1
a78 1
#define PRS2_STATUS_STATUS_INSTEAD	3
d128 1
a128 1
 *    return the number of locks contained in a 'Prs2Locks' structure.
d144 1
a144 1
Prs2Locks
d155 1
a155 1
Prs2Locks
d157 1
a157 1
    Prs2Locks       oldLocks,
d166 1
a166 1
 *    Given a 'Prs2Locks' return a pointer to its Nth lock..
d172 1
a172 1
    Prs2Locks	locks,
d178 1
a178 1
 *    Extract the locks from a tuple. It returns a 'Prs2Locks',
d180 1
a180 1
 *    locks in it, it will return a 'Prs2Locks' with 'numberOfLocks'
d184 1
a184 1
Prs2Locks
d202 1
a202 1
    Prs2Locks	newLocks
d212 1
a212 1
    Prs2Locks	locks
d218 1
a218 1
 *    the old `Prs2Locks' is destroyed and should never be
d223 1
a223 1
Prs2Locks
d225 1
a225 1
    Prs2Locks	oldLocks,
d234 1
a234 1
Prs2Locks
d236 1
a236 1
    Prs2Locks	locks;
d244 1
a244 1
Prs2Locks
d251 1
a251 1
 *   Create the union of two Prs2Locks.
d254 1
a254 1
Prs2Locks
d256 2
a257 2
    Prs2Locks	lock1,
    Prs2Locks	lock1
d320 3
a322 3
 * prs2PutLocks
 *    Put all the appropriate locks.
 *    For the time being only relation level locking is implemented.
d326 5
a330 4
prs2PutLocks ARGS((
    ObjectId	ruleId,		/* the OID of the rule */
    LispValue	eventTargetList,/* the target list specified in the event */
    int		lockType	/* the event that triggers the rule */
d352 4
a355 4
 * The first item is a string giving some info for the rule.
 * Currently this can have the following values:
 *  "instead" the rule has an instead specified in its action part
 *  "not-instead" no instead specified in the action part..
d376 2
d433 1
d473 1
a473 1
    Prs2Locks locks;
d503 1
a503 1
typedef Prs2EStateInfoData *Prs2EStateInfo;
d562 3
d566 19
d586 1
a586 1
 * Thse routines are some 'internal' routines. 
d590 6
a595 2
extern void prs2CalculateOneAttribute();
extern void prs2CalculateAttributesOfParamNodes();
d600 3
d604 8
d613 6
d621 1
@