pdf viewer dll for c# : Add photo to pdf form SDK control project winforms web page azure UWP postgresql-9.4-A4107-part2732

Chapter 37. Event Triggers
If this returns true, then it is safe to cast
fcinfo->context
to type
EventTriggerData
*
and make use of the pointed-to
EventTriggerData
structure. The function must not alter the
EventTriggerData
structure or any of the data it points to.
struct EventTriggerData
is defined in
commands/event_trigger.h
:
typedef struct EventTriggerData
{
NodeTag
type;
const char
*
event;
/
*
event name
*
/
Node
*
parsetree;
/
*
parse tree
*
/
const char
*
tag;
/
*
command tag
*
/
} EventTriggerData;
where the members are defined as follows:
type
Always
T_EventTriggerData
.
event
Describes the event for which the function is called, one of
"ddl_command_start"
,
"ddl_command_end"
,
"sql_drop"
.See Section 37.1 for the meaning of these events.
parsetree
Apointer to the parse tree of the command. Check the PostgreSQL source code for details. The
parse tree structure is subject to change without notice.
tag
The command tag associated with the event for which the event trigger is run, for example
"CREATE FUNCTION"
.
Aneventtrigger functionmust returna
NULL
pointer (notanSQL nullvalue, thatis, donot set
isNull
true).
37.4. A Complete Event Trigger Example
Here is a very simple example of anevent trigger function written in C. (Examples of triggers written
in procedural languages can be found in the documentation of the procedural languages.)
The function
noddl
raises an exception each time it is called. The event trigger definition associated
the function with the
ddl_command_start
event. The effect is that all DDL commands (with the
exceptions mentioned in Section 37.1) are prevented from running.
This is the source code of the trigger function:
#include "postgres.h"
#include "commands/event_trigger.h"
PG_MODULE_MAGIC;
Datum noddl(PG_FUNCTION_ARGS);
998
Add photo to pdf form - 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
add a picture to a pdf document; adding a png to a pdf
Add photo to pdf form - 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
adding an image to a pdf form; how to add a jpg to a pdf
Chapter 37. Event Triggers
PG_FUNCTION_INFO_V1(noddl);
Datum
noddl(PG_FUNCTION_ARGS)
{
EventTriggerData
*
trigdata;
if (!CALLED_AS_EVENT_TRIGGER(fcinfo))
/
*
internal error
*
/
elog(ERROR, "not fired by event trigger manager");
trigdata = (EventTriggerData
*
) fcinfo->context;
ereport(ERROR,
(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
errmsg("command \"%s\" denied", trigdata->tag)));
PG_RETURN_NULL();
}
After you have compiled the source code (see Section 35.9.6), declare the function and the triggers:
CREATE FUNCTION noddl() RETURNS event_trigger
AS ’noddl’ LANGUAGE C;
CREATE EVENT TRIGGER noddl ON ddl_command_start
EXECUTE PROCEDURE noddl();
Now you can test the operation of the trigger:
=# \dy
List of event triggers
Name
|
Event
| Owner | Enabled | Procedure | Tags
-------+-------------------+-------+---------+-----------+------
noddl | ddl_command_start | dim
| enabled | noddl
|
(1 row)
=# CREATE TABLE foo(id serial);
ERROR:
command "CREATE TABLE" denied
In this situation, in order to be able to run some DDL commands when you need to do so, you have
to either drop the event trigger or disable it. It can be convenient to disable the trigger for only the
duration of a transaction:
BEGIN;
ALTER EVENT TRIGGER noddl DISABLE;
CREATE TABLE foo (id serial);
ALTER EVENT TRIGGER noddl ENABLE;
COMMIT;
(Recall that DDL commands on event triggers themselves are not affected by event triggers.)
999
VB.NET Image: Mark Photo, Image & Document with Polygon Annotation
on PDF file without using external PDF editing software. VB.NET Methods to Add Polygon Annotation. In this Public Partial Class Form1 Inherits Form Public Sub
add jpg to pdf form; add image pdf
VB.NET Image: Image Cropping SDK to Cut Out Image, Picture and
VB.NET image cropping method to crop picture / photo; size of created cropped image file, add antique effect Public Partial Class Form1 Inherits Form Public Sub
how to add image to pdf document; add image pdf acrobat
Chapter 38. The Rule System
This chapter discusses the rule system in PostgreSQL. Production rule systems are conceptuallysim-
ple, but there are many subtle points involved in actually using them.
Some other database systems define active database rules, which are usually stored procedures and
triggers. In PostgreSQL, these can be implemented using functions and triggers as well.
The rule system (more precisely speaking, the query rewrite rule system) is totally different from
stored procedures and triggers. It modifies queries to take rules into consideration, and then passes
the modified query to the query planner for planning and execution. It is very powerful, and can
be used for many things such as query language procedures, views, and versions. The theoretical
foundations and the power of this rule system are also discussed in On Rules, Procedures, Caching
and Views in Database Systems and A Unified Framework for Version Modeling Using Production
Rules in a Database System.
38.1. The Query Tree
To understandhow the rule system works it is necessaryto know whenit is invokedand whatits input
and results are.
The rule system is located between the parser and the planner. It takes the output of the parser, one
query tree, and the user-defined rewrite rules, which are also query trees with some extra information,
and creates zero or more query trees as result. So its input and output are always things the parser
itself could have produced and thus, anything it sees is basically representable as an SQL statement.
Now what is a query tree? It is an internal representation of an SQL statement where the single
parts that it is built from are stored separately. These query trees can be shown in the server log
if you set the configuration parameters
debug_print_parse
,
debug_print_rewritten
, or
debug_print_plan
. The rule actions are also stored as query trees, in the system catalog
pg_rewrite
. They are not formatted like the log output, but they contain exactly the same
information.
Reading a raw query tree requires some experience. But since SQL representations of querytrees are
sufficient tounderstand the rule system, this chapter will not teach how to read them.
When reading the SQL representations of the query trees in this chapter it is necessary to be able to
identify the parts the statement is broken into when it is in the query tree structure. The parts of a
query tree are
the command type
This is a simple value telling which command (
SELECT
,
INSERT
,
UPDATE
,
DELETE
)produced
the query tree.
the range table
The range table is a list of relations that are used in the query. In a
SELECT
statement these are
the relations given after the
FROM
key word.
Every range table entry identifies a table or view and tells by whichname it is called inthe other
parts of the query. In the query tree, the range table entries are referenced by number rather than
by name, so here it doesn’t matter if there are duplicate names as it would in an SQL statement.
This can happen after the range tables of rules have beenmerged in. The examples in this chapter
will not have this situation.
1000
VB.NET Image: Image Scaling SDK to Scale Picture / Photo
about this VB.NET image scaling control add-on, we RE__Test Public Partial Class Form1 Inherits Form Public Sub can only scale one image / picture / photo at a
add picture to pdf file; acrobat insert image into pdf
VB.NET Image: Image Resizer Control SDK to Resize Picture & Photo
VB.NET Image & Photo Resizing Overview. The practical this VB.NET image resizer control add-on, can powerful & profession imaging controls, PDF document, image
adding an image to a pdf in preview; add jpg to pdf file
Chapter 38. The Rule System
the result relation
This is an index into the range table that identifies the relation where the results of the querygo.
SELECT
queries don’t have aresult relation. (The special case of
SELECT INTO
is mostlyidenti-
calto
CREATE TABLE
followedby
INSERT ... SELECT
,andis not discussed separatelyhere.)
For
INSERT
,
UPDATE
,and
DELETE
commands, the result relation is the table (or view!) where
the changes are to take effect.
the target list
The target list is a list of expressions that define the result of the query. In the case of a
SELECT
,
these expressions are the ones that build the final output of the query. They correspond to the
expressions between the key words
SELECT
and
FROM
.(
*
is just an abbreviation for all the
column names of a relation. It is expanded by the parser into the individual columns, so the rule
system never sees it.)
DELETE
commands don’tneeda normaltarget listbecausetheydon’tproduceanyresult. Instead,
the rule system adds a special CTID entry to the empty target list, to allow the executor to find
the row to be deleted. (CTIDis added when the result relation is anordinarytable. If it is a view,
awhole-row variable is added instead, as described in Section 38.2.4.)
For
INSERT
commands, the target list describes the new rows that should go into the result
relation. It consists of the expressions in the
VALUES
clause or the ones from the
SELECT
clause
in
INSERT ... SELECT
.The first step of the rewrite process adds target list entries for any
columns that were not assigned to by the original command but have defaults. Any remaining
columns (withneither a given value nor a default) willbe filled in by the planner with a constant
null expression.
For
UPDATE
commands, the target list describes the new rows that should replace the old ones.
In the rule system, it contains just the expressions from the
SET column = expression
part
of the command. The planner will handle missing columns by inserting expressions that copy
the values from the old row into the new one. Just as for
DELETE
,the rule system adds a CTID
or whole-row variable so that the executor can identify the old row to be updated.
Every entry in the target list contains an expression that can be a constant value, a variable
pointingto a column of one of the relations in the range table, a parameter, or an expression tree
made of function calls, constants, variables, operators, etc.
the qualification
The query’s qualification is an expression much like one of those contained in the target list
entries. The result value of this expression is a Booleanthattells whether the operation(
INSERT
,
UPDATE
,
DELETE
,or
SELECT
)for the final result row should be executed or not. It corresponds
to the
WHERE
clause of an SQL statement.
the join tree
The query’s join tree shows the structure of the
FROM
clause. For a simple query like
SELECT
... FROM a, b, c
,the join tree is just a list of the
FROM
items, because we are allowed to
join them in any order. But when
JOIN
expressions, particularly outer joins, are used, we have
to join in the order shown by the joins. In that case, the join tree shows the structure of the
JOIN
expressions. The restrictions associated with particular
JOIN
clauses (from
ON
or
USING
expressions) are storedas qualification expressions attached to those join-tree nodes. It turns out
to be convenient to store the top-level
WHERE
expression as a qualification attached to the top-
level join-tree item, too. So really the join tree represents both the
FROM
and
WHERE
clauses of a
SELECT
.
1001
VB.NET Image: How to Save Image & Print Image Using VB.NET
of saving and printing multi-page document files, like PDF and Word printing assembly with VB.NET web image viewer add-on, you VB.NET Code to Save Image / Photo.
add image to pdf acrobat reader; add jpg to pdf preview
C# Image: How to Add Antique & Vintage Effect to Image, Photo
this C#.NET antique effect creating control add-on is widely used in modern photo editors, which powerful & profession imaging controls, PDF document, tiff
add picture to pdf preview; adding an image to a pdf in acrobat
Chapter 38. The Rule System
the others
Theother parts of the query treelike the
ORDER BY
clause aren’tof interest here. The rulesystem
substitutes some entries there while applying rules, but that doesn’t have much to do with the
fundamentals of the rule system.
38.2. Views and the Rule System
Views inPostgreSQL areimplemented usingtherule system. Infact, there is essentiallyno difference
between:
CREATE VIEW myview AS SELECT
*
FROM mytab;
compared against the two commands:
CREATE TABLE myview (
same column list as mytab
);
CREATE RULE "_RETURN" AS ON SELECT TO myview DO INSTEAD
SELECT
*
FROM mytab;
because this is exactly what the
CREATE VIEW
command does internally. This has some side effects.
One of them is that the information about a view in the PostgreSQL system catalogs is exactly the
same as itis for a table. So for the parser, there is absolutely nodifference betweena table anda view.
They are the same thing: relations.
38.2.1. How
SELECT
Rules Work
Rules
ON SELECT
are applied to all queries as the last step, evenif the command givenis an
INSERT
,
UPDATE
or
DELETE
.And theyhave differentsemantics from rules on the other command types inthat
they modifythe query tree inplace instead of creating a new one. So
SELECT
rules are described first.
Currently, there can be onlyone actioninan
ON SELECT
rule, and it mustbeanunconditional
SELECT
action that is
INSTEAD
.This restriction was required to make rules safe enough to open them for
ordinary users, and it restricts
ON SELECT
rules to act like views.
The examplesfor thischapter are twojoin views that do somecalculationsandsome more views using
them in turn. One of the two first views is customized later by adding rules for
INSERT
,
UPDATE
,and
DELETE
operations sothat the finalresult willbe aview thatbehaves like a real tablewith some magic
functionality. This is not sucha simple example to start from and this makes things harder to get into.
But it’s better to have one example that covers all the points discussed step by step rather than having
many different ones that might mix up in mind.
For the example, we need a little
min
function that returns the lower of 2 integer values. We create
that as:
CREATE FUNCTION min(integer, integer) RETURNS integer AS $$
SELECT CASE WHEN $1 < $2 THEN $1 ELSE $2 END
$$ LANGUAGE SQL STRICT;
The real tables we need in the first two rule system descriptions are these:
CREATE TABLE shoe_data (
shoename
text,
-- primary key
1002
VB.NET Image: Tutorial for Flipping Image Using Our .NET Image SDK
version of .NET imaging SDK and add the following becomes a mirror reflection of the photo on the powerful & profession imaging controls, PDF document, tiff
add an image to a pdf in preview; how to add image to pdf file
C# PDF remove image library: remove, delete images from PDF in C#.
Highlight Text. Add Text. Add Text Box. Drawing vector image, graphic picture, digital photo, scanned signature and remove multiple or all images from PDF document
adding image to pdf form; add a picture to a pdf
Chapter 38. The Rule System
sh_avail
integer,
-- available number of pairs
slcolor
text,
-- preferred shoelace color
slminlen
real,
-- minimum shoelace length
slmaxlen
real,
-- maximum shoelace length
slunit
text
-- length unit
);
CREATE TABLE shoelace_data (
sl_name
text,
-- primary key
sl_avail
integer,
-- available number of pairs
sl_color
text,
-- shoelace color
sl_len
real,
-- shoelace length
sl_unit
text
-- length unit
);
CREATE TABLE unit (
un_name
text,
-- primary key
un_fact
real
-- factor to transform to cm
);
As you cansee, they represent shoe-store data.
The views are created as:
CREATE VIEW shoe AS
SELECT sh.shoename,
sh.sh_avail,
sh.slcolor,
sh.slminlen,
sh.slminlen
*
un.un_fact AS slminlen_cm,
sh.slmaxlen,
sh.slmaxlen
*
un.un_fact AS slmaxlen_cm,
sh.slunit
FROM shoe_data sh, unit un
WHERE sh.slunit = un.un_name;
CREATE VIEW shoelace AS
SELECT s.sl_name,
s.sl_avail,
s.sl_color,
s.sl_len,
s.sl_unit,
s.sl_len
*
u.un_fact AS sl_len_cm
FROM shoelace_data s, unit u
WHERE s.sl_unit = u.un_name;
CREATE VIEW shoe_ready AS
SELECT rsh.shoename,
rsh.sh_avail,
rsl.sl_name,
rsl.sl_avail,
min(rsh.sh_avail, rsl.sl_avail) AS total_avail
FROM shoe rsh, shoelace rsl
WHERE rsl.sl_color = rsh.slcolor
AND rsl.sl_len_cm >= rsh.slminlen_cm
AND rsl.sl_len_cm <= rsh.slmaxlen_cm;
1003
Chapter 38. The Rule System
The
CREATE VIEW
command for the
shoelace
view (which is the simplest one we have) willcreate
arelation
shoelace
and an entry in
pg_rewrite
that tells that there is a rewrite rule that must be
applied whenever the relation
shoelace
is referenced in a query’s range table. The rule has no rule
qualification (discussed later, with the non-
SELECT
rules, since
SELECT
rules currently cannot have
them) and it is
INSTEAD
.Note that rule qualifications are not the same as query qualifications. The
action of our rule has a query qualification. The action of the rule is one query tree that is a copy of
the
SELECT
statement in the view creation command.
Note: The two extra rangetable entries for
NEW
and
OLD
that you cansee in the
pg_rewrite
entry
aren’t of interest for
SELECT
rules.
Now we populate
unit
,
shoe_data
and
shoelace_data
and run a simple query on a view:
INSERT INTO unit VALUES (’cm’, 1.0);
INSERT INTO unit VALUES (’m’, 100.0);
INSERT INTO unit VALUES (’inch’, 2.54);
INSERT INTO shoe_data VALUES (’sh1’, 2, ’black’, 70.0, 90.0, ’cm’);
INSERT INTO shoe_data VALUES (’sh2’, 0, ’black’, 30.0, 40.0, ’inch’);
INSERT INTO shoe_data VALUES (’sh3’, 4, ’brown’, 50.0, 65.0, ’cm’);
INSERT INTO shoe_data VALUES (’sh4’, 3, ’brown’, 40.0, 50.0, ’inch’);
INSERT INTO shoelace_data VALUES (’sl1’, 5, ’black’, 80.0, ’cm’);
INSERT INTO shoelace_data VALUES (’sl2’, 6, ’black’, 100.0, ’cm’);
INSERT INTO shoelace_data VALUES (’sl3’, 0, ’black’, 35.0 , ’inch’);
INSERT INTO shoelace_data VALUES (’sl4’, 8, ’black’, 40.0 , ’inch’);
INSERT INTO shoelace_data VALUES (’sl5’, 4, ’brown’, 1.0 , ’m’);
INSERT INTO shoelace_data VALUES (’sl6’, 0, ’brown’, 0.9 , ’m’);
INSERT INTO shoelace_data VALUES (’sl7’, 7, ’brown’, 60 , ’cm’);
INSERT INTO shoelace_data VALUES (’sl8’, 1, ’brown’, 40 , ’inch’);
SELECT
*
FROM shoelace;
sl_name
| sl_avail | sl_color | sl_len | sl_unit | sl_len_cm
-----------+----------+----------+--------+---------+-----------
sl1
|
5 | black
|
80 | cm
|
80
sl2
|
6 | black
|
100 | cm
|
100
sl7
|
7 | brown
|
60 | cm
|
60
sl3
|
0 | black
|
35 | inch
|
88.9
sl4
|
8 | black
|
40 | inch
|
101.6
sl8
|
1 | brown
|
40 | inch
|
101.6
sl5
|
4 | brown
|
1 | m
|
100
sl6
|
0 | brown
|
0.9 | m
|
90
(8 rows)
This is the simplest
SELECT
you can doonour views, sowe take this opportunity to explain the basics
of view rules. The
SELECT
*
FROM shoelace
was interpretedbytheparser and produced the query
tree:
SELECT shoelace.sl_name, shoelace.sl_avail,
shoelace.sl_color, shoelace.sl_len,
shoelace.sl_unit, shoelace.sl_len_cm
FROM shoelace shoelace;
1004
Chapter 38. The Rule System
and this is given to the rule system. The rule system walks through the range table and checks if there
are rules for any relation. When processing the range table entry for
shoelace
(the only one up to
now) it finds the
_RETURN
rule with the query tree:
SELECT s.sl_name, s.sl_avail,
s.sl_color, s.sl_len, s.sl_unit,
s.sl_len
*
u.un_fact AS sl_len_cm
FROM shoelace old, shoelace new,
shoelace_data s, unit u
WHERE s.sl_unit = u.un_name;
To expand the view, the rewriter simply creates a subquery range-table entry containing the rule’s
action query tree, and substitutes this range table entry for the original one that referenced the view.
The resulting rewritten query tree is almost the same as if you had typed:
SELECT shoelace.sl_name, shoelace.sl_avail,
shoelace.sl_color, shoelace.sl_len,
shoelace.sl_unit, shoelace.sl_len_cm
FROM (SELECT s.sl_name,
s.sl_avail,
s.sl_color,
s.sl_len,
s.sl_unit,
s.sl_len
*
u.un_fact AS sl_len_cm
FROM shoelace_data s, unit u
WHERE s.sl_unit = u.un_name) shoelace;
There is one difference however: the subquery’s range table has two extra entries
shoelace old
and
shoelace new
.These entries don’t participate directly inthequery, since theyaren’t referenced
by the subquery’s join tree or target list. The rewriter uses them to store the access privilege check
information that was originally present in the range-table entry that referenced the view. In this way,
the executor will stillcheck that the user has proper privileges to access the view, even though there’s
no direct use of the view in the rewritten query.
That was the first rule applied. The rule system will continue checking the remaining range-table
entries in the top query (in this example there are no more), and it will recursively check the range-
table entries in the added subquery to see if any of them reference views. (But it won’t expand
old
or
new
—otherwise we’d have infinite recursion!) In this example, there are no rewrite rules for
shoelace_data
or
unit
,so rewriting is complete and the above is the final result given to the
planner.
Now we want to write a query that finds out for which shoes currently in the store we have the
matching shoelaces (color and length) andwhere the totalnumber of exactlymatching pairs is greater
or equal to two.
SELECT
*
FROM shoe_ready WHERE total_avail >= 2;
shoename | sh_avail | sl_name | sl_avail | total_avail
----------+----------+---------+----------+-------------
sh1
|
2 | sl1
|
5 |
2
sh3
|
4 | sl7
|
7 |
4
(2 rows)
The output of the parser this time is the query tree:
1005
Chapter 38. The Rule System
SELECT shoe_ready.shoename, shoe_ready.sh_avail,
shoe_ready.sl_name, shoe_ready.sl_avail,
shoe_ready.total_avail
FROM shoe_ready shoe_ready
WHERE shoe_ready.total_avail >= 2;
The first rule applied will be the one for the
shoe_ready
view and it results in the query tree:
SELECT shoe_ready.shoename, shoe_ready.sh_avail,
shoe_ready.sl_name, shoe_ready.sl_avail,
shoe_ready.total_avail
FROM (SELECT rsh.shoename,
rsh.sh_avail,
rsl.sl_name,
rsl.sl_avail,
min(rsh.sh_avail, rsl.sl_avail) AS total_avail
FROM shoe rsh, shoelace rsl
WHERE rsl.sl_color = rsh.slcolor
AND rsl.sl_len_cm >= rsh.slminlen_cm
AND rsl.sl_len_cm <= rsh.slmaxlen_cm) shoe_ready
WHERE shoe_ready.total_avail >= 2;
Similarly, the rules for
shoe
and
shoelace
are substituted into the range table of the subquery,
leading toa three-level final query tree:
SELECT shoe_ready.shoename, shoe_ready.sh_avail,
shoe_ready.sl_name, shoe_ready.sl_avail,
shoe_ready.total_avail
FROM (SELECT rsh.shoename,
rsh.sh_avail,
rsl.sl_name,
rsl.sl_avail,
min(rsh.sh_avail, rsl.sl_avail) AS total_avail
FROM (SELECT sh.shoename,
sh.sh_avail,
sh.slcolor,
sh.slminlen,
sh.slminlen
*
un.un_fact AS slminlen_cm,
sh.slmaxlen,
sh.slmaxlen
*
un.un_fact AS slmaxlen_cm,
sh.slunit
FROM shoe_data sh, unit un
WHERE sh.slunit = un.un_name) rsh,
(SELECT s.sl_name,
s.sl_avail,
s.sl_color,
s.sl_len,
s.sl_unit,
s.sl_len
*
u.un_fact AS sl_len_cm
FROM shoelace_data s, unit u
WHERE s.sl_unit = u.un_name) rsl
WHERE rsl.sl_color = rsh.slcolor
AND rsl.sl_len_cm >= rsh.slminlen_cm
AND rsl.sl_len_cm <= rsh.slmaxlen_cm) shoe_ready
WHERE shoe_ready.total_avail > 2;
1006
Chapter 38. The Rule System
It turns out that the planner will collapse this tree into a two-level query tree: the bottommost
SELECT
commands will be “pulled up” into the middle
SELECT
since there’s no need to process them sep-
arately. But the middle
SELECT
will remain separate from the top, because it contains aggregate
functions. If we pulled those up it would change the behavior of the topmost
SELECT
,which we don’t
want. However, collapsing the query tree is an optimization that the rewrite system doesn’t have to
concern itself with.
38.2.2. View Rules in Non-
SELECT
Statements
Two details of the query tree aren’t touched in the description of view rules above. These are the
command type and the result relation. In fact, the command type is not needed by view rules, but the
result relation may affect the wayin which the queryrewriter works, because specialcare needs to be
taken if the result relation is a view.
There are only a few differences between a query tree for a
SELECT
and one for any other command.
Obviously, they have a different command type and for a command other than a
SELECT
,the result
relation points to the range-table entry where the result should go. Everything else is absolutely the
same. So having two tables
t1
and
t2
with columns
a
and
b
,the query trees for the two statements:
SELECT t2.b FROM t1, t2 WHERE t1.a = t2.a;
UPDATE t1 SET b = t2.b FROM t2 WHERE t1.a = t2.a;
are nearly identical. In particular:
The range tables contain entries for the tables
t1
and
t2
.
The target lists contain one variable that points to column
b
of the range table entry for table
t2
.
The qualification expressions compare the columns
a
of both range-table entries for equality.
The join trees show a simple join between
t1
and
t2
.
The consequence is, that both query trees result in similar execution plans: They are both joins over
the twotables. For the
UPDATE
the missing columns from
t1
are added to the target list bythe planner
and the final query tree will read as:
UPDATE t1 SET a = t1.a, b = t2.b FROM t2 WHERE t1.a = t2.a;
and thus the executor run over the join will produce exactly the same result set as:
SELECT t1.a, t2.b FROM t1, t2 WHERE t1.a = t2.a;
But there is a little problem in
UPDATE
:the part of the executor plan that does the join does not care
what the results from the join are meant for. It just produces a result set of rows. The fact that one is
a
SELECT
command and the other is an
UPDATE
is handled higher upin the executor, where it knows
that this is an
UPDATE
,and it knows that this result should go into table
t1
.But which of the rows
that are there has to be replaced by the new row?
To resolve this problem, another entry is added to the target list in
UPDATE
(and also in
DELETE
)
statements: the current tuple ID (CTID). This is a system column containing the file block number
and position in the block for the row. Knowing the table, the CTIDcan be used toretrievethe original
row of
t1
to be updated. After adding the CTID to the target list, the query actually looks like:
1007
Documents you may be interested
Documents you may be interested