pdf viewer for asp.net web application : How to add picture to pdf SDK control service wpf web page asp.net dnn postgresql-9.4-A4204-part2840

Chapter 58. GIN Indexes
the key sorting order determined by the
compare
support method). The
extractQuery
method,
instead of returning a key value to be matched exactly, returns a key value that is the lower bound
of the range to be searched, and sets the
pmatch
flag true. The key range is then scanned using the
comparePartial
method.
comparePartial
must return zero for a matching index key, less than
zero for a non-match that is still within the range to be searched, or greater than zero if the index key
is past the range that could match.
58.5. GIN Tips and Tricks
Create vs. insert
Insertion into a GIN index can be slow due to the likelihood of many keys being inserted for
each item. So, for bulk insertions into a table it is advisable to drop the GIN index and recreate
it after finishing bulk insertion.
As of PostgreSQL 8.4, this advice is less necessary since delayed indexing is used (see Section
58.4.1for details). But for very large updates it may still be best to drop and recreate the index.
maintenance_work_mem
Build time for a GIN index is very sensitive to the
maintenance_work_mem
setting; it doesn’t
payto skimp on work memory during index creation.
work_mem
During a series of insertions into an existing GIN index that has
FASTUPDATE
enabled, the
system will clean up the pending-entry list whenever the list grows larger than
work_mem
.To
avoid fluctuations in observed response time, it’s desirable to have pending-list cleanup occur
in the background (i.e., via autovacuum). Foreground cleanup operations can be avoided by
increasing
work_mem
or making autovacuum more aggressive. However, enlarging
work_mem
means that if a foreground cleanup does occur, it will take even longer.
gin_fuzzy_search_limit
The primary goal of developing GIN indexes was to create support for highly scalable full-text
search in PostgreSQL, and there are often situations when a full-text search returns a very large
set of results. Moreover, this oftenhappens when the querycontains veryfrequent words, so that
the large result set is not even useful. Since reading many tuples from the disk and sorting them
could take a lot of time, this is unacceptable for production. (Note that the index search itself is
very fast.)
To facilitate controlled execution of such queries, GIN has a configurable soft upper limit on the
number of rows returned: the
gin_fuzzy_search_limit
configuration parameter. It is set to
0(meaning no limit) by default. If a non-zero limit is set, then the returned set is a subset of the
whole result set, chosen at random.
“Soft” means that the actualnumber of returnedresults coulddiffer somewhat from the specified
limit, depending on the query and the quality of the system’s random number generator.
From experience, values in the thousands (e.g., 5000 — 20000) work well.
1968
How to add picture to pdf - 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 photo to pdf in preview; add image to pdf
How to add picture to pdf - 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
how to add an image to a pdf; how to add a jpeg to a pdf
Chapter 58. GIN Indexes
58.6. Limitations
GIN assumes that indexable operators are strict. This means that
extractValue
will not be called
at all on a null item value (instead, a placeholder index entry is created automatically), and
extractQuery
will not be called on a null query value either (instead, the query is presumed to be
unsatisfiable). Note however that null key values contained within a non-null composite item or
query value are supported.
58.7. Examples
The PostgreSQL source distribution includes GIN operator classes for
tsvector
and for
one-dimensional arrays of all internal types. Prefix searching in
tsvector
is implemented using the
GIN partial match feature. The following
contrib
modules also contain GINoperator classes:
btree_gin
B-tree equivalent functionality for several data types
hstore
Module for storing (key, value) pairs
intarray
Enhanced support for
int[]
pg_trgm
Text similarity using trigram matching
1969
C# TIFF: How to Insert & Burn Picture/Image into TIFF Document
Support adding image or picture to an existing or new new REImage(@"c:\ logo.png"); // add the image powerful & profession imaging controls, PDF document, tiff
add image to pdf file; pdf insert image
VB.NET Image: Image Cropping SDK to Cut Out Image, Picture and
VB.NET image cropper control SDK; VB.NET image cropping method to crop picture / photo; you can adjust the size of created cropped image file, add antique effect
add image to pdf acrobat reader; add a jpeg to a pdf
Chapter 59. Database Physical Storage
This chapter provides anoverview of the physical storage format used by PostgreSQL databases.
59.1. Database File Layout
This section describes the storage format at the level of files and directories.
Traditionally, the configuration anddata files usedby a database cluster are stored together within the
cluster’s data directory, commonly referred to as
PGDATA
(after the name of the environment variable
that can be used to define it). A common location for
PGDATA
is
/var/lib/pgsql/data
.Multiple
clusters, managed by different server instances, can exist on the same machine.
The
PGDATA
directory contains severalsubdirectories andcontrol files, as shown inTable 59-1. In ad-
ditionto these required items, the cluster configurationfiles
postgresql.conf
,
pg_hba.conf
,and
pg_ident.conf
are traditionally stored in
PGDATA
,although it is possible to place them elsewhere.
Table 59-1. Contents of
PGDATA
Item
Description
PG_VERSION
Afile containing the major version number of
PostgreSQL
base
Subdirectory containing per-database
subdirectories
global
Subdirectory containing cluster-wide tables,
such as
pg_database
pg_clog
Subdirectory containing transaction commit
status data
pg_dynshmem
Subdirectory containing files used by the
dynamic shared memory subsystem
pg_logical
Subdirectory containing status data for logical
decoding
pg_multixact
Subdirectory containing multitransaction status
data (used for shared row locks)
pg_notify
Subdirectory containing LISTEN/NOTIFY
status data
pg_replslot
Subdirectory containing replication slot data
pg_serial
Subdirectory containing information about
committed serializable transactions
pg_snapshots
Subdirectory containing exported snapshots
pg_stat
Subdirectory containing permanent files for the
statistics subsystem
pg_stat_tmp
Subdirectory containing temporary files for the
statistics subsystem
1970
VB.NET TIFF: How to Draw Picture & Write Text on TIFF Document in
drawing As RaterEdgeDrawing = New RaterEdgeDrawing() drawing.Picture = "RasterEdge" drawing provide powerful & profession imaging controls, PDF document, tiff
add image field to pdf form; add multiple jpg to pdf
VB.NET Image: VB.NET Codes to Add Antique Effect to Image with .
mature technology to replace a picture's original colors add the glow and noise, and add a little powerful & profession imaging controls, PDF document, image
add jpg to pdf form; how to add image to pdf reader
Chapter 59. Database Physical Storage
Item
Description
pg_subtrans
Subdirectory containing subtransaction status
data
pg_tblspc
Subdirectory containing symbolic links to
tablespaces
pg_twophase
Subdirectory containing state files for prepared
transactions
pg_xlog
Subdirectory containing WAL (Write Ahead
Log) files
postgresql.auto.conf
Afile used for storing configuration parameters
that are set by
ALTER SYSTEM
postmaster.opts
Afile recording the command-line options the
server was last started with
postmaster.pid
Alock file recording the current postmaster
process ID (PID), cluster data directory path,
postmaster start timestamp, port number,
Unix-domain socket directory path (empty on
Windows), first valid listen_address (IP address
or
*
,or empty if not listening on TCP), and
shared memory segment ID (this file is not
present after server shutdown)
For each database in the cluster there is a subdirectory within
PGDATA/base
, named after the
database’s OID in
pg_database
.This subdirectory is the default location for the database’s files; in
particular, its system catalogs are stored there.
Each table and indexis stored in a separate file. For ordinary relations, these files are named after the
table or index’s filenode number, which canbe found in
pg_class
.
relfilenode
.But for temporary
relations, the file name is of the form
t
BBB
_
FFF
,where
BBB
is the backend ID of the backend which
created the file, and
FFF
is the filenode number. Ineither case, in additionto the main file (a/k/a main
fork), each table and index has a free space map (see Section 59.3), which stores information about
free space available in the relation. The free space map is stored in a file named with the filenode
number plus the suffix
_fsm
.Tables alsohave a visibility map, storedin a forkwith the suffix
_vm
,to
track whichpages areknowntohave nodeadtuples. The visibility mapis described further inSection
59.4. Unlogged tables and indexes have a third fork, known as the initialization fork, which is stored
in a fork with the suffix
_init
(see Section 59.5).
Caution
Note that while a table’s filenode often matches its OID, this is not necessarily
the case; some operations, like
TRUNCATE
,
REINDEX
,
CLUSTER
and some forms
of
ALTER TABLE
,can change the filenode while preserving the OID. Avoid as-
suming that filenode and table OID are the same. Also, for certain system cat-
alogs including
pg_class
itself,
pg_class
.
relfilenode
contains zero. The ac-
tual filenode number of these catalogs is stored in a lower-level data structure,
and can be obtainedusing the
pg_relation_filenode()
function.
When a table or index exceeds 1 GB, it is divided into gigabyte-sized segments. The first seg-
ment’s file name is the same as the filenode; subsequent segments are named filenode.1, filenode.2,
etc. This arrangement avoids problems on platforms that have file size limitations. (Actually, 1 GB
is just the default segment size. The segment size can be adjusted using the configuration option
1971
VB.NET Image: Image Scaling SDK to Scale Picture / Photo
Framework application; VB.NET sample code for how to scale image / picture; Frequently asked questions about RasterEdge VB.NET image scaling control SDK add-on.
add picture to pdf reader; adding a jpg to a pdf
VB.NET Image: Create Code 11 Barcode on Picture & Document Using
file, apart from above mentioned .NET core imaging SDK and .NET barcode creator add-on, you also need to buy .NET PDF document editor add-on, namely, RasterEdge
add image pdf; add picture to pdf form
Chapter 59. Database Physical Storage
--with-segsize
when building PostgreSQL.) Inprinciple, free space map and visibility map forks
could require multiple segments as well, thoughthis is unlikely to happen in practice.
Atable that has columns with potentially large entries will have an associated TOAST table, which
is used for out-of-line storage of field values that are too large to keep in the table rows proper.
pg_class
.
reltoastrelid
links from a table to its TOAST table, if any. See Section59.2 for more
information.
The contents of tables and indexes are discussed further in Section 59.6.
Tablespaces make the scenario more complicated. Each user-defined tablespace has a symbolic link
inside the
PGDATA/pg_tblspc
directory, which points to the physical tablespace directory (i.e., the
locationspecified inthe tablespace’s
CREATE TABLESPACE
command). This symbolic link is named
after the tablespace’s OID. Inside the physical tablespace directory there is a subdirectory with a
name that depends on the PostgreSQL server version, such as
PG_9.0_201008051
.(The reason
for using this subdirectory is so that successive versions of the database can use the same
CREATE
TABLESPACE
location value without conflicts.) Within the version-specific subdirectory, there is a
subdirectoryfor eachdatabase thathas elementsinthetablespace, namedafter thedatabase’s OID. Ta-
bles and indexesarestored withinthatdirectory, using the filenodenamingscheme. The
pg_default
tablespace is not accessed through
pg_tblspc
,but corresponds to
PGDATA/base
. Similarly, the
pg_global
tablespace is not accessed through
pg_tblspc
,but corresponds to
PGDATA/global
.
The
pg_relation_filepath()
function shows the entire path (relative to
PGDATA
)of anyrelation.
It is often useful as a substitute for remembering many of the above rules. But keep in mind that this
function just gives the name of the first segment of the main fork of the relation — you may need to
append asegmentnumber and/or
_fsm
,
_vm
,or
_init
to findallthefiles associated withthe relation.
Temporary files (for operations such as sorting more data than can fit in memory) are created within
PGDATA/base/pgsql_tmp
,or within a
pgsql_tmp
subdirectory of a tablespace directory if a ta-
blespace other than
pg_default
is specified for them. The name of a temporary file has the form
pgsql_tmp
PPP
.
NNN
,where
PPP
is the PID of the owning backend and
NNN
distinguishes different
temporary files of that backend.
59.2. TOAST
This section provides an overview of TOAST (The Oversized-Attribute Storage Technique).
PostgreSQL usesa fixedpage size (commonly8kB), anddoes notallowtuples to span multiple pages.
Therefore, it is not possible to store very large field values directly. To overcome this limitation, large
field values are compressed and/or broken up intomultiple physical rows. This happens transparently
to the user, with only small impact on most of the backend code. The technique is affectionately
known as TOAST (or “the best thing since sliced bread”).
Only certain data types support TOAST — there is no need to impose the overhead on data types
that cannot produce large field values. To support TOAST, a data type must have a variable-length
(varlena) representation, in which the first 32-bit word of any stored value contains the total length
of the value in bytes (including itself). TOAST does not constrain the rest of the representation. All
the C-level functions supporting a TOAST-able data type must be careful to handle TOASTed input
values. (This is normallydone by invoking
PG_DETOAST_DATUM
before doinganything withan input
value, but in some cases more efficient approaches are possible.)
TOAST usurps two bits of the varlena length word (the high-order bits on big-endian machines, the
low-order bits on little-endian machines), thereby limiting the logical size of any value of a TOAST-
able data type to 1 GB (2
30
-1 bytes). When both bits are zero, the value is an ordinary un-TOASTed
value of the data type, and the remaining bits of the length word give the total datum size (including
1972
C# Word - Paragraph Processing in C#.NET
Add references: C# users can set paragraph properties and create content such as run, footnote, endnote and picture in a paragraph.
adding an image to a pdf; how to add image to pdf form
VB.NET Image: Image Resizer Control SDK to Resize Picture & Photo
NET Method to Resize Image & Picture. Here we this VB.NET image resizer control add-on, can provide powerful & profession imaging controls, PDF document, image
how to add an image to a pdf file in acrobat; add jpg to pdf
Chapter 59. Database Physical Storage
length word) in bytes. When the highest-order or lowest-order bit is set, the value has only a single-
byte header instead of the normal four-byte header, and the remaining bits give the total datum size
(including length byte) in bytes. As a special case, if the remaining bits are all zero (which would be
impossible for a self-inclusive length), the value is a pointer to out-of-line data stored in a separate
TOAST table. (The size of a TOAST pointer is given in the second byte of the datum.) Values with
single-byte headers aren’t aligned on any particular boundary, either. Lastly, when the highest-order
or lowest-order bit is clear but the adjacent bit is set, the content of the datum has been compressed
and must be decompressed before use. In this case the remainingbits of the lengthword give the total
size of the compressed datum, not the original data. Note that compression is also possible for out-
of-line data but the varlena header does not tell whether it has occurred — the content of the TOAST
pointer tells that, instead.
If any of the columns of a table are TOAST-able, the table will have an associated TOAST table,
whose OID is stored in the table’s
pg_class
.
reltoastrelid
entry. Out-of-line TOASTed values
are kept in the TOAST table, as described in more detail below.
The compression technique used is a fairly simple and very fast member of the LZ family of com-
pression techniques. See
src/backend/utils/adt/pg_lzcompress.c
for the details.
Out-of-line values are divided (after compression if used) into chunks of at most
TOAST_MAX_CHUNK_SIZE
bytes (by default this value is chosen so that four chunk rows will fit on a
page, making it about 2000 bytes). Each chunk is stored as a separate row inthe TOAST table for the
owning table. Every TOAST table has the columns
chunk_id
(an OID identifying the particular
TOASTed value),
chunk_seq
(a sequence number for the chunk within its value), and
chunk_data
(the actual data of the chunk). A unique index on
chunk_id
and
chunk_seq
provides fast retrieval
of the values. A pointer datum representing an out-of-line TOASTed value therefore needs to store
the OID of the TOAST table in which to look and the OID of the specific value (its
chunk_id
). For
convenience, pointer datums also store the logical datum size (original uncompressed data length)
and actual stored size (different if compression was applied). Allowing for the varlena header bytes,
the total size of a TOAST pointer datum is therefore 18 bytes regardless of the actual size of the
represented value.
The TOAST code is triggered only when a row value to be stored in a table is wider than
TOAST_TUPLE_THRESHOLD
bytes (normally 2 kB). The TOAST code will compress and/or move
field values out-of-line until the row value is shorter than
TOAST_TUPLE_TARGET
bytes (also
normally 2 kB) or no more gains can be had. During an UPDATE operation, values of unchanged
fields are normally preserved as-is; so an UPDATE of a row with out-of-line values incurs no
TOAST costs if none of the out-of-line values change.
The TOAST code recognizes four different strategies for storing TOAST-able columns:
PLAIN
prevents either compression or out-of-line storage; furthermore itdisables useof single-byte
headers for varlena types. This is the only possible strategy for columns of non-TOAST-able data
types.
EXTENDED
allows both compression and out-of-line storage. This is the default for most TOAST-
able data types. Compression will be attempted first, then out-of-line storage if the row is still too
big.
EXTERNAL
allows out-of-line storage but not compression. Use of
EXTERNAL
will make substring
operations on wide
text
and
bytea
columns faster (at the penalty of increased storage space)
because these operations are optimized to fetch only the required parts of the out-of-line value
when it is not compressed.
MAIN
allows compression but not out-of-line storage. (Actually, out-of-line storage will still be
performed for such columns, but only as a last resort when there is no other way to make the row
1973
Chapter 59. Database Physical Storage
small enough to fit on a page.)
Each TOAST-able data type specifies a default strategy for columns of that data type, but the strategy
for a given table column can be altered with
ALTER TABLE SET STORAGE
.
This scheme has a number of advantages compared to a more straightforward approach such as al-
lowing row values to span pages. Assuming that queries are usually qualified by comparisons against
relatively small key values, most of the work of the executor will be done using the main row entry.
The big values of TOASTed attributes will only be pulled out (if selected at all) at the time the result
set is sent to the client. Thus, the main table is much smaller and more of its rows fit in the shared
buffer cache than would be the case without any out-of-line storage. Sort sets shrink also, and sorts
will more often be done entirelyin memory. A little test showed that a table containingtypicalHTML
pages and their URLs was stored in about half of the raw data size including the TOAST table, and
that the main table contained only about 10% of the entire data (the URLs and some small HTML
pages). There was no run time difference compared to an un-TOASTed comparison table, in which
all the HTML pages were cut down to 7 kB to fit.
59.3. Free Space Map
Each heap and index relation, except for hash indexes, has a Free Space Map (FSM) to keep track of
available space in the relation. It’s stored alongside the main relation data in a separate relation fork,
named after the filenode number of the relation, plus a
_fsm
suffix. For example, if the filenode of
arelation is 12345, the FSM is stored in a file called
12345_fsm
,in the same directory as the main
relation file.
The Free Space Map is organized as a tree of FSM pages. The bottom level FSM pages store the free
space available on each heap (or index) page, using one byte to represent each such page. The upper
levels aggregate information from the lower levels.
Within each FSM page is a binary tree, stored in an array with one byte per node. Each leaf node
represents a heap page, or a lower level FSM page. In each non-leaf node, the higher of its children’s
values is stored. The maximum value in the leaf nodes is therefore stored at the root.
See
src/backend/storage/freespace/README
for more details on how the FSM is structured,
and how it’s updated and searched. The pg_freespacemap module can be used to examine the infor-
mation stored in free space maps.
59.4. Visibility Map
Each heap relation has a VisibilityMap(VM) tokeeptrackof whichpagescontainonly tuples that are
knownto be visible to all active transactions. It’s stored alongside the main relation data ina separate
relation fork, named after the filenode number of the relation, plus a
_vm
suffix. For example, if the
filenode of a relation is 12345, the VM is stored in a file called
12345_vm
,in the same directory as
the main relation file. Note that indexes do not have VMs.
The visibility map simply stores one bit per heap page. A set bit means that all tuples on the page are
knownto be visible toall transactions. This means that the page does not contain any tuples that need
to be vacuumed. This information can also be used by index-only scans to answer queries using only
the index tuple.
The map is conservative in the sense that we make sure that whenever a bit is set, we know the
condition is true, but if a bit is not set, it might or might not be true. Visibility map bits are only set
by vacuum, but are cleared by any data-modifying operations on a page.
1974
Chapter 59. Database Physical Storage
59.5. The Initialization Fork
Each unloggedtable, andeachindexon an unloggedtable, has aninitializationfork. The initialization
forkis anemptytable or index of theappropriate type. Whenanunlogged table must be reset to empty
due to a crash, the initialization fork is copiedover the mainfork, and any other forks are erased (they
will be recreated automatically as needed).
59.6. Database Page Layout
This section provides an overview of the page format used within PostgreSQL tables and indexes.
1
Sequences and TOAST tables are formatted just like a regular table.
In the following explanation, a byte is assumed to contain 8 bits. In addition, the term item refers to
an individual data value that is stored on a page. In a table, an item is a row; in an index, an item is an
index entry.
Every table and index is stored as anarray of pages of a fixed size (usually 8 kB, althougha different
pagesize can be selected when compilingthe server). In a table, all the pages are logically equivalent,
soa particular item (row) can be stored in any page. Inindexes, the first page is generally reserved as
ametapage holding control information, and there can be different types of pages within the index,
depending on the index access method.
Table 59-2 shows the overall layout of a page. There are five parts to each page.
Table 59-2. Overall Page Layout
Item
Description
PageHeaderData
24 bytes long. Contains general information
about the page, including free space pointers.
ItemIdData
Array of (offset,length) pairs pointing to the
actual items. 4 bytes per item.
Free space
The unallocated space. New item pointers are
allocated from the start of this area, new items
from the end.
Items
The actual items themselves.
Special space
Index access method specific data. Different
methods store different data. Empty in ordinary
tables.
The first 24 bytes of eachpage consists of a page header (
PageHeaderData
). Its format is detailed in
Table 59-3. The firstfield tracks the mostrecent WAL entry related to this page. The second fieldcon-
tains thepage checksum if data checksums are enabled. Nextis a 2-bytefield containing flagbits. This
is followed by three 2-byte integer fields (
pd_lower
,
pd_upper
,and
pd_special
). These contain
byte offsets from the page start to the start of unallocated space, to the end of unallocated space, and
to the start of the special space. The next 2 bytes of the page header,
pd_pagesize_version
,store
both the page size and a version indicator. Beginning with PostgreSQL 8.3 the version number is 4;
PostgreSQL 8.1 and8.2 used version number 3; PostgreSQL 8.0 used version number 2; PostgreSQL
7.3 and 7.4 used version number 1; prior releases used version number 0. (The basic page layout and
header format has not changed in most of these versions, but the layout of heap row headers has.)
1. Actually, index accessmethods need not use this page format. All the existingindex methods douse thisbasic format, but
the data kept on index metapagesusually doesn’t follow the item layout rules.
1975
Chapter 59. Database Physical Storage
The page size is basically only present as a cross-check; there is no support for having more than one
page size in an installation. The last field is a hint that shows whether pruning the page is likely to be
profitable: it tracks the oldest un-pruned XMAX on the page.
Table 59-3. PageHeaderData Layout
Field
Type
Length
Description
pd_lsn
PageXLogRecPtr
8bytes
LSN: next byte after
last byte of xlog record
for last change to this
page
pd_checksum
uint16
2bytes
Page checksum
pd_flags
uint16
2bytes
Flag bits
pd_lower
LocationIndex
2bytes
Offset to start of free
space
pd_upper
LocationIndex
2bytes
Offset to end of free
space
pd_special
LocationIndex
2bytes
Offset to start of
special space
pd_pagesize_version
uint16
2bytes
Page size and layout
version number
information
pd_prune_xid
TransactionId
4bytes
Oldest unpruned
XMAX on page, or
zero if none
All the details can be found in
src/include/storage/bufpage.h
.
Following the page header are item identifiers (
ItemIdData
), each requiring four bytes. An item
identifier contains a byte-offset to the start of an item, its length in bytes, and a few attribute bits
which affect its interpretation. New item identifiers are allocatedas needed from the beginning of the
unallocatedspace. The number of item identifiers presentcan be determined by lookingat
pd_lower
,
which is increased to allocate a new identifier. Because an item identifier is never moved until it is
freed, its index can be used on a long-term basis to reference an item, even when the item itself is
moved around on the page to compact free space. In fact, every pointer to an item (
ItemPointer
,
also known as
CTID
)created by PostgreSQL consists of a page number and the index of an item
identifier.
The items themselves are stored in space allocatedbackwards from the end of unallocatedspace. The
exact structure varies depending on what the table is to contain. Tables and sequences both use a
structure named
HeapTupleHeaderData
,described below.
The final section is the “special section” which can contain anything the access method wishes to
store. For example, b-tree indexes store links to the page’s left and right siblings, as well as some
other data relevant to the index structure. Ordinary tables do not use a special section atall (indicated
by setting
pd_special
to equal the page size).
All table rows are structured in the same way. There is a fixed-size header (occupying 23 bytes on
most machines), followed by an optional null bitmap, an optional object ID field, and the user data.
The header is detailed in Table 59-4. The actual user data (columns of the row) begins at the offset
indicated by
t_hoff
,whichmustalways be a multiple of the MAXALIGN distance for the platform.
The null bitmap is only present if the HEAP_HASNULL bit is set in
t_infomask
.If it is present it
begins just after the fixed header and occupies enough bytes to have one bit per data column (that is,
1976
Chapter 59. Database Physical Storage
t_natts
bits altogether). Inthis listof bits, a 1bit indicates not-null, a0bitis anull. Whenthebitmap
is not present, all columns are assumed not-null. The object ID is only present if the HEAP_HASOID
bitis set in
t_infomask
.If present, itappears just before the
t_hoff
boundary. Any paddingneeded
tomake
t_hoff
aMAXALIGNmultiplewill appear between the nullbitmapand the objectID. (This
in turn ensures that the object ID is suitably aligned.)
Table 59-4. HeapTupleHeaderData Layout
Field
Type
Length
Description
t_xmin
TransactionId
4bytes
insert XID stamp
t_xmax
TransactionId
4bytes
delete XID stamp
t_cid
CommandId
4bytes
insert and/or delete
CIDstamp (overlays
with t_xvac)
t_xvac
TransactionId
4bytes
XID for VACUUM
operation movinga
row version
t_ctid
ItemPointerData
6bytes
current TID of this or
newer row version
t_infomask2
uint16
2bytes
number of attributes,
plus various flag bits
t_infomask
uint16
2bytes
various flag bits
t_hoff
uint8
1byte
offset to user data
All the details can be found in
src/include/access/htup_details.h
.
Interpreting the actual data can only be done with information obtained from other tables, mostly
pg_attribute
.The key values needed to identify field locations are
attlen
and
attalign
.There
is noway to directlygeta particular attribute, except whenthere areonly fixedwidthfieldsandnonull
values. All this trickery is wrapped up in the functions heap_getattr, fastgetattr and heap_getsysattr.
To read the data you need to examine each attribute in turn. First check whether the field is NULL
according to the null bitmap. If it is, go to the next. Then make sure you have the right alignment.
If the field is a fixed width field, then all the bytes are simply placed. If it’s a variable length field
(attlen = -1) then it’s a bit more complicated. All variable-length data types share the common header
structure
struct varlena
,which includes the total length of the stored value and some flag bits.
Depending on the flags, the data can be either inline or in a TOAST table; it might be compressed,
too (see Section 59.2).
1977
Documents you may be interested
Documents you may be interested