pdf viewer dll for c# : How to add an image to a pdf file in acrobat Library control component asp.net azure web page mvc postgresql-9.4-A418-part2812

Chapter 8. Data Types
Name
Aliases
Description
polygon
closed geometric path on a
plane
real
float4
single precision floating-point
number (4 bytes)
smallint
int2
signed two-byte integer
smallserial
serial2
autoincrementing two-byte
integer
serial
serial4
autoincrementing four-byte
integer
text
variable-length character string
time [ (
p
) ] [ without
time zone ]
time of day (no time zone)
time [ (
p
) ] with time
zone
timetz
time of day, including time
zone
timestamp [ (
p
) ] [
without time zone ]
date and time (no time zone)
timestamp [ (
p
) ] with
time zone
timestamptz
date and time, including time
zone
tsquery
text search query
tsvector
text search document
txid_snapshot
user-level transaction ID
snapshot
uuid
universally unique identifier
xml
XML data
Compatibility: The following types (or spellings thereof) are specified by SQL:
bigint
,
bit
,
bit
varying
,
boolean
,
char
,
character varying
,
character
,
varchar
,
date
,
double precision
,
integer
,
interval
,
numeric
,
decimal
,
real
,
smallint
,
time
(with or without time zone),
timestamp
(with or without time zone),
xml
.
Each data type has an external representation determined by its input and output functions. Many of
the built-in types have obvious external formats. However, several types are either unique to Post-
greSQL, such as geometric paths, or have several possible formats, such as the date and time types.
Some of the input and output functions are not invertible, i.e., the result of an output function might
lose accuracy when compared to the original input.
8.1. Numeric Types
Numeric types consist of two-, four-, and eight-byte integers, four- and eight-byte floating-point num-
bers, and selectable-precisiondecimals. Table 8-2 lists the available types.
Table 8-2. Numeric Types
Name
Storage Size
Description
Range
108
How to add an image to a pdf file in 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
how to add a photo to a pdf document; adding an image to a pdf form
How to add an image to a pdf file in 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
acrobat insert image in pdf; how to add image to pdf reader
Chapter 8. Data Types
Name
Storage Size
Description
Range
smallint
2bytes
small-range integer
-32768 to +32767
integer
4bytes
typical choice for
integer
-2147483648 to
+2147483647
bigint
8bytes
large-range integer
-
9223372036854775808
to
+9223372036854775807
decimal
variable
user-specified
precision, exact
up to 131072 digits
before the decimal
point; up to 16383
digits after the decimal
point
numeric
variable
user-specified
precision, exact
up to 131072 digits
before the decimal
point; up to 16383
digits after the decimal
point
real
4bytes
variable-precision,
inexact
6decimal digits
precision
double precision
8bytes
variable-precision,
inexact
15 decimal digits
precision
smallserial
2bytes
small autoincrementing
integer
1to 32767
serial
4bytes
autoincrementing
integer
1to 2147483647
bigserial
8bytes
large autoincrementing
integer
1to
9223372036854775807
The syntax of constants for the numeric types is described in Section 4.1.2. The numeric types have a
full set of corresponding arithmetic operators and functions. Refer toChapter 9 for more information.
The following sections describe the types in detail.
8.1.1. Integer Types
The types
smallint
,
integer
,and
bigint
store whole numbers, thatis, numbers withoutfractional
components, of various ranges. Attempts to store values outside of the allowed range will result in an
error.
The type
integer
is the commonchoice, as it offers the bestbalance between range, storagesize, and
performance. The
smallint
type is generally only used if disk space is at a premium. The
bigint
type is designed to be used when the range of the
integer
type is insufficient.
SQL only specifies the integer types
integer
(or
int
),
smallint
,and
bigint
.The type names
int2
,
int4
,and
int8
are extensions, which are also used by some other SQL database systems.
109
.NET PDF Document Viewing, Annotation, Conversion & Processing
Convert image files to PDF. File & Page Process. Add, insert PDF native annotations to PDF file. Edit, update, delete PDF annotations from PDF file. Print.
add jpg to pdf document; adding an image to a pdf
C# PDF Converter Library SDK to convert PDF to other file formats
professional PDF document conversion library toolkit in C#, you can easily perform file conversion from PDF document to image or document
how to add a picture to a pdf document; how to add image to pdf form
Chapter 8. Data Types
8.1.2. Arbitrary Precision Numbers
The type
numeric
can store numbers with a very large number of digits and perform calculations
exactly. It is especiallyrecommendedfor storing monetary amounts andother quantities where exact-
ness is required. However, arithmetic on
numeric
values is very slow compared to the integer types,
or to the floating-point types described in the next section.
We use the following terms below: The scale of a
numeric
is the count of decimal digits in the
fractional part, to the right of the decimal point. The precision of a
numeric
is the total count of
significant digits in the whole number, that is, the number of digits to both sides of the decimalpoint.
So the number 23.5141 has a precision of 6 and a scale of 4. Integers can be considered to have a
scale of zero.
Both the maximum precision and the maximum scale of a
numeric
column can be configured. To
declare a columnof type
numeric
use the syntax:
NUMERIC(
precision
,
scale
)
The precision must be positive, the scale zero or positive. Alternatively:
NUMERIC(
precision
)
selects a scale of 0. Specifying:
NUMERIC
without any precision or scale creates a column in which numeric values of any precision and scale
can be stored, up to the implementation limit on precision. A column of this kind will not coerce
input values toany particular scale, whereas
numeric
columns with a declaredscale willcoerce input
values tothat scale. (The SQL standard requires a default scale of 0, i.e., coerciontointeger precision.
We findthis a bituseless. If you’re concernedabout portability, always specify the precisionand scale
explicitly.)
Note: The maximum allowed precision when explicitly specified in the type declaration is 1000;
NUMERIC
without a specified precision is subject to the limits described in Table 8-2.
If the scale of a value to be stored is greater than the declared scale of the column, the system will
round the value to the specified number of fractional digits. Then, if the number of digits to the left of
the decimal point exceeds the declared precision minus the declared scale, an error is raised.
Numeric values are physically stored without any extra leading or trailing zeroes. Thus, the declared
precision andscale of a column are maximums, not fixed allocations. (In this sense the
numeric
type
is more akin to
varchar(
n
)
than to
char(
n
)
.) The actual storage requirement is two bytes for each
group of four decimal digits, plus three to eight bytes overhead.
In addition to ordinary numeric values, the
numeric
type allows the special value
NaN
,meaning
“not-a-number”. Any operation on
NaN
yields another
NaN
.When writing this value as a constant in
an SQL command, you must put quotes around it, for example
UPDATE table SET x = ’NaN’
.
On input, the string
NaN
is recognized in a case-insensitive manner.
Note: In most implementations of the“not-a-number” concept,
NaN
is not considered equal to any
other numeric value (including
NaN
). In order to allow
numeric
values to be sorted and used in
tree-based indexes, PostgreSQL treats
NaN
values as equal, and greater than all non-
NaN
values.
110
C# Windows Viewer - Image and Document Conversion & Rendering in
conversion library toolkit in C#, you can easily perform file conversion from Image and Document Conversion Supported by Windows Viewer. Convert to PDF.
adding a png to a pdf; adding a jpg to a pdf
C# powerpoint - PowerPoint Conversion & Rendering in C#.NET
may easily achieve the following PowerPoint file conversions SDK to convert PowerPoint document to PDF document demo code for PowerPoint to TIFF image conversion
add picture to pdf form; adding images to pdf forms
Chapter 8. Data Types
The types
decimal
and
numeric
are equivalent. Both types are part of the SQL standard.
8.1.3. Floating-Point Types
The data types
real
and
double precision
are inexact, variable-precision numerictypes. In prac-
tice, these types are usually implementations of IEEE Standard 754 for Binary Floating-Point Arith-
metic (singleanddoubleprecision, respectively), tothe extent thattheunderlying processor, operating
system, and compiler support it.
Inexactmeans thatsome values cannotbeconverted exactlytotheinternal format andarestoredas ap-
proximations, so that storing and retrieving a value might show slight discrepancies. Managing these
errors and how they propagate through calculations is the subject of an entire branch of mathematics
and computer science and will not be discussed here, except for the following points:
If you require exact storage and calculations (such as for monetary amounts), use the
numeric
type instead.
If you want to do complicated calculations with these types for anything important, especially
if you rely on certain behavior in boundary cases (infinity, underflow), you should evaluate the
implementation carefully.
Comparing two floating-point values for equality might not always work as expected.
On most platforms, the
real
type has a range of atleast 1E-37to 1E+37 witha precision of at least6
decimaldigits. The
double precision
type typicallyhas arange of around1E-307to1E+308with
aprecision of at least 15 digits. Values that are too large or too small will cause an error. Rounding
might take place if the precision of an input number is too high. Numbers too close to zero that are
not representable as distinct from zero will cause an underflow error.
Note: The extra_float_digits setting controls the number of extra significant digits included when
afloating point value is converted to text for output. With the default value of
0
,the output is the
same on every platform supported by PostgreSQL. Increasing it will produce output that more
accurately represents the stored value, but may be unportable.
In addition to ordinary numeric values, the floating-point types have several special values:
Infinity
-Infinity
NaN
These represent the IEEE 754 special values “infinity”, “negative infinity”, and “not-a-number”, re-
spectively. (On a machine whose floating-point arithmetic does not follow IEEE 754, these values
will probably not work as expected.) When writing these values as constants in an SQL command,
you must put quotes around them, for example
UPDATE table SET x = ’Infinity’
.On input,
these strings are recognized in a case-insensitive manner.
Note: IEEE754 specifies that
NaN
should not compare equal to any other floating-point value
(including
NaN
). Inorder toallowfloating-point values to be sortedandused in tree-basedindexes,
PostgreSQL treats
NaN
values as equal, and greater than all non-
NaN
values.
111
C# Word - Word Conversion in C#.NET
you may easily achieve the following Word file conversions. XDoc.Word SDK to convert Word document to PDF document C# demo code for Word to TIFF image conversion
pdf insert image; add photo to pdf file
VB.NET PDF: How to Create Watermark on PDF Document within
Using this VB.NET Imaging PDF Watermark Add-on, you can a watermark that consists of text or image (such as And with our PDF Watermark Creator, users need no
add image to pdf online; add picture to pdf online
Chapter 8. Data Types
PostgreSQL also supports the SQL-standard notations
float
and
float(
p
)
for specifying inexact
numeric types. Here,
p
specifies the minimum acceptable precision in binary digits. PostgreSQL
accepts
float(1)
to
float(24)
as selecting the
real
type, while
float(25)
to
float(53)
select
double precision
.Values of
p
outside the allowed range draw an error.
float
with no precision
specified is taken to mean
double precision
.
Note: Theassumption that
real
and
double precision
have exactly 24and53 bits in the man-
tissa respectively is correct for IEEE-standard floating point implementations. On non-IEEE plat-
forms it might be off a little, but for simplicity the same ranges of
p
are used on all platforms.
8.1.4. Serial Types
The data types
smallserial
,
serial
and
bigserial
are not true types, but merely a notational
convenience for creating unique identifier columns (similar to the
AUTO_INCREMENT
property sup-
ported by some other databases). In the current implementation, specifying:
CREATE TABLE
tablename
(
colname
SERIAL
);
is equivalent to specifying:
CREATE SEQUENCE
tablename
_
colname
_seq;
CREATE TABLE
tablename
(
colname
integer NOT NULL DEFAULT nextval(’
tablename
_
colname
_seq’)
);
ALTER SEQUENCE
tablename
_
colname
_seq OWNED BY
tablename
.
colname
;
Thus, we have created an integer column and arranged for its default values to be assignedfrom a se-
quence generator. A
NOT NULL
constraint is applied to ensure that a null value cannot be inserted. (In
most cases you would also want to attach a
UNIQUE
or
PRIMARY KEY
constraint to prevent duplicate
values from being inserted by accident, but this is not automatic.) Lastly, the sequence is marked as
“owned by” the column, so that it will be dropped if the column or table is dropped.
Note: Because
smallserial
,
serial
and
bigserial
are implemented using sequences, there
may be "holes" or gaps in the sequence of values which appears in the column, even if no rows
are ever deleted. A value allocated from the sequence is still "used up" even if a row containing
that value is never successfully inserted into the table column. This may happen, for example, if
the inserting transaction rolls back. See
nextval()
in Section 9.16 for details.
To insert the next value of the sequence into the
serial
column, specify that the
serial
column
should be assigned its default value. This can be done either by excluding the column from the list of
columns in the
INSERT
statement, or through the use of the
DEFAULT
key word.
The type names
serial
and
serial4
areequivalent: bothcreate
integer
columns. Thetype names
bigserial
and
serial8
workthesame way, exceptthatthey create a
bigint
column.
bigserial
should be used if you anticipate the use of more than 2
31
identifiers over the lifetime of the table. The
type names
smallserial
and
serial2
also work the same way, exceptthatthey create a
smallint
column.
112
PDF to WORD Converter | Convert PDF to Word, Convert Word to PDF
If you want to convert document file PDF formats to out transformation between different kinds of image files and Converter has accurate output, and PDF to Word
add jpg signature to pdf; how to add image to pdf acrobat
JPEG to PDF Converter | Convert JPEG to PDF, Convert PDF to JPEG
No need for Adobe Acrobat Reader; Seamlessly integrated into RasterEdge .NET Image SDK; high speed; Get a compressed PDF file after conversion;
add image to pdf form; adding image to pdf
Chapter 8. Data Types
The sequence created for a
serial
column is automatically dropped when the owning column is
dropped. You can drop the sequence without dropping the column, but this will force removal of the
column default expression.
8.2. Monetary Types
The
money
type stores a currency amount with a fixed fractional precision; see Table 8-3. The frac-
tional precision is determined by the database’s lc_monetary setting. The range shown in the table
assumes there are two fractional digits. Input is accepted in a variety of formats, including integer
and floating-point literals, as well as typical currency formatting, such as
’$1,000.00’
.Output is
generally in the latter form but depends on the locale.
Table 8-3. Monetary Types
Name
Storage Size
Description
Range
money
8bytes
currency amount
-
92233720368547758.08
to
+92233720368547758.07
Since the output of this data type is locale-sensitive, it might not work to load
money
data into a
database that has a different setting of
lc_monetary
.To avoid problems, before restoring a dump
into a new database make sure
lc_monetary
has the same or equivalent value as in the database that
was dumped.
Values of the
numeric
,
int
,and
bigint
data types can be cast to
money
.Conversionfrom the
real
and
double precision
data types can be done by casting to
numeric
first, for example:
SELECT ’12.34’::float8::numeric::money;
However, this is not recommended. Floating point numbers should not be used to handle money due
to the potential for rounding errors.
A
money
value can be cast to
numeric
without loss of precision. Conversion to other types could
potentially lose precision, and must also be done in two stages:
SELECT ’52093.89’::money::numeric::float8;
When a
money
value is divided by another
money
value, the result is
double precision
(i.e., a
pure number, not money); the currency units cancel each other out inthe division.
8.3. Character Types
Table 8-4. Character Types
Name
Description
character varying(
n
)
,
varchar(
n
)
variable-length with limit
113
BMP to PDF Converter | Convert Bitmap to PDF, Convert PDF to BMP
Also designed to be used add-on for .NET Image Powerful image converter for Bitmap and PDF files; No Support conversion of Bitmap - PDF files in both single &
add image in pdf using java; add jpeg signature to pdf
VB.NET PowerPoint: VB Code to Draw and Create Annotation on PPT
as a kind of compensation for limitations (other documents are compatible, including PDF, TIFF, MS VB.NET PPT: VB Code to Add Embedded Image Object to
add picture to pdf preview; adding images to a pdf document
Chapter 8. Data Types
Name
Description
character(
n
)
,
char(
n
)
fixed-length, blank padded
text
variable unlimited length
Table 8-4 shows the general-purpose character types available in PostgreSQL.
SQL defines two primary character types:
character varying(
n
)
and
character(
n
)
,where
n
is a positive integer. Both of these types can store strings up to
n
characters (not bytes) in length.
An attempt to store a longer string into a column of these types will result in an error, unless the
excess characters are all spaces, in which case the string will be truncated to the maximum length.
(This somewhat bizarreexception is required by the SQL standard.) If thestring to be storedis shorter
thanthedeclaredlength, values of type
character
will be space-padded; values of type
character
varying
will simply store the shorter string.
If one explicitly casts a value to
character varying(
n
)
or
character(
n
)
,then an over-length
value will be truncated to
n
characters without raising an error. (This too is required by the SQL
standard.)
The notations
varchar(
n
)
and
char(
n
)
are aliases for
character varying(
n
)
and
character(
n
)
,respectively.
character
without length specifier is equivalent to
character(1)
.
If
character varying
is used without length specifier, the type accepts strings of any size. The
latter is a PostgreSQL extension.
In addition, PostgreSQL provides the
text
type, which stores strings of any length. Although the
type
text
is not in the SQL standard, several other SQL database management systems have it as
well.
Values of type
character
are physically padded with spaces to the specifiedwidth
n
,and are stored
and displayed that way. However, trailing spaces are treated as semantically insignificant and disre-
gardedwhen comparing twovalues of type
character
.Incollations where whitespace is significant,
this behavior canproduceunexpectedresults;for example
SELECT ’a ’::CHAR(2) collate "C"
< E’a\n’::CHAR(2)
returns true, even though
C
locale would consider a space to be greater than a
newline. Trailing spaces are removed when converting a
character
value to one of the other string
types. Note that trailing spaces are semantically significant in
character varying
and
text
val-
ues, and when using pattern matching, that is
LIKE
and regular expressions.
The storage requirement for a short string (up to 126 bytes) is 1 byte plus the actual string, which
includesthespace paddinginthecase of
character
.Longer strings have4 bytes of overheadinstead
of 1. Long strings are compressed by the system automatically, so the physical requirement on disk
might be less. Very long values are also stored in background tables so that they do not interfere with
rapid access to shorter column values. In any case, the longest possible character string that can be
stored is about 1 GB. (The maximum value that will be allowed for
n
in the data type declaration
is less than that. It wouldn’t be useful to change this because with multibyte character encodings
the number of characters and bytes can be quite different. If you desire to store long strings with no
specific upper limit, use
text
or
character varying
without alengthspecifier, rather thanmaking
up an arbitrary length limit.)
Tip: There is no performance difference among these three types, apart from increased storage
space when using the blank-padded type, and a few extra CPU cycles to check the length when
storing into a length-constrained column. While
character(
n
)
has performance advantages in
some other database systems, there is no such advantage in PostgreSQL; in fact
character(
n
)
is usually the slowest of the three because of its additional storage costs. In most situations
text
or
character varying
should be used instead.
114
Chapter 8. Data Types
Refer to Section 4.1.2.1 for information about the syntax of string literals, and to Chapter 9 for infor-
mation about available operators and functions. The database character set determines the character
set used to store textual values; for more information on character set support, refer to Section 22.3.
Example 8-1. Using the Character Types
CREATE TABLE test1 (a character(4));
INSERT INTO test1 VALUES (’ok’);
SELECT a, char_length(a) FROM test1; -- ˚
a
| char_length
------+-------------
ok
|
2
CREATE TABLE test2 (b varchar(5));
INSERT INTO test2 VALUES (’ok’);
INSERT INTO test2 VALUES (’good
’);
INSERT INTO test2 VALUES (’too long’);
ERROR:
value too long for type character varying(5)
INSERT INTO test2 VALUES (’too long’::varchar(5)); -- explicit truncation
SELECT b, char_length(b) FROM test2;
b
| char_length
-------+-------------
ok
|
2
good
|
5
too l |
5
˚
The
char_length
function is discussed in Section 9.4.
There are two other fixed-length character types in PostgreSQL, shown in Table 8-5. The
name
type
exists only for the storage of identifiers in the internal system catalogs and is not intended for use by
the general user. Its length is currently defined as 64 bytes (63 usable characters plus terminator) but
should be referenced usingthe constant
NAMEDATALEN
in
C
source code. The length is set at compile
time (and is therefore adjustable for special uses); the default maximum length might change in a
future release. The type
"char"
(note the quotes) is different from
char(1)
in that it only uses one
byte of storage. It is internally used in the system catalogs as a simplistic enumeration type.
Table 8-5. Special Character Types
Name
Storage Size
Description
"char"
1byte
single-byte internal type
name
64 bytes
internal type for object names
8.4. Binary Data Types
The
bytea
data type allows storage of binary strings; see Table 8-6.
Table 8-6. Binary Data Types
Name
Storage Size
Description
115
Chapter 8. Data Types
Name
Storage Size
Description
bytea
1or 4 bytes plus the actual
binary string
variable-length binary string
Abinary string is a sequence of octets (or bytes). Binary strings are distinguished from character
strings in two ways. First, binarystrings specifically allowstoring octets of value zero and other “non-
printable” octets (usually, octets outside the range 32 to 126). Character strings disallow zero octets,
and also disallow any other octet values and sequences of octet values that are invalid according to
the database’s selected character setencoding. Second, operations onbinary strings process theactual
bytes, whereas the processing of character strings depends on locale settings. In short, binary strings
are appropriate for storing data that the programmer thinks of as “raw bytes”, whereas character
strings are appropriate for storing text.
The
bytea
type supports twoexternal formats for input andoutput: PostgreSQL’s historical “escape”
format, and “hex” format. Both of these are always accepted on input. The output format depends on
the configurationparameter bytea_output;the default is hex. (Note that the hex format was introduced
in PostgreSQL 9.0; earlier versions and some tools don’t understand it.)
The SQL standard defines a different binary string type, called
BLOB
or
BINARY LARGE OBJECT
.
The input format is different from
bytea
,but the provided functions and operators are mostly the
same.
8.4.1.
bytea
Hex Format
The “hex” format encodes binary data as 2 hexadecimal digits per byte, most significant nibble first.
The entire string is preceded by the sequence
\x
(to distinguish it from the escape format). In some
contexts, the initial backslash may need to be escaped by doubling it, in the same cases in which
backslashes have to be doubled in escape format; details appear below. The hexadecimal digits can
be either upper or lower case, and whitespace is permitted between digit pairs (but not within a digit
pair nor in the starting
\x
sequence). The hex format is compatible with a wide range of external
applications and protocols, and it tends to be faster to convert than the escape format, so its use is
preferred.
Example:
SELECT E’\\xDEADBEEF’;
8.4.2.
bytea
Escape Format
The “escape” format is the traditional PostgreSQL format for the
bytea
type. It takes the approach
of representing a binary string as a sequence of ASCII characters, while converting those bytes that
cannot be represented as an ASCII character into special escape sequences. If, from the point of
view of the application, representing bytes as characters makes sense, then this representation can be
convenient. But in practice it is usually confusing because it fuzzes up the distinction between binary
strings and character strings, and also the particular escape mechanism that was chosen is somewhat
unwieldy. So this format should probably be avoided for most new applications.
When entering
bytea
values in escape format, octets of certain values must be escaped, while all
octet values can be escaped. In general, to escape an octet, convert it into its three-digit octal value
and precede it by a backslash (or two backslashes, if writing the value as a literal using escape string
syntax). Backslash itself (octet value 92) can alternatively be represented by double backslashes.
116
Chapter 8. Data Types
Table8-7 shows the characters that must be escaped, andgives thealternative escape sequences where
applicable.
Table 8-7.
bytea
Literal Escaped Octets
Decimal Octet
Value
Description
Escaped Input
Representation
Example
Output
Representation
0
zero octet
E’\\000’
SELECT
E’\\000’::bytea;
\000
39
single quote
””
or
E’\\047’
SELECT
E’\”::bytea;
92
backslash
E’\\\\’
or
E’\\134’
SELECT
E’\\\\’::bytea;
\\
0to 31 and 127 to
255
“non-printable”
octets
E’\\
xxx’
(octal
value)
SELECT
E’\\001’::bytea;
\001
The requirement toescape non-printable octets varies depending onlocale settings. Insomeinstances
you can get away with leaving them unescaped. Note that the result in each of the examples in Table
8-7 was exactly one octet in length, even though the output representation is sometimes more than
one character.
The reason multiple backslashes are required, as shown in Table 8-7, is that an input string written
as a string literal must pass through two parse phases in the PostgreSQL server. The first backslash
of each pair is interpreted as an escape character by the string-literal parser (assuming escape string
syntax is used) and is therefore consumed, leaving the second backslash of the pair. (Dollar-quoted
strings can be used to avoid this level of escaping.) The remaining backslash is then recognized by
the
bytea
input functionas startingeither a three digit octal value or escaping another backslash. For
example, a string literal passed to the server as
E’\\001’
becomes
\001
after passing through the
escape string parser. The
\001
is then sent to the
bytea
input function, where it is converted to a
single octet with a decimal value of 1. Note that the single-quote character is not treated specially by
bytea
,so it follows the normal rules for string literals. (See also Section 4.1.2.1.)
Bytea
octets are sometimes escaped when output. In general, each “non-printable” octetis converted
into its equivalent three-digit octal value and preceded by one backslash. Most “printable” octets are
represented by their standard representation in the client character set. The octet with decimal value
92 (backslash) is doubled in the output. Details are in Table 8-8.
Table 8-8.
bytea
Output Escaped Octets
Decimal Octet
Value
Description
Escaped
Output
Representation
Example
Output Result
92
backslash
\\
SELECT
E’\\134’::bytea;
\\
117
Documents you may be interested
Documents you may be interested