pdf viewer dll for c# : Add signature image to pdf acrobat application software utility html windows asp.net visual studio postgresql-9.4-A4108-part2733

Chapter 38. The Rule System
SELECT t1.a, t2.b, t1.ctid FROM t1, t2 WHERE t1.a = t2.a;
Now another detail of PostgreSQL enters the stage. Old table rows aren’t overwritten, and this is
why
ROLLBACK
is fast. In an
UPDATE
,the new result row is inserted into the table (after stripping the
CTID) and in the row header of the old row, which the CTID pointed to, the
cmax
and
xmax
entries
are set to the current command counter and current transaction ID. Thus the old row is hidden, and
after the transaction commits the vacuum cleaner can eventually remove the dead row.
Knowing all that, we cansimply applyview rules inabsolutely the same way to anycommand. There
is no difference.
38.2.3. The Power of Views in PostgreSQL
The above demonstrates how the rule system incorporates view definitions into the original query
tree. In the second example, a simple
SELECT
from one view created a final query tree that is a join
of 4 tables (
unit
was used twice with different names).
The benefit of implementing views with the rule system is, that the planner has all the information
about which tables have to be scanned plus the relationships between these tables plus the restrictive
qualifications from the views plus the qualifications from the original query in one single query tree.
And this is still the situation when the original query is already a join over views. The planner has
to decide which is the best path to execute the query, and the more information the planner has, the
better this decision can be. And the rule system as implemented in PostgreSQL ensures, that this is
all information available about the query up to that point.
38.2.4. Updating a View
What happens if a view is named as the targetrelation for an
INSERT
,
UPDATE
,or
DELETE
?Doing the
substitutions described above would give a query tree in which the result relationpoints ata subquery
range-table entry, which will not work. There are several ways in which PostgreSQL can support the
appearance of updating a view, however.
If the subqueryselects from a singlebase relationandis simple enough, the rewriter can automatically
replace the subquery with the underlying base relation so that the
INSERT
,
UPDATE
,or
DELETE
is
applied tothe base relation in the appropriate way. Views that are “simple enough” for this are called
automatically updatable. For detailed information on the kinds of view that can be automatically
updated, see CREATE VIEW.
Alternatively, the operation may be handled by a user-provided
INSTEAD OF
trigger on the view.
Rewriting works slightly differently in this case. For
INSERT
,the rewriter does nothing at all with
the view, leaving it as the result relation for the query. For
UPDATE
and
DELETE
,it’s still necessary to
expand the view query to produce the “old” rows that the command will attempt to update or delete.
So the view is expandedas normal, butanother unexpandedrange-table entry is added to the query to
represent the view in its capacity as the result relation.
The problem that now arises is how to identify the rows to be updated in the view. Recall that when
the result relation is a table, a special CTID entry is added to the target list to identify the physical
locations of the rows tobe updated. This does not work if the result relation is a view, because a view
does not have any CTID, since its rows do not have actual physical locations. Instead, for an
UPDATE
or
DELETE
operation, a special
wholerow
entry is added to the target list, which expands to include
all columns from the view. The executor uses this value to supply the “old” row to the
INSTEAD OF
trigger. It is up to the trigger to work out what to update based on the old and new row values.
1008
Add signature image to pdf acrobat - insert images into PDF in C#.net, ASP.NET, MVC, Ajax, WinForms, WPF
Sample C# code to add image, picture, logo or digital photo into PDF document page using PDF page editor control
attach image to pdf form; how to add picture to pdf
Add signature image to pdf acrobat - VB.NET PDF insert image library: insert images into PDF in vb.net, ASP.NET, MVC, Ajax, WinForms, WPF
Guide VB.NET Programmers How to Add Images in PDF Document
add image to pdf online; add image to pdf file acrobat
Chapter 38. The Rule System
Another possibility is for the user to define
INSTEAD
rules that specifysubstitute actions for
INSERT
,
UPDATE
,and
DELETE
commands on a view. These rules will rewrite the command, typically into a
command that updates one or more tables, rather than views. That is the topic of the next section.
Note that rules are evaluated first, rewriting the original query before it is planned and executed.
Therefore, if a view has
INSTEAD OF
triggers as well as rules on
INSERT
,
UPDATE
,or
DELETE
,then
the rules will be evaluated first, and depending on the result, the triggers may not be used at all.
Automatic rewriting of an
INSERT
,
UPDATE
,or
DELETE
query on a simple view is always tried last.
Therefore, if a view has rules or triggers, they will override the default behavior of automatically
updatable views.
If there are no
INSTEAD
rules or
INSTEAD OF
triggers for the view, and the rewriter cannot automat-
ically rewrite the query as an update on the underlying base relation, an error will be thrown because
the executor cannot update a view as such.
38.3. Materialized Views
Materialized views in PostgreSQL use the rule system like views do, but persist the results in a table-
like form. The main differences between:
CREATE MATERIALIZED VIEW mymatview AS SELECT
*
FROM mytab;
and:
CREATE TABLE mymatview AS SELECT
*
FROM mytab;
are that the materialized view cannot subsequently be directly updated and that the query used to
create the materialized view is stored in exactly the same way that a view’s query is stored, so that
fresh data canbe generated for the materialized viewwith:
REFRESH MATERIALIZED VIEW mymatview;
The information about a materialized view in the PostgreSQL system catalogs is exactly the same as
it is for a table or view. So for the parser, a materialized view is a relation, just like a table or a view.
When a materialized viewis referenced in a query, the data is returned directly from the materialized
view, like from a table; the rule is only used for populating the materialized view.
While access to the data stored in a materialized view is often much faster than accessing the under-
lying tables directly or through a view, the data is not always current; yet sometimes current data is
not needed. Consider a table which records sales:
CREATE TABLE invoice (
invoice_no
integer
PRIMARY KEY,
seller_no
integer,
-- ID of salesperson
invoice_date
date,
-- date of sale
invoice_amt
numeric(13,2)
-- amount of sale
);
If people want to be able to quickly graph historical sales data, they might want to summarize, and
they may not care about the incomplete data for the current date:
CREATE MATERIALIZED VIEW sales_summary AS
SELECT
seller_no,
1009
.NET PDF Document Viewing, Annotation, Conversion & Processing
Convert image files to PDF. File & Page Process. Allow to create digital signature. Easy to set PDF file permission. Add, insert PDF native annotations to PDF file
add jpg to pdf acrobat; how to add a jpeg to a pdf file
BMP to PDF Converter | Convert Bitmap to PDF, Convert PDF to BMP
Also designed to be used add-on for .NET Image SDK, RasterEdge Bitmap to PDF Converter can Powerful image converter for Bitmap and PDF files; No need for
add photo to pdf form; how to add an image to a pdf
Chapter 38. The Rule System
invoice_date,
sum(invoice_amt)::numeric(13,2) as sales_amt
FROM invoice
WHERE invoice_date < CURRENT_DATE
GROUP BY
seller_no,
invoice_date
ORDER BY
seller_no,
invoice_date;
CREATE UNIQUE INDEX sales_summary_seller
ON sales_summary (seller_no, invoice_date);
This materializedviewmightbe useful for displayinga graphin thedashboard createdfor salespeople.
Ajob could be scheduled to update the statistics each night using this SQL statement:
REFRESH MATERIALIZED VIEW sales_summary;
Another use for a materialized view is to allow faster access to data brought across from a remote
system through a foreign data wrapper. A simple example using
file_fdw
is below, with timings,
but since this is using cache on the local system the performance difference compared to access to a
remote system would usually be greater than shown here. Notice we are also exploiting the ability to
put an index on the materialized view, whereas
file_fdw
does not support indexes; this advantage
might not apply for other sorts of foreign data access.
Setup:
CREATE EXTENSION file_fdw;
CREATE SERVER local_file FOREIGN DATA WRAPPER file_fdw;
CREATE FOREIGN TABLE words (word text NOT NULL)
SERVER local_file
OPTIONS (filename ’/usr/share/dict/words’);
CREATE MATERIALIZED VIEW wrd AS SELECT
*
FROM words;
CREATE UNIQUE INDEX wrd_word ON wrd (word);
CREATE EXTENSION pg_trgm;
CREATE INDEX wrd_trgm ON wrd USING gist (word gist_trgm_ops);
VACUUM ANALYZE wrd;
Now let’s spell-checka word. Using
file_fdw
directly:
SELECT count(
*
) FROM words WHERE word = ’caterpiler’;
count
-------
0
(1 row)
With
EXPLAIN ANALYZE
,we see:
Aggregate
(cost=21763.99..21764.00 rows=1 width=0) (actual time=188.180..188.181 rows=1 loops=1)
->
Foreign Scan on words
(cost=0.00..21761.41 rows=1032 width=0) (actual time=188.177..188.177 rows=0 loops=1)
Filter: (word = ’caterpiler’::text)
Rows Removed by Filter: 479829
Foreign File: /usr/share/dict/words
Foreign File Size: 4953699
1010
JPEG to PDF Converter | Convert JPEG to PDF, Convert PDF to JPEG
It can be used standalone. JPEG to PDF Converter is able to convert image files to PDF directly without the software Adobe Acrobat Reader for conversion.
add image to pdf file; add jpeg signature to pdf
PDF to WORD Converter | Convert PDF to Word, Convert Word to PDF
out transformation between different kinds of image files and Word Converter has accurate output, and PDF to Word need the support of Adobe Acrobat & Microsoft
add signature image to pdf; how to add jpg to pdf file
Chapter 38. The Rule System
Planning time: 0.118 ms
Execution time: 188.273 ms
If the materialized view is used instead, the query is much faster:
Aggregate
(cost=4.44..4.45 rows=1 width=0) (actual time=0.042..0.042 rows=1 loops=1)
->
Index Only Scan using wrd_word on wrd
(cost=0.42..4.44 rows=1 width=0) (actual time=0.039..0.039 rows=0 loops=1)
Index Cond: (word = ’caterpiler’::text)
Heap Fetches: 0
Planning time: 0.164 ms
Execution time: 0.117 ms
Either way, the word is spelled wrong, so let’s look for what we might have wanted. Again using
file_fdw
:
SELECT word FROM words ORDER BY word <-> ’caterpiler’ LIMIT 10;
word
---------------
cater
caterpillar
Caterpillar
caterpillars
caterpillar’s
Caterpillar’s
caterer
caterer’s
caters
catered
(10 rows)
Limit
(cost=11583.61..11583.64 rows=10 width=32) (actual time=1431.591..1431.594 rows=10 loops=1)
->
Sort
(cost=11583.61..11804.76 rows=88459 width=32) (actual time=1431.589..1431.591 rows=10 loops=1)
Sort Key: ((word <-> ’caterpiler’::text))
Sort Method: top-N heapsort
Memory: 25kB
->
Foreign Scan on words
(cost=0.00..9672.05 rows=88459 width=32) (actual time=0.057..1286.455 rows=479829 loops=1)
Foreign File: /usr/share/dict/words
Foreign File Size: 4953699
Planning time: 0.128 ms
Execution time: 1431.679 ms
Using the materialized view:
Limit
(cost=0.29..1.06 rows=10 width=10) (actual time=187.222..188.257 rows=10 loops=1)
->
Index Scan using wrd_trgm on wrd
(cost=0.29..37020.87 rows=479829 width=10) (actual time=187.219..188.252 rows=10 loops=1)
Order By: (word <-> ’caterpiler’::text)
Planning time: 0.196 ms
Execution time: 198.640 ms
If you can tolerate periodic update of the remote data to the local database, the performance benefit
can be substantial.
1011
GIF to PDF Converter | Convert GIF to PDF, Convert PDF to GIF
use of external applications & Adobe Acrobat Reader. This GIF to PDF Converter provided by RasterEdge is Features and Benefits. Powerful image converter for GIF
add picture to pdf reader; add jpg to pdf online
DICOM to PDF Converter | Convert DICOM to PDF, Convert PDF to
Different from other image converters, users do not need to load Adobe Acrobat or any other print drivers when they use DICOM to PDF Converter.
add a jpg to a pdf; add image to pdf preview
Chapter 38. The Rule System
38.4. Rules on
INSERT
,
UPDATE
,and
DELETE
Rules thatare definedon
INSERT
,
UPDATE
,and
DELETE
are significantlydifferentfrom the viewrules
described in the previous section. First, their
CREATE RULE
command allows more:
They are allowed to have no action.
They can have multiple actions.
They can be
INSTEAD
or
ALSO
(the default).
The pseudorelations
NEW
and
OLD
become useful.
They can have rule qualifications.
Second, they don’t modify the query tree in place. Instead they create zero or more new query trees
and can throw away the original one.
38.4.1. How Update Rules Work
Keep the syntax:
CREATE [ OR REPLACE ] RULE
name
AS ON
event
TO
table
[ WHERE
condition
]
DO [ ALSO | INSTEAD ] { NOTHING |
command
| (
command
;
command
... ) }
in mind. In the following, update rules means rules that are defined on
INSERT
,
UPDATE
,or
DELETE
.
Update rules get appliedby the rule system when the result relation and the command type of a query
tree are equal tothe object and event given in the
CREATE RULE
command. For update rules, the rule
system creates a list of query trees. Initially the query-tree list is empty. There can be zero (
NOTHING
key word), one, or multiple actions. To simplify, we will look at a rule with one action. This rule can
have a qualification or not andit can be
INSTEAD
or
ALSO
(the default).
What is arule qualification? Itis a restrictionthat tells when the actions of the rule should bedone and
when not. This qualification can only reference the pseudorelations
NEW
and/or
OLD
,which basically
represent the relation that was given as object (but with a special meaning).
So we have three cases that produce the following query trees for a one-action rule.
No qualification, with either
ALSO
or
INSTEAD
the query tree from the rule action with the original querytree’s qualification added
Qualification given and
ALSO
the query tree from the rule action with the rule qualification and the original query tree’s quali-
fication added
Qualification given and
INSTEAD
the query tree from the rule action with the rule qualification and the original query tree’s quali-
fication; and the original query tree with the negated rule qualification added
Finally, if the rule is
ALSO
,the unchanged original query tree is added to the list. Since only qualified
INSTEAD
rules already add the original query tree, we end up with either one or two output query
trees for a rule with one action.
For
ON INSERT
rules, the original query (if not suppressed by
INSTEAD
)is done before any actions
added by rules. This allows the actionstoseethe insertedrow(s). Butfor
ON UPDATE
and
ON DELETE
1012
TIFF to PDF Converter | Convert TIFF to PDF, Convert PDF to TIFF
PDF to TIFF Converter doesn't require other third-party such as Adobe Acrobat. PDF to TIFF Converter can create the output TIFF image with 68-1024 dpi.
how to add an image to a pdf in reader; how to add a picture to a pdf file
Chapter 38. The Rule System
rules, the original queryis done after the actions added by rules. This ensures that the actions can see
the to-be-updated or to-be-deleted rows; otherwise, the actions might do nothing because they find no
rows matching their qualifications.
The querytrees generatedfrom rule actions are throwninto the rewrite system again, and maybe more
rules get applied resulting in more or less query trees. So a rule’s actions must have either a different
command type or a different result relation than the rule itself is on, otherwise this recursive process
will end up in an infinite loop. (Recursive expansion of a rule will be detected and reported as an
error.)
The query trees found in the actions of the
pg_rewrite
system catalog are only templates. Since
they canreference the range-table entries for
NEW
and
OLD
,some substitutions have to bemade before
they can be used. For any reference to
NEW
,the target list of the original query is searched for a
corresponding entry. If found, that entry’s expression replaces the reference. Otherwise,
NEW
means
the same as
OLD
(for an
UPDATE
)or is replaced bya null value (for an
INSERT
). Any reference to
OLD
is replaced bya reference to the range-table entry that is the result relation.
After the system is done applying update rules, it applies view rules to the produced query tree(s).
Views cannot insert newupdate actions so there is no need toapply update rules to the outputof view
rewriting.
38.4.1.1. A First Rule Step by Step
Say we want to trace changes to the
sl_avail
column in the
shoelace_data
relation. So we set
up a log table and a rule that conditionally writes a log entry when an
UPDATE
is performed on
shoelace_data
.
CREATE TABLE shoelace_log (
sl_name
text,
-- shoelace changed
sl_avail
integer,
-- new available value
log_who
text,
-- who did it
log_when
timestamp
-- when
);
CREATE RULE log_shoelace AS ON UPDATE TO shoelace_data
WHERE NEW.sl_avail <> OLD.sl_avail
DO INSERT INTO shoelace_log VALUES (
NEW.sl_name,
NEW.sl_avail,
current_user,
current_timestamp
);
Now someone does:
UPDATE shoelace_data SET sl_avail = 6 WHERE sl_name = ’sl7’;
and we look at the log table:
SELECT
*
FROM shoelace_log;
sl_name | sl_avail | log_who | log_when
---------+----------+---------+----------------------------------
sl7
|
6 | Al
| Tue Oct 20 16:14:45 1998 MET DST
(1 row)
1013
Chapter 38. The Rule System
That’s what we expected. What happened in the background is the following. The parser created the
query tree:
UPDATE shoelace_data SET sl_avail = 6
FROM shoelace_data shoelace_data
WHERE shoelace_data.sl_name = ’sl7’;
There is a rule
log_shoelace
that is
ON UPDATE
with the rule qualification expression:
NEW.sl_avail <> OLD.sl_avail
and the action:
INSERT INTO shoelace_log VALUES (
new.sl_name, new.sl_avail,
current_user, current_timestamp )
FROM shoelace_data new, shoelace_data old;
(This looks a little strange since you cannot normally write
INSERT ... VALUES ... FROM
.The
FROM
clause here is just to indicate that there are range-table entries inthequery treefor
new
and
old
.
These are needed so that they can be referenced by variables inthe
INSERT
command’s query tree.)
The rule is a qualified
ALSO
rule, so the rule system has to return two query trees: the modified rule
action and the original query tree. In step 1, the range table of the original query is incorporated into
the rule’s action query tree. This results in:
INSERT INTO shoelace_log VALUES (
new.sl_name, new.sl_avail,
current_user, current_timestamp )
FROM shoelace_data new, shoelace_data old,
shoelace_data shoelace_data;
In step 2, the rule qualification is added to it, so the result set is restricted to rows where
sl_avail
changes:
INSERT INTO shoelace_log VALUES (
new.sl_name, new.sl_avail,
current_user, current_timestamp )
FROM shoelace_data new, shoelace_data old,
shoelace_data shoelace_data
WHERE new.sl_avail <> old.sl_avail;
(This looks even stranger, since
INSERT ... VALUES
doesn’t have a
WHERE
clause either, but the
planner and executor will have no difficulty with it. They need to support this same functionality
anyway for
INSERT ... SELECT
.)
In step 3, the original query tree’s qualification is added, restricting the result set further to only the
rows that would have been touched by the original query:
INSERT INTO shoelace_log VALUES (
new.sl_name, new.sl_avail,
current_user, current_timestamp )
FROM shoelace_data new, shoelace_data old,
shoelace_data shoelace_data
WHERE new.sl_avail <> old.sl_avail
AND shoelace_data.sl_name = ’sl7’;
1014
Chapter 38. The Rule System
Step 4 replaces references to
NEW
by the target list entries from the original query tree or by the
matching variable references from the result relation:
INSERT INTO shoelace_log VALUES (
shoelace_data.sl_name, 6,
current_user, current_timestamp )
FROM shoelace_data new, shoelace_data old,
shoelace_data shoelace_data
WHERE 6 <> old.sl_avail
AND shoelace_data.sl_name = ’sl7’;
Step 5 changes
OLD
references into result relation references:
INSERT INTO shoelace_log VALUES (
shoelace_data.sl_name, 6,
current_user, current_timestamp )
FROM shoelace_data new, shoelace_data old,
shoelace_data shoelace_data
WHERE 6 <> shoelace_data.sl_avail
AND shoelace_data.sl_name = ’sl7’;
That’s it. Since the rule is
ALSO
,we also output the original query tree. In short, the output from the
rule system is a list of two query trees that correspond to these statements:
INSERT INTO shoelace_log VALUES (
shoelace_data.sl_name, 6,
current_user, current_timestamp )
FROM shoelace_data
WHERE 6 <> shoelace_data.sl_avail
AND shoelace_data.sl_name = ’sl7’;
UPDATE shoelace_data SET sl_avail = 6
WHERE sl_name = ’sl7’;
These are executed in this order, and that is exactly what the rule was meant to do.
The substitutions and the added qualifications ensure that, if the original query would be, say:
UPDATE shoelace_data SET sl_color = ’green’
WHERE sl_name = ’sl7’;
no log entry would get written. In that case, the original query tree does not contain a target list entry
for
sl_avail
,so
NEW.sl_avail
will getreplacedby
shoelace_data.sl_avail
.Thus, the extra
command generated by the rule is:
INSERT INTO shoelace_log VALUES (
shoelace_data.sl_name, shoelace_data.sl_avail,
current_user, current_timestamp )
FROM shoelace_data
WHERE shoelace_data.sl_avail <> shoelace_data.sl_avail
AND shoelace_data.sl_name = ’sl7’;
and that qualification will never be true.
1015
Chapter 38. The Rule System
It will also work if the original query modifies multiple rows. So if someone issued the command:
UPDATE shoelace_data SET sl_avail = 0
WHERE sl_color = ’black’;
four rows in fact get updated (
sl1
,
sl2
,
sl3
,and
sl4
). But
sl3
already has
sl_avail = 0
.In this
case, the original query trees qualification is different and that results in the extra query tree:
INSERT INTO shoelace_log
SELECT shoelace_data.sl_name, 0,
current_user, current_timestamp
FROM shoelace_data
WHERE 0 <> shoelace_data.sl_avail
AND shoelace_data.sl_color = ’black’;
being generated by the rule. This query tree will surely insert three new log entries. And that’s abso-
lutely correct.
Here we can see why it is important that the original query tree is executed last. If the
UPDATE
had
been executed first, all the rows would have already been set to zero, so the logging
INSERT
would
not find any row where
0 <> shoelace_data.sl_avail
.
38.4.2. Cooperation with Views
Asimple way to protect view relations from the mentioned possibility that someone can try to run
INSERT
,
UPDATE
,or
DELETE
on them is to let those query trees get thrown away. So we could create
the rules:
CREATE RULE shoe_ins_protect AS ON INSERT TO shoe
DO INSTEAD NOTHING;
CREATE RULE shoe_upd_protect AS ON UPDATE TO shoe
DO INSTEAD NOTHING;
CREATE RULE shoe_del_protect AS ON DELETE TO shoe
DO INSTEAD NOTHING;
If someone now tries to do any of these operations on the view relation
shoe
,the rule system will
apply these rules. Since the rules have no actions and are
INSTEAD
,the resulting list of query trees
will be empty and the whole query will become nothing because there is nothing left to be optimized
or executed after the rule system is done with it.
Amore sophisticated way to use the rule system is to create rules that rewrite the query tree into
one that does the right operation on the real tables. To do that on the
shoelace
view, we create the
following rules:
CREATE RULE shoelace_ins AS ON INSERT TO shoelace
DO INSTEAD
INSERT INTO shoelace_data VALUES (
NEW.sl_name,
NEW.sl_avail,
NEW.sl_color,
NEW.sl_len,
NEW.sl_unit
);
CREATE RULE shoelace_upd AS ON UPDATE TO shoelace
1016
Chapter 38. The Rule System
DO INSTEAD
UPDATE shoelace_data
SET sl_name = NEW.sl_name,
sl_avail = NEW.sl_avail,
sl_color = NEW.sl_color,
sl_len = NEW.sl_len,
sl_unit = NEW.sl_unit
WHERE sl_name = OLD.sl_name;
CREATE RULE shoelace_del AS ON DELETE TO shoelace
DO INSTEAD
DELETE FROM shoelace_data
WHERE sl_name = OLD.sl_name;
If you want to support
RETURNING
queries on the view, you need to make the rules include
RETURNING
clauses that compute the view rows. This is usually pretty trivial for views on a single
table, but it’s a bit tedious for join views such as
shoelace
.An example for the insert case is:
CREATE RULE shoelace_ins AS ON INSERT TO shoelace
DO INSTEAD
INSERT INTO shoelace_data VALUES (
NEW.sl_name,
NEW.sl_avail,
NEW.sl_color,
NEW.sl_len,
NEW.sl_unit
)
RETURNING
shoelace_data.
*
,
(SELECT shoelace_data.sl_len
*
u.un_fact
FROM unit u WHERE shoelace_data.sl_unit = u.un_name);
Note that this one rule supports both
INSERT
and
INSERT RETURNING
queries on the view — the
RETURNING
clause is simplyignored for
INSERT
.
Now assume that once in a while, a pack of shoelaces arrives at the shop and a big parts list along
with it. But you don’t want to manually update the
shoelace
view every time. Instead we setup two
little tables: one where you can insert the items from the part list, and one with a special trick. The
creation commands for these are:
CREATE TABLE shoelace_arrive (
arr_name
text,
arr_quant
integer
);
CREATE TABLE shoelace_ok (
ok_name
text,
ok_quant
integer
);
CREATE RULE shoelace_ok_ins AS ON INSERT TO shoelace_ok
DO INSTEAD
UPDATE shoelace
SET sl_avail = sl_avail + NEW.ok_quant
WHERE sl_name = NEW.ok_name;
1017
Documents you may be interested
Documents you may be interested