PL / SQL触发器无法读取表AFTER INSERT

Question

I am doing a small project, replicating a CVS Pharmacy DB. Learning about triggers in PL/SQL, I thought it would be a good idea to create a trigger that would update the store's inventory of a product when that product is purchased in the store (transaction).

Now in order to do so, I have to do a AFTER INSERT on productLine_T (the table where a product in the transaction is being purchased with a quantity), store the transactionID, find the employeeID of newly inserted transaction, get storeID from employee of that transaction, which then allows me to get the corresponding inventory by storeID to update the productID in Inventory of that store by the orderedQuantity in productLine_T.

After creating this trigger, I am getting the following error when I try inserting into productLine_T, described above:

Error starting at line 193 in command:
INSERT INTO productLine_T(transactionID, productID, productQuantity, productFinalPrice)
VALUES(00000006, 00000001, 2, 1.50)
Error report:
SQL Error: ORA-04091: table BSEWARDS.PRODUCTLINE_T is mutating, trigger/function may     not see it
ORA-06512: at "BSEWARDS.ONPRODUCTPURCHASED", line 10
ORA-04088: error during execution of trigger 'BSEWARDS.ONPRODUCTPURCHASED'
04091. 00000 -  "table %s.%s is mutating, trigger/function may not see it"
*Cause:    A trigger (or a user defined plsql function that is referenced in
       this statement) attempted to look at (or modify) a table that was
       in the middle of being modified by the statement which fired it.
*Action:   Rewrite the trigger (or function) so it does not read that table.

I don't understand why the trigger cannot read in the new value AFTER INSERT? I can include my ERD and any other visual representations needed for help when requested.

* Trigger: *

    create or replace 
trigger onProductPurchased
  AFTER INSERT on productLine_T
  for each row
    declare
      transQty productLine_T.productQuantity%type;
      transID productLine_T.transactionID%type;
      prodID productLine_T.productID%type;
      empID Employee_T.employeeID%type;
      stID Store_T.storeID%type;
      --outOfStock exception;
  begin
    --store new transactionID in transID for query
    select transactionID, productID, productQuantity into transID, prodID, transQty
      FROM productLine_T
      WHERE productLine_T.transactionID = :new.transactionID;
    --find store by employee of transactionID to get inventory of store

      -- get employeeID of newly inserted transaction
      select emp.employeeID into empID FROM Employee_T emp, Transaction_T trans
        WHERE trans.transactionID = transID;

      -- get storeID from employee at store who made the transaction
      select st.storeID into stID FROM Store_T st, Employee_T emp
        WHERE emp.employeeID = empID;

      --get inventory by storeID and change inventoryQty based on productID quantity
      update Inventory_T 
        set inventoryQuantity = inventoryQuantity - :new.productQuantity
        WHERE Inventory_T.storeID = stID AND Inventory_T.storeID = prodID;
  end;

Answer 1

Row level triggers in PL/SQL cannot SELECT from the table that they're placed on without causing mutating table errors. In your case, I don't think you even need to SELECT from it - can't you just replace this:

SELECT transactionID, productID, productQuantity into transID, prodID, transQty
FROM productLine_T
WHERE productLine_T.transactionID = :new.transactionID;

with this:

transID  := :new.transactionID;
prodID   := :new.productID;
transQty := :new.productQuantity;

The second problem you have is that both of the queries in your trigger reference more than one table but you haven't specified any join conditions, which means you'll get the cartesian product of the two tables. You don't actually care about the employee, you only care about the store, so you'd be better to replace both queries with a single one that fetches just what you need:

SELECT st.storeID INTO stID
FROM Transaction_T trans
INNER JOIN Employee_T emp ON (emp.employeeID = trans.employeeID)
INNER JOIN Store_T st ON (st.storeID = emp.storeID)
WHERE trans.transactionID = transID;

I've made some guesses about your schema here, but it's probably close enough to get you there. Note the use of ANSI join syntax, which neatly separates the join conditions (in the ON clause) from the filter predicates (in the WHERE clause).

It's also worth noting that some people consider it bad form to use a SELECT ... INTO ... statement due to the fact that if you ever got zero rows, or more than one row, it will raise an exception. It would be better to put the query into a cursor and then fetch from it exactly once. This way you know you will only ever get one record and you can easily protect against zero records by checking the %NOTFOUND cursor attribute.