I686LINUX/util/I686LINUX/doc/postgresql/html/sql-syntax.html

   1 <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
   2 <HTML
   3 ><HEAD
   4 ><TITLE
   5 >SQL Syntax</TITLE
   6 ><META
   7 NAME="GENERATOR"
   8 CONTENT="Modular DocBook HTML Stylesheet Version 1.7"><LINK
   9 REV="MADE"
  10 HREF="mailto:pgsql-docs@postgresql.org"><LINK
  11 REL="HOME"
  12 TITLE="PostgreSQL 7.4.1 Documentation"
  13 HREF="index.html"><LINK
  14 REL="UP"
  15 TITLE="The SQL Language"
  16 HREF="sql.html"><LINK
  17 REL="PREVIOUS"
  18 TITLE="The SQL Language"
  19 HREF="sql.html"><LINK
  20 REL="NEXT"
  21 TITLE="Value Expressions"
  22 HREF="sql-expressions.html"><LINK
  23 REL="STYLESHEET"
  24 TYPE="text/css"
  25 HREF="stylesheet.css"><META
  26 NAME="creation"
  27 CONTENT="2003-12-22T03:48:47"></HEAD
  28 ><BODY
  29 CLASS="CHAPTER"
  30 ><DIV
  31 CLASS="NAVHEADER"
  32 ><TABLE
  33 SUMMARY="Header navigation table"
  34 WIDTH="100%"
  35 BORDER="0"
  36 CELLPADDING="0"
  37 CELLSPACING="0"
  38 ><TR
  39 ><TH
  40 COLSPAN="5"
  41 ALIGN="center"
  42 VALIGN="bottom"
  43 >PostgreSQL 7.4.1 Documentation</TH
  44 ></TR
  45 ><TR
  46 ><TD
  47 WIDTH="10%"
  48 ALIGN="left"
  49 VALIGN="top"
  50 ><A
  51 HREF="sql.html"
  52 ACCESSKEY="P"
  53 >Prev</A
  54 ></TD
  55 ><TD
  56 WIDTH="10%"
  57 ALIGN="left"
  58 VALIGN="top"
  59 ><A
  60 HREF="sql.html#AEN997"
  61 >Fast Backward</A
  62 ></TD
  63 ><TD
  64 WIDTH="60%"
  65 ALIGN="center"
  66 VALIGN="bottom"
  67 ></TD
  68 ><TD
  69 WIDTH="10%"
  70 ALIGN="right"
  71 VALIGN="top"
  72 ><A
  73 HREF="ddl.html"
  74 >Fast Forward</A
  75 ></TD
  76 ><TD
  77 WIDTH="10%"
  78 ALIGN="right"
  79 VALIGN="top"
  80 ><A
  81 HREF="sql-expressions.html"
  82 ACCESSKEY="N"
  83 >Next</A
  84 ></TD
  85 ></TR
  86 ></TABLE
  87 ><HR
  88 ALIGN="LEFT"
  89 WIDTH="100%"></DIV
  90 ><DIV
  91 CLASS="CHAPTER"
  92 ><H1
  93 ><A
  94 NAME="SQL-SYNTAX"
  95 ></A
  96 >Chapter 4. SQL Syntax</H1
  97 ><DIV
  98 CLASS="TOC"
  99 ><DL
 100 ><DT
 101 ><B
 102 >Table of Contents</B
 103 ></DT
 104 ><DT
 105 >4.1. <A
 106 HREF="sql-syntax.html#SQL-SYNTAX-LEXICAL"
 107 >Lexical Structure</A
 108 ></DT
 109 ><DD
 110 ><DL
 111 ><DT
 112 >4.1.1. <A
 113 HREF="sql-syntax.html#SQL-SYNTAX-IDENTIFIERS"
 114 >Identifiers and Key Words</A
 115 ></DT
 116 ><DT
 117 >4.1.2. <A
 118 HREF="sql-syntax.html#SQL-SYNTAX-CONSTANTS"
 119 >Constants</A
 120 ></DT
 121 ><DT
 122 >4.1.3. <A
 123 HREF="sql-syntax.html#SQL-SYNTAX-OPERATORS"
 124 >Operators</A
 125 ></DT
 126 ><DT
 127 >4.1.4. <A
 128 HREF="sql-syntax.html#AEN1269"
 129 >Special Characters</A
 130 ></DT
 131 ><DT
 132 >4.1.5. <A
 133 HREF="sql-syntax.html#SQL-SYNTAX-COMMENTS"
 134 >Comments</A
 135 ></DT
 136 ><DT
 137 >4.1.6. <A
 138 HREF="sql-syntax.html#SQL-PRECEDENCE"
 139 >Lexical Precedence</A
 140 ></DT
 141 ></DL
 142 ></DD
 143 ><DT
 144 >4.2. <A
 145 HREF="sql-expressions.html"
 146 >Value Expressions</A
 147 ></DT
 148 ><DD
 149 ><DL
 150 ><DT
 151 >4.2.1. <A
 152 HREF="sql-expressions.html#AEN1510"
 153 >Column References</A
 154 ></DT
 155 ><DT
 156 >4.2.2. <A
 157 HREF="sql-expressions.html#AEN1526"
 158 >Positional Parameters</A
 159 ></DT
 160 ><DT
 161 >4.2.3. <A
 162 HREF="sql-expressions.html#AEN1540"
 163 >Subscripts</A
 164 ></DT
 165 ><DT
 166 >4.2.4. <A
 167 HREF="sql-expressions.html#AEN1559"
 168 >Field Selection</A
 169 ></DT
 170 ><DT
 171 >4.2.5. <A
 172 HREF="sql-expressions.html#AEN1570"
 173 >Operator Invocations</A
 174 ></DT
 175 ><DT
 176 >4.2.6. <A
 177 HREF="sql-expressions.html#AEN1599"
 178 >Function Calls</A
 179 ></DT
 180 ><DT
 181 >4.2.7. <A
 182 HREF="sql-expressions.html#SYNTAX-AGGREGATES"
 183 >Aggregate Expressions</A
 184 ></DT
 185 ><DT
 186 >4.2.8. <A
 187 HREF="sql-expressions.html#SQL-SYNTAX-TYPE-CASTS"
 188 >Type Casts</A
 189 ></DT
 190 ><DT
 191 >4.2.9. <A
 192 HREF="sql-expressions.html#SQL-SYNTAX-SCALAR-SUBQUERIES"
 193 >Scalar Subqueries</A
 194 ></DT
 195 ><DT
 196 >4.2.10. <A
 197 HREF="sql-expressions.html#SQL-SYNTAX-ARRAY-CONSTRUCTORS"
 198 >Array Constructors</A
 199 ></DT
 200 ><DT
 201 >4.2.11. <A
 202 HREF="sql-expressions.html#SYNTAX-EXPRESS-EVAL"
 203 >Expression Evaluation Rules</A
 204 ></DT
 205 ></DL
 206 ></DD
 207 ></DL
 208 ></DIV
 209 ><A
 210 NAME="AEN1014"
 211 ></A
 212 ><P
 213 >  This chapter describes the syntax of SQL.  It forms the foundation
 214   for understanding the following chapters which will go into detail
 215   about how the SQL commands are applied to define and modify data.
 216  </P
 217 ><P
 218 >  We also advise users who are already familiar with SQL to read this
 219   chapter carefully because there are several rules and concepts that
 220   are implemented inconsistently among SQL databases or that are
 221   specific to <SPAN
 222 CLASS="PRODUCTNAME"
 223 >PostgreSQL</SPAN
 224 >.
 225  </P
 226 ><DIV
 227 CLASS="SECT1"
 228 ><H1
 229 CLASS="SECT1"
 230 ><A
 231 NAME="SQL-SYNTAX-LEXICAL"
 232 >4.1. Lexical Structure</A
 233 ></H1
 234 ><A
 235 NAME="AEN1022"
 236 ></A
 237 ><P
 238 >   SQL input consists of a sequence of
 239    <I
 240 CLASS="FIRSTTERM"
 241 >commands</I
 242 >.  A command is composed of a
 243    sequence of <I
 244 CLASS="FIRSTTERM"
 245 >tokens</I
 246 >, terminated by a
 247    semicolon (<SPAN
 248 CLASS="QUOTE"
 249 >";"</SPAN
 250 >).  The end of the input stream also
 251    terminates a command.  Which tokens are valid depends on the syntax
 252    of the particular command.
 253   </P
 254 ><P
 255 >   A token can be a <I
 256 CLASS="FIRSTTERM"
 257 >key word</I
 258 >, an
 259    <I
 260 CLASS="FIRSTTERM"
 261 >identifier</I
 262 >, a <I
 263 CLASS="FIRSTTERM"
 264 >quoted
 265    identifier</I
 266 >, a <I
 267 CLASS="FIRSTTERM"
 268 >literal</I
 269 > (or
 270    constant), or a special character symbol.  Tokens are normally
 271    separated by whitespace (space, tab, newline), but need not be if
 272    there is no ambiguity (which is generally only the case if a
 273    special character is adjacent to some other token type).
 274   </P
 275 ><P
 276 >   Additionally, <I
 277 CLASS="FIRSTTERM"
 278 >comments</I
 279 > can occur in SQL
 280    input.  They are not tokens, they are effectively equivalent to
 281    whitespace.
 282   </P
 283 ><P
 284 >    For example, the following is (syntactically) valid SQL input:
 285 </P><PRE
 286 CLASS="PROGRAMLISTING"
 287 >SELECT * FROM MY_TABLE;
 288 UPDATE MY_TABLE SET A = 5;
 289 INSERT INTO MY_TABLE VALUES (3, 'hi there');</PRE
 290 ><P>
 291     This is a sequence of three commands, one per line (although this
 292     is not required; more than one command can be on a line, and
 293     commands can usefully be split across lines).
 294    </P
 295 ><P
 296 >   The SQL syntax is not very consistent regarding what tokens
 297    identify commands and which are operands or parameters.  The first
 298    few tokens are generally the command name, so in the above example
 299    we would usually speak of a <SPAN
 300 CLASS="QUOTE"
 301 >"SELECT"</SPAN
 302 >, an
 303    <SPAN
 304 CLASS="QUOTE"
 305 >"UPDATE"</SPAN
 306 >, and an <SPAN
 307 CLASS="QUOTE"
 308 >"INSERT"</SPAN
 309 > command.  But
 310    for instance the <TT
 311 CLASS="COMMAND"
 312 >UPDATE</TT
 313 > command always requires
 314    a <TT
 315 CLASS="TOKEN"
 316 >SET</TT
 317 > token to appear in a certain position, and
 318    this particular variation of <TT
 319 CLASS="COMMAND"
 320 >INSERT</TT
 321 > also
 322    requires a <TT
 323 CLASS="TOKEN"
 324 >VALUES</TT
 325 > in order to be complete.  The
 326    precise syntax rules for each command are described in <A
 327 HREF="reference.html"
 328 >Part VI</A
 329 >.
 330   </P
 331 ><DIV
 332 CLASS="SECT2"
 333 ><H2
 334 CLASS="SECT2"
 335 ><A
 336 NAME="SQL-SYNTAX-IDENTIFIERS"
 337 >4.1.1. Identifiers and Key Words</A
 338 ></H2
 339 ><A
 340 NAME="AEN1048"
 341 ></A
 342 ><A
 343 NAME="AEN1051"
 344 ></A
 345 ><A
 346 NAME="AEN1054"
 347 ></A
 348 ><P
 349 >    Tokens such as <TT
 350 CLASS="TOKEN"
 351 >SELECT</TT
 352 >, <TT
 353 CLASS="TOKEN"
 354 >UPDATE</TT
 355 >, or
 356     <TT
 357 CLASS="TOKEN"
 358 >VALUES</TT
 359 > in the example above are examples of
 360     <I
 361 CLASS="FIRSTTERM"
 362 >key words</I
 363 >, that is, words that have a fixed
 364     meaning in the SQL language.  The tokens <TT
 365 CLASS="TOKEN"
 366 >MY_TABLE</TT
 367 >
 368     and <TT
 369 CLASS="TOKEN"
 370 >A</TT
 371 > are examples of
 372     <I
 373 CLASS="FIRSTTERM"
 374 >identifiers</I
 375 >.  They identify names of
 376     tables, columns, or other database objects, depending on the
 377     command they are used in.  Therefore they are sometimes simply
 378     called <SPAN
 379 CLASS="QUOTE"
 380 >"names"</SPAN
 381 >.  Key words and identifiers have the
 382     same lexical structure, meaning that one cannot know whether a
 383     token is an identifier or a key word without knowing the language.
 384     A complete list of key words can be found in <A
 385 HREF="sql-keywords-appendix.html"
 386 >Appendix C</A
 387 >.
 388    </P
 389 ><P
 390 >    SQL identifiers and key words must begin with a letter
 391     (<TT
 392 CLASS="LITERAL"
 393 >a</TT
 394 >-<TT
 395 CLASS="LITERAL"
 396 >z</TT
 397 >, but also letters with
 398     diacritical marks and non-Latin letters) or an underscore
 399     (<TT
 400 CLASS="LITERAL"
 401 >_</TT
 402 >).  Subsequent characters in an identifier or
 403     key word can be letters, underscores, digits
 404     (<TT
 405 CLASS="LITERAL"
 406 >0</TT
 407 >-<TT
 408 CLASS="LITERAL"
 409 >9</TT
 410 >), or dollar signs
 411     (<TT
 412 CLASS="LITERAL"
 413 >$</TT
 414 >).  Note that dollar signs are not allowed in identifiers
 415     according to the letter of the SQL standard, so their use may render
 416     applications less portable.
 417     The SQL standard will not define a key word that contains
 418     digits or starts or ends with an underscore, so identifiers of this
 419     form are safe against possible conflict with future extensions of the
 420     standard.
 421    </P
 422 ><P
 423 >    <A
 424 NAME="AEN1075"
 425 ></A
 426 >
 427     The system uses no more than <TT
 428 CLASS="SYMBOL"
 429 >NAMEDATALEN</TT
 430 >-1
 431     characters of an identifier; longer names can be written in
 432     commands, but they will be truncated.  By default,
 433     <TT
 434 CLASS="SYMBOL"
 435 >NAMEDATALEN</TT
 436 > is 64 so the maximum identifier
 437     length is 63. If this limit is problematic, it can be raised by
 438     changing the <TT
 439 CLASS="SYMBOL"
 440 >NAMEDATALEN</TT
 441 > constant in
 442     <TT
 443 CLASS="FILENAME"
 444 >src/include/postgres_ext.h</TT
 445 >.
 446    </P
 447 ><P
 448 >    <A
 449 NAME="AEN1083"
 450 ></A
 451 >
 452     Identifier and key word names are case insensitive.  Therefore
 453 </P><PRE
 454 CLASS="PROGRAMLISTING"
 455 >UPDATE MY_TABLE SET A = 5;</PRE
 456 ><P>
 457     can equivalently be written as
 458 </P><PRE
 459 CLASS="PROGRAMLISTING"
 460 >uPDaTE my_TabLE SeT a = 5;</PRE
 461 ><P>
 462     A convention often used is to write key words in upper
 463     case and names in lower case, e.g.,
 464 </P><PRE
 465 CLASS="PROGRAMLISTING"
 466 >UPDATE my_table SET a = 5;</PRE
 467 ><P>
 468    </P
 469 ><P
 470 >    <A
 471 NAME="AEN1090"
 472 ></A
 473 >
 474     There is a second kind of identifier:  the <I
 475 CLASS="FIRSTTERM"
 476 >delimited
 477     identifier</I
 478 > or <I
 479 CLASS="FIRSTTERM"
 480 >quoted
 481     identifier</I
 482 >.  It is formed by enclosing an arbitrary
 483     sequence of characters in double-quotes
 484     (<TT
 485 CLASS="LITERAL"
 486 >"</TT
 487 >).  A delimited
 488     identifier is always an identifier, never a key word.  So
 489     <TT
 490 CLASS="LITERAL"
 491 >"select"</TT
 492 > could be used to refer to a column or
 493     table named <SPAN
 494 CLASS="QUOTE"
 495 >"select"</SPAN
 496 >, whereas an unquoted
 497     <TT
 498 CLASS="LITERAL"
 499 >select</TT
 500 > would be taken as a key word and
 501     would therefore provoke a parse error when used where a table or
 502     column name is expected.  The example can be written with quoted
 503     identifiers like this:
 504 </P><PRE
 505 CLASS="PROGRAMLISTING"
 506 >UPDATE "my_table" SET "a" = 5;</PRE
 507 ><P>
 508    </P
 509 ><P
 510 >    Quoted identifiers can contain any character other than a double
 511     quote itself.  (To include a double quote, write two double quotes.)
 512     This allows constructing table or column names that would
 513     otherwise not be possible, such as ones containing spaces or
 514     ampersands.  The length limitation still applies.
 515    </P
 516 ><P
 517 >    Quoting an identifier also makes it case-sensitive, whereas
 518     unquoted names are always folded to lower case.  For example, the
 519     identifiers <TT
 520 CLASS="LITERAL"
 521 >FOO</TT
 522 >, <TT
 523 CLASS="LITERAL"
 524 >foo</TT
 525 >, and
 526     <TT
 527 CLASS="LITERAL"
 528 >"foo"</TT
 529 > are considered the same by
 530     <SPAN
 531 CLASS="PRODUCTNAME"
 532 >PostgreSQL</SPAN
 533 >, but
 534     <TT
 535 CLASS="LITERAL"
 536 >"Foo"</TT
 537 > and <TT
 538 CLASS="LITERAL"
 539 >"FOO"</TT
 540 > are
 541     different from these three and each other.  (The folding of
 542     unquoted names to lower case in <SPAN
 543 CLASS="PRODUCTNAME"
 544 >PostgreSQL</SPAN
 545 > is
 546     incompatible with the SQL standard, which says that unquoted names
 547     should be folded to upper case.  Thus, <TT
 548 CLASS="LITERAL"
 549 >foo</TT
 550 >
 551     should be equivalent to <TT
 552 CLASS="LITERAL"
 553 >"FOO"</TT
 554 > not
 555     <TT
 556 CLASS="LITERAL"
 557 >"foo"</TT
 558 > according to the standard.  If you want
 559     to write portable applications you are advised to always quote a
 560     particular name or never quote it.)
 561    </P
 562 ></DIV
 563 ><DIV
 564 CLASS="SECT2"
 565 ><H2
 566 CLASS="SECT2"
 567 ><A
 568 NAME="SQL-SYNTAX-CONSTANTS"
 569 >4.1.2. Constants</A
 570 ></H2
 571 ><A
 572 NAME="AEN1114"
 573 ></A
 574 ><P
 575 >    There are three kinds of <I
 576 CLASS="FIRSTTERM"
 577 >implicitly-typed
 578     constants</I
 579 > in <SPAN
 580 CLASS="PRODUCTNAME"
 581 >PostgreSQL</SPAN
 582 >:
 583     strings, bit strings, and numbers.
 584     Constants can also be specified with explicit types, which can
 585     enable more accurate representation and more efficient handling by
 586     the system. The implicit constants are described below; explicit
 587     constants are discussed afterwards.
 588    </P
 589 ><DIV
 590 CLASS="SECT3"
 591 ><H3
 592 CLASS="SECT3"
 593 ><A
 594 NAME="SQL-SYNTAX-STRINGS"
 595 >4.1.2.1. String Constants</A
 596 ></H3
 597 ><A
 598 NAME="AEN1121"
 599 ></A
 600 ><P
 601 >     <A
 602 NAME="AEN1125"
 603 ></A
 604 >
 605      A string constant in SQL is an arbitrary sequence of characters
 606      bounded by single quotes (<TT
 607 CLASS="LITERAL"
 608 >'</TT
 609 >), e.g., <TT
 610 CLASS="LITERAL"
 611 >'This
 612      is a string'</TT
 613 >.  SQL allows single quotes to be embedded
 614      in strings by typing two adjacent single quotes, e.g.,
 615      <TT
 616 CLASS="LITERAL"
 617 >'Dianne''s horse'</TT
 618 >.  In
 619      <SPAN
 620 CLASS="PRODUCTNAME"
 621 >PostgreSQL</SPAN
 622 > single quotes may
 623      alternatively be escaped with a backslash (<TT
 624 CLASS="LITERAL"
 625 >\</TT
 626 >),
 627      e.g., <TT
 628 CLASS="LITERAL"
 629 >'Dianne\'s horse'</TT
 630 >.
 631     </P
 632 ><P
 633 >     C-style backslash escapes are also available:
 634      <TT
 635 CLASS="LITERAL"
 636 >\b</TT
 637 > is a backspace, <TT
 638 CLASS="LITERAL"
 639 >\f</TT
 640 > is a
 641      form feed, <TT
 642 CLASS="LITERAL"
 643 >\n</TT
 644 > is a newline,
 645      <TT
 646 CLASS="LITERAL"
 647 >\r</TT
 648 > is a carriage return, <TT
 649 CLASS="LITERAL"
 650 >\t</TT
 651 >
 652      is a tab, and <TT
 653 CLASS="LITERAL"
 654 >\<VAR
 655 CLASS="REPLACEABLE"
 656 >xxx</VAR
 657 ></TT
 658 >,
 659      where <VAR
 660 CLASS="REPLACEABLE"
 661 >xxx</VAR
 662 > is an octal number, is a
 663      byte with the corresponding code.  (It is your responsibility
 664      that the byte sequences you create are valid characters in the
 665      server character set encoding.)  Any other character following a
 666      backslash is taken literally.  Thus, to include a backslash in a
 667      string constant, type two backslashes.
 668     </P
 669 ><P
 670 >     The character with the code zero cannot be in a string constant.
 671     </P
 672 ><P
 673 >     Two string constants that are only separated by whitespace
 674      <SPAN
 675 CLASS="emphasis"
 676 ><I
 677 CLASS="EMPHASIS"
 678 >with at least one newline</I
 679 ></SPAN
 680 > are concatenated
 681      and effectively treated as if the string had been written in one
 682      constant.  For example:
 683 </P><PRE
 684 CLASS="PROGRAMLISTING"
 685 >SELECT 'foo'
 686 'bar';</PRE
 687 ><P>
 688      is equivalent to
 689 </P><PRE
 690 CLASS="PROGRAMLISTING"
 691 >SELECT 'foobar';</PRE
 692 ><P>
 693      but
 694 </P><PRE
 695 CLASS="PROGRAMLISTING"
 696 >SELECT 'foo'      'bar';</PRE
 697 ><P>
 698      is not valid syntax.  (This slightly bizarre behavior is specified
 699      by <ACRONYM
 700 CLASS="ACRONYM"
 701 >SQL</ACRONYM
 702 >; <SPAN
 703 CLASS="PRODUCTNAME"
 704 >PostgreSQL</SPAN
 705 > is
 706      following the standard.)
 707     </P
 708 ></DIV
 709 ><DIV
 710 CLASS="SECT3"
 711 ><H3
 712 CLASS="SECT3"
 713 ><A
 714 NAME="SQL-SYNTAX-BIT-STRINGS"
 715 >4.1.2.2. Bit-String Constants</A
 716 ></H3
 717 ><A
 718 NAME="AEN1153"
 719 ></A
 720 ><P
 721 >     Bit-string constants look like string constants with a
 722      <TT
 723 CLASS="LITERAL"
 724 >B</TT
 725 > (upper or lower case) immediately before the
 726      opening quote (no intervening whitespace), e.g.,
 727      <TT
 728 CLASS="LITERAL"
 729 >B'1001'</TT
 730 >.  The only characters allowed within
 731      bit-string constants are <TT
 732 CLASS="LITERAL"
 733 >0</TT
 734 > and
 735      <TT
 736 CLASS="LITERAL"
 737 >1</TT
 738 >.
 739     </P
 740 ><P
 741 >     Alternatively, bit-string constants can be specified in hexadecimal
 742      notation, using a leading <TT
 743 CLASS="LITERAL"
 744 >X</TT
 745 > (upper or lower case),
 746      e.g., <TT
 747 CLASS="LITERAL"
 748 >X'1FF'</TT
 749 >.  This notation is equivalent to
 750      a bit-string constant with four binary digits for each hexadecimal digit.
 751     </P
 752 ><P
 753 >     Both forms of bit-string constant can be continued
 754      across lines in the same way as regular string constants.
 755     </P
 756 ></DIV
 757 ><DIV
 758 CLASS="SECT3"
 759 ><H3
 760 CLASS="SECT3"
 761 ><A
 762 NAME="AEN1165"
 763 >4.1.2.3. Numeric Constants</A
 764 ></H3
 765 ><A
 766 NAME="AEN1167"
 767 ></A
 768 ><P
 769 >     Numeric constants are accepted in these general forms:
 770 </P><PRE
 771 CLASS="SYNOPSIS"
 772 ><VAR
 773 CLASS="REPLACEABLE"
 774 >digits</VAR
 775 >
 776 <VAR
 777 CLASS="REPLACEABLE"
 778 >digits</VAR
 779 >.[<SPAN
 780 CLASS="OPTIONAL"
 781 ><VAR
 782 CLASS="REPLACEABLE"
 783 >digits</VAR
 784 ></SPAN
 785 >][<SPAN
 786 CLASS="OPTIONAL"
 787 >e[<SPAN
 788 CLASS="OPTIONAL"
 789 >+-</SPAN
 790 >]<VAR
 791 CLASS="REPLACEABLE"
 792 >digits</VAR
 793 ></SPAN
 794 >]
 795 [<SPAN
 796 CLASS="OPTIONAL"
 797 ><VAR
 798 CLASS="REPLACEABLE"
 799 >digits</VAR
 800 ></SPAN
 801 >].<VAR
 802 CLASS="REPLACEABLE"
 803 >digits</VAR
 804 >[<SPAN
 805 CLASS="OPTIONAL"
 806 >e[<SPAN
 807 CLASS="OPTIONAL"
 808 >+-</SPAN
 809 >]<VAR
 810 CLASS="REPLACEABLE"
 811 >digits</VAR
 812 ></SPAN
 813 >]
 814 <VAR
 815 CLASS="REPLACEABLE"
 816 >digits</VAR
 817 >e[<SPAN
 818 CLASS="OPTIONAL"
 819 >+-</SPAN
 820 >]<VAR
 821 CLASS="REPLACEABLE"
 822 >digits</VAR
 823 ></PRE
 824 ><P>
 825      where <VAR
 826 CLASS="REPLACEABLE"
 827 >digits</VAR
 828 > is one or more decimal
 829      digits (0 through 9).  At least one digit must be before or after the
 830      decimal point, if one is used.  At least one digit must follow the
 831      exponent marker (<TT
 832 CLASS="LITERAL"
 833 >e</TT
 834 >), if one is present.
 835      There may not be any spaces or other characters embedded in the
 836      constant.  Note that any leading plus or minus sign is not actually
 837      considered part of the constant; it is an operator applied to the
 838      constant.
 839     </P
 840 ><P
 841 >     These are some examples of valid numeric constants:
 842 <P
 843 CLASS="LITERALLAYOUT"
 844 >42<br>
 845 3.5<br>
 846 4.<br>
 847 .001<br>
 848 5e2<br>
 849 1.925e-3</P
 850 >
 851     </P
 852 ><P
 853 >     <A
 854 NAME="AEN1193"
 855 ></A
 856 >
 857      <A
 858 NAME="AEN1195"
 859 ></A
 860 >
 861      <A
 862 NAME="AEN1197"
 863 ></A
 864 >
 865      A numeric constant that contains neither a decimal point nor an
 866      exponent is initially presumed to be type <TT
 867 CLASS="TYPE"
 868 >integer</TT
 869 > if its
 870      value fits in type <TT
 871 CLASS="TYPE"
 872 >integer</TT
 873 > (32 bits); otherwise it is
 874      presumed to be type <TT
 875 CLASS="TYPE"
 876 >bigint</TT
 877 > if its
 878      value fits in type <TT
 879 CLASS="TYPE"
 880 >bigint</TT
 881 > (64 bits); otherwise it is
 882      taken to be type <TT
 883 CLASS="TYPE"
 884 >numeric</TT
 885 >.  Constants that contain      decimal
 886      points and/or exponents are always initially presumed to be type
 887      <TT
 888 CLASS="TYPE"
 889 >numeric</TT
 890 >.
 891     </P
 892 ><P
 893 >     The initially assigned data type of a numeric constant is just a
 894      starting point for the type resolution algorithms.  In most cases
 895      the constant will be automatically coerced to the most
 896      appropriate type depending on context.  When necessary, you can
 897      force a numeric value to be interpreted as a specific data type
 898      by casting it.<A
 899 NAME="AEN1206"
 900 ></A
 901 >
 902      For example, you can force a numeric value to be treated as type
 903      <TT
 904 CLASS="TYPE"
 905 >real</TT
 906 > (<TT
 907 CLASS="TYPE"
 908 >float4</TT
 909 >) by writing
 910
 911 </P><PRE
 912 CLASS="PROGRAMLISTING"
 913 >REAL '1.23'  -- string style
 914 1.23::REAL   -- PostgreSQL (historical) style</PRE
 915 ><P>
 916      </P
 917 ></DIV
 918 ><DIV
 919 CLASS="SECT3"
 920 ><H3
 921 CLASS="SECT3"
 922 ><A
 923 NAME="SQL-SYNTAX-CONSTANTS-GENERIC"
 924 >4.1.2.4. Constants of Other Types</A
 925 ></H3
 926 ><A
 927 NAME="AEN1213"
 928 ></A
 929 ><P
 930 >     A constant of an <SPAN
 931 CLASS="emphasis"
 932 ><I
 933 CLASS="EMPHASIS"
 934 >arbitrary</I
 935 ></SPAN
 936 > type can be
 937      entered using any one of the following notations:
 938 </P><PRE
 939 CLASS="SYNOPSIS"
 940 ><VAR
 941 CLASS="REPLACEABLE"
 942 >type</VAR
 943 > '<VAR
 944 CLASS="REPLACEABLE"
 945 >string</VAR
 946 >'
 947 '<VAR
 948 CLASS="REPLACEABLE"
 949 >string</VAR
 950 >'::<VAR
 951 CLASS="REPLACEABLE"
 952 >type</VAR
 953 >
 954 CAST ( '<VAR
 955 CLASS="REPLACEABLE"
 956 >string</VAR
 957 >' AS <VAR
 958 CLASS="REPLACEABLE"
 959 >type</VAR
 960 > )</PRE
 961 ><P>
 962      The string's text is passed to the input conversion
 963      routine for the type called <VAR
 964 CLASS="REPLACEABLE"
 965 >type</VAR
 966 >. The
 967      result is a constant of the indicated type.  The explicit type
 968      cast may be omitted if there is no ambiguity as to the type the
 969      constant must be (for example, when it is passed as an argument
 970      to a non-overloaded function), in which case it is automatically
 971      coerced.
 972     </P
 973 ><P
 974 >     It is also possible to specify a type coercion using a function-like
 975      syntax:
 976 </P><PRE
 977 CLASS="SYNOPSIS"
 978 ><VAR
 979 CLASS="REPLACEABLE"
 980 >typename</VAR
 981 > ( '<VAR
 982 CLASS="REPLACEABLE"
 983 >string</VAR
 984 >' )</PRE
 985 ><P>
 986      but not all type names may be used in this way; see <A
 987 HREF="sql-expressions.html#SQL-SYNTAX-TYPE-CASTS"
 988 >Section 4.2.8</A
 989 > for details.
 990     </P
 991 ><P
 992 >     The <TT
 993 CLASS="LITERAL"
 994 >::</TT
 995 >, <TT
 996 CLASS="LITERAL"
 997 >CAST()</TT
 998 >, and
 999      function-call syntaxes can also be used to specify run-time type
1000      conversions of arbitrary expressions, as discussed in <A
1001 HREF="sql-expressions.html#SQL-SYNTAX-TYPE-CASTS"
1002 >Section 4.2.8</A
1003 >.  But the form
1004      <TT
1005 CLASS="LITERAL"
1006 ><VAR
1007 CLASS="REPLACEABLE"
1008 >type</VAR
1009 > '<VAR
1010 CLASS="REPLACEABLE"
1011 >string</VAR
1012 >'</TT
1013 >
1014      can only be used to specify the type of a literal constant.
1015      Another restriction on
1016      <TT
1017 CLASS="LITERAL"
1018 ><VAR
1019 CLASS="REPLACEABLE"
1020 >type</VAR
1021 > '<VAR
1022 CLASS="REPLACEABLE"
1023 >string</VAR
1024 >'</TT
1025 >
1026      is that it does not work for array types; use <TT
1027 CLASS="LITERAL"
1028 >::</TT
1029 >
1030      or <TT
1031 CLASS="LITERAL"
1032 >CAST()</TT
1033 > to specify the type of an array constant.
1034     </P
1035 ></DIV
1036 ></DIV
1037 ><DIV
1038 CLASS="SECT2"
1039 ><H2
1040 CLASS="SECT2"
1041 ><A
1042 NAME="SQL-SYNTAX-OPERATORS"
1043 >4.1.3. Operators</A
1044 ></H2
1045 ><A
1046 NAME="AEN1245"
1047 ></A
1048 ><P
1049 >    An operator name is a sequence of up to <TT
1050 CLASS="SYMBOL"
1051 >NAMEDATALEN</TT
1052 >-1
1053     (63 by default) characters from the following list:
1054 <P
1055 CLASS="LITERALLAYOUT"
1056 >+&nbsp;-&nbsp;*&nbsp;/&nbsp;&lt;&nbsp;&gt;&nbsp;=&nbsp;~&nbsp;!&nbsp;@&nbsp;#&nbsp;%&nbsp;^&nbsp;&amp;&nbsp;|&nbsp;`&nbsp;?</P
1057 >
1058
1059     There are a few restrictions on operator names, however:
1060     <P
1061 ></P
1062 ></P><UL
1063 ><LI
1064 ><P
1065 >       <TT
1066 CLASS="LITERAL"
1067 >--</TT
1068 > and <TT
1069 CLASS="LITERAL"
1070 >/*</TT
1071 > cannot appear
1072        anywhere in an operator name, since they will be taken as the
1073        start of a comment.
1074       </P
1075 ></LI
1076 ><LI
1077 ><P
1078 >       A multiple-character operator name cannot end in <TT
1079 CLASS="LITERAL"
1080 >+</TT
1081 > or <TT
1082 CLASS="LITERAL"
1083 >-</TT
1084 >,
1085        unless the name also contains at least one of these characters:
1086 <P
1087 CLASS="LITERALLAYOUT"
1088 >~&nbsp;!&nbsp;@&nbsp;#&nbsp;%&nbsp;^&nbsp;&amp;&nbsp;|&nbsp;`&nbsp;?</P
1089 >
1090        For example, <TT
1091 CLASS="LITERAL"
1092 >@-</TT
1093 > is an allowed operator name,
1094        but <TT
1095 CLASS="LITERAL"
1096 >*-</TT
1097 > is not.  This restriction allows
1098        <SPAN
1099 CLASS="PRODUCTNAME"
1100 >PostgreSQL</SPAN
1101 > to parse SQL-compliant
1102        queries without requiring spaces between tokens.
1103       </P
1104 ></LI
1105 ></UL
1106 ><P>
1107    </P
1108 ><P
1109 >    When working with non-SQL-standard operator names, you will usually
1110     need to separate adjacent operators with spaces to avoid ambiguity.
1111     For example, if you have defined a left unary operator named <TT
1112 CLASS="LITERAL"
1113 >@</TT
1114 >,
1115     you cannot write <TT
1116 CLASS="LITERAL"
1117 >X*@Y</TT
1118 >; you must write
1119     <TT
1120 CLASS="LITERAL"
1121 >X* @Y</TT
1122 > to ensure that
1123     <SPAN
1124 CLASS="PRODUCTNAME"
1125 >PostgreSQL</SPAN
1126 > reads it as two operator names
1127     not one.
1128    </P
1129 ></DIV
1130 ><DIV
1131 CLASS="SECT2"
1132 ><H2
1133 CLASS="SECT2"
1134 ><A
1135 NAME="AEN1269"
1136 >4.1.4. Special Characters</A
1137 ></H2
1138 ><P
1139 >   Some characters that are not alphanumeric have a special meaning
1140    that is different from being an operator.  Details on the usage can
1141    be found at the location where the respective syntax element is
1142    described.  This section only exists to advise the existence and
1143    summarize the purposes of these characters.
1144
1145    <P
1146 ></P
1147 ></P><UL
1148 ><LI
1149 ><P
1150 >      A dollar sign (<TT
1151 CLASS="LITERAL"
1152 >$</TT
1153 >) followed by digits is used
1154       to represent a positional parameter in the body of a function
1155       definition or a prepared statement.  In other contexts the
1156       dollar sign may be part of an identifier.
1157      </P
1158 ></LI
1159 ><LI
1160 ><P
1161 >      Parentheses (<TT
1162 CLASS="LITERAL"
1163 >()</TT
1164 >) have their usual meaning to
1165       group expressions and enforce precedence.  In some cases
1166       parentheses are required as part of the fixed syntax of a
1167       particular SQL command.
1168      </P
1169 ></LI
1170 ><LI
1171 ><P
1172 >      Brackets (<TT
1173 CLASS="LITERAL"
1174 >[]</TT
1175 >) are used to select the elements
1176       of an array.  See <A
1177 HREF="arrays.html"
1178 >Section 8.10</A
1179 > for more information
1180       on arrays.
1181      </P
1182 ></LI
1183 ><LI
1184 ><P
1185 >      Commas (<TT
1186 CLASS="LITERAL"
1187 >,</TT
1188 >) are used in some syntactical
1189       constructs to separate the elements of a list.
1190      </P
1191 ></LI
1192 ><LI
1193 ><P
1194 >      The semicolon (<TT
1195 CLASS="LITERAL"
1196 >;</TT
1197 >) terminates an SQL command.
1198       It cannot appear anywhere within a command, except within a
1199       string constant or quoted identifier.
1200      </P
1201 ></LI
1202 ><LI
1203 ><P
1204 >      The colon (<TT
1205 CLASS="LITERAL"
1206 >:</TT
1207 >) is used to select
1208       <SPAN
1209 CLASS="QUOTE"
1210 >"slices"</SPAN
1211 > from arrays. (See <A
1212 HREF="arrays.html"
1213 >Section 8.10</A
1214 >.)  In certain SQL dialects (such as Embedded
1215       SQL), the colon is used to prefix variable names.
1216      </P
1217 ></LI
1218 ><LI
1219 ><P
1220 >      The asterisk (<TT
1221 CLASS="LITERAL"
1222 >*</TT
1223 >) has a special meaning when
1224       used in the <TT
1225 CLASS="COMMAND"
1226 >SELECT</TT
1227 > command or with the
1228       <CODE
1229 CLASS="FUNCTION"
1230 >COUNT</CODE
1231 > aggregate function.
1232      </P
1233 ></LI
1234 ><LI
1235 ><P
1236 >      The period (<TT
1237 CLASS="LITERAL"
1238 >.</TT
1239 >) is used in numeric
1240       constants, and to separate schema, table, and column names.
1241      </P
1242 ></LI
1243 ></UL
1244 ><P>
1245
1246    </P
1247 ></DIV
1248 ><DIV
1249 CLASS="SECT2"
1250 ><H2
1251 CLASS="SECT2"
1252 ><A
1253 NAME="SQL-SYNTAX-COMMENTS"
1254 >4.1.5. Comments</A
1255 ></H2
1256 ><A
1257 NAME="AEN1304"
1258 ></A
1259 ><P
1260 >    A comment is an arbitrary sequence of characters beginning with
1261     double dashes and extending to the end of the line, e.g.:
1262 </P><PRE
1263 CLASS="PROGRAMLISTING"
1264 >-- This is a standard SQL comment</PRE
1265 ><P>
1266    </P
1267 ><P
1268 >    Alternatively, C-style block comments can be used:
1269 </P><PRE
1270 CLASS="PROGRAMLISTING"
1271 >/* multiline comment
1272  * with nesting: /* nested block comment */
1273  */</PRE
1274 ><P>
1275     where the comment begins with <TT
1276 CLASS="LITERAL"
1277 >/*</TT
1278 > and extends to
1279     the matching occurrence of <TT
1280 CLASS="LITERAL"
1281 >*/</TT
1282 >. These block
1283     comments nest, as specified in the SQL standard but unlike C, so that one can
1284     comment out larger blocks of code that may contain existing block
1285     comments.
1286    </P
1287 ><P
1288 >    A comment is removed from the input stream before further syntax
1289     analysis and is effectively replaced by whitespace.
1290    </P
1291 ></DIV
1292 ><DIV
1293 CLASS="SECT2"
1294 ><H2
1295 CLASS="SECT2"
1296 ><A
1297 NAME="SQL-PRECEDENCE"
1298 >4.1.6. Lexical Precedence</A
1299 ></H2
1300 ><A
1301 NAME="AEN1316"
1302 ></A
1303 ><P
1304 >    <A
1305 HREF="sql-syntax.html#SQL-PRECEDENCE-TABLE"
1306 >Table 4-1</A
1307 > shows the precedence and
1308     associativity of the operators in <SPAN
1309 CLASS="PRODUCTNAME"
1310 >PostgreSQL</SPAN
1311 >.
1312     Most operators have the same precedence and are left-associative.
1313     The precedence and associativity of the operators is hard-wired
1314     into the parser.  This may lead to non-intuitive behavior; for
1315     example the Boolean operators <TT
1316 CLASS="LITERAL"
1317 >&lt;</TT
1318 > and
1319     <TT
1320 CLASS="LITERAL"
1321 >&gt;</TT
1322 > have a different precedence than the Boolean
1323     operators <TT
1324 CLASS="LITERAL"
1325 >&lt;=</TT
1326 > and <TT
1327 CLASS="LITERAL"
1328 >&gt;=</TT
1329 >.  Also, you will
1330     sometimes need to add parentheses when using combinations of
1331     binary and unary operators.  For instance
1332 </P><PRE
1333 CLASS="PROGRAMLISTING"
1334 >SELECT 5 ! - 6;</PRE
1335 ><P>
1336    will be parsed as
1337 </P><PRE
1338 CLASS="PROGRAMLISTING"
1339 >SELECT 5 ! (- 6);</PRE
1340 ><P>
1341     because the parser has no idea -- until it is too late -- that
1342     <TT
1343 CLASS="TOKEN"
1344 >!</TT
1345 > is defined as a postfix operator, not an infix one.
1346     To get the desired behavior in this case, you must write
1347 </P><PRE
1348 CLASS="PROGRAMLISTING"
1349 >SELECT (5 !) - 6;</PRE
1350 ><P>
1351     This is the price one pays for extensibility.
1352    </P
1353 ><DIV
1354 CLASS="TABLE"
1355 ><A
1356 NAME="SQL-PRECEDENCE-TABLE"
1357 ></A
1358 ><P
1359 ><B
1360 >Table 4-1. Operator Precedence (decreasing)</B
1361 ></P
1362 ><TABLE
1363 BORDER="1"
1364 CLASS="CALSTABLE"
1365 ><COL><COL><COL><THEAD
1366 ><TR
1367 ><TH
1368 >Operator/Element</TH
1369 ><TH
1370 >Associativity</TH
1371 ><TH
1372 >Description</TH
1373 ></TR
1374 ></THEAD
1375 ><TBODY
1376 ><TR
1377 ><TD
1378 ><TT
1379 CLASS="TOKEN"
1380 >.</TT
1381 ></TD
1382 ><TD
1383 >left</TD
1384 ><TD
1385 >table/column name separator</TD
1386 ></TR
1387 ><TR
1388 ><TD
1389 ><TT
1390 CLASS="TOKEN"
1391 >::</TT
1392 ></TD
1393 ><TD
1394 >left</TD
1395 ><TD
1396 ><SPAN
1397 CLASS="PRODUCTNAME"
1398 >PostgreSQL</SPAN
1399 >-style typecast</TD
1400 ></TR
1401 ><TR
1402 ><TD
1403 ><TT
1404 CLASS="TOKEN"
1405 >[</TT
1406 > <TT
1407 CLASS="TOKEN"
1408 >]</TT
1409 ></TD
1410 ><TD
1411 >left</TD
1412 ><TD
1413 >array element selection</TD
1414 ></TR
1415 ><TR
1416 ><TD
1417 ><TT
1418 CLASS="TOKEN"
1419 >-</TT
1420 ></TD
1421 ><TD
1422 >right</TD
1423 ><TD
1424 >unary minus</TD
1425 ></TR
1426 ><TR
1427 ><TD
1428 ><TT
1429 CLASS="TOKEN"
1430 >^</TT
1431 ></TD
1432 ><TD
1433 >left</TD
1434 ><TD
1435 >exponentiation</TD
1436 ></TR
1437 ><TR
1438 ><TD
1439 ><TT
1440 CLASS="TOKEN"
1441 >*</TT
1442 > <TT
1443 CLASS="TOKEN"
1444 >/</TT
1445 > <TT
1446 CLASS="TOKEN"
1447 >%</TT
1448 ></TD
1449 ><TD
1450 >left</TD
1451 ><TD
1452 >multiplication, division, modulo</TD
1453 ></TR
1454 ><TR
1455 ><TD
1456 ><TT
1457 CLASS="TOKEN"
1458 >+</TT
1459 > <TT
1460 CLASS="TOKEN"
1461 >-</TT
1462 ></TD
1463 ><TD
1464 >left</TD
1465 ><TD
1466 >addition, subtraction</TD
1467 ></TR
1468 ><TR
1469 ><TD
1470 ><TT
1471 CLASS="TOKEN"
1472 >IS</TT
1473 ></TD
1474 ><TD
1475 >&nbsp;</TD
1476 ><TD
1477 ><TT
1478 CLASS="LITERAL"
1479 >IS TRUE</TT
1480 >, <TT
1481 CLASS="LITERAL"
1482 >IS FALSE</TT
1483 >, <TT
1484 CLASS="LITERAL"
1485 >IS UNKNOWN</TT
1486 >, <TT
1487 CLASS="LITERAL"
1488 >IS NULL</TT
1489 ></TD
1490 ></TR
1491 ><TR
1492 ><TD
1493 ><TT
1494 CLASS="TOKEN"
1495 >ISNULL</TT
1496 ></TD
1497 ><TD
1498 >&nbsp;</TD
1499 ><TD
1500 >test for null</TD
1501 ></TR
1502 ><TR
1503 ><TD
1504 ><TT
1505 CLASS="TOKEN"
1506 >NOTNULL</TT
1507 ></TD
1508 ><TD
1509 >&nbsp;</TD
1510 ><TD
1511 >test for not null</TD
1512 ></TR
1513 ><TR
1514 ><TD
1515 >(any other)</TD
1516 ><TD
1517 >left</TD
1518 ><TD
1519 >all other native and user-defined operators</TD
1520 ></TR
1521 ><TR
1522 ><TD
1523 ><TT
1524 CLASS="TOKEN"
1525 >IN</TT
1526 ></TD
1527 ><TD
1528 >&nbsp;</TD
1529 ><TD
1530 >set membership</TD
1531 ></TR
1532 ><TR
1533 ><TD
1534 ><TT
1535 CLASS="TOKEN"
1536 >BETWEEN</TT
1537 ></TD
1538 ><TD
1539 >&nbsp;</TD
1540 ><TD
1541 >containment</TD
1542 ></TR
1543 ><TR
1544 ><TD
1545 ><TT
1546 CLASS="TOKEN"
1547 >OVERLAPS</TT
1548 ></TD
1549 ><TD
1550 >&nbsp;</TD
1551 ><TD
1552 >time interval overlap</TD
1553 ></TR
1554 ><TR
1555 ><TD
1556 ><TT
1557 CLASS="TOKEN"
1558 >LIKE</TT
1559 > <TT
1560 CLASS="TOKEN"
1561 >ILIKE</TT
1562 > <TT
1563 CLASS="TOKEN"
1564 >SIMILAR</TT
1565 ></TD
1566 ><TD
1567 >&nbsp;</TD
1568 ><TD
1569 >string pattern matching</TD
1570 ></TR
1571 ><TR
1572 ><TD
1573 ><TT
1574 CLASS="TOKEN"
1575 >&lt;</TT
1576 > <TT
1577 CLASS="TOKEN"
1578 >&gt;</TT
1579 ></TD
1580 ><TD
1581 >&nbsp;</TD
1582 ><TD
1583 >less than, greater than</TD
1584 ></TR
1585 ><TR
1586 ><TD
1587 ><TT
1588 CLASS="TOKEN"
1589 >=</TT
1590 ></TD
1591 ><TD
1592 >right</TD
1593 ><TD
1594 >equality, assignment</TD
1595 ></TR
1596 ><TR
1597 ><TD
1598 ><TT
1599 CLASS="TOKEN"
1600 >NOT</TT
1601 ></TD
1602 ><TD
1603 >right</TD
1604 ><TD
1605 >logical negation</TD
1606 ></TR
1607 ><TR
1608 ><TD
1609 ><TT
1610 CLASS="TOKEN"
1611 >AND</TT
1612 ></TD
1613 ><TD
1614 >left</TD
1615 ><TD
1616 >logical conjunction</TD
1617 ></TR
1618 ><TR
1619 ><TD
1620 ><TT
1621 CLASS="TOKEN"
1622 >OR</TT
1623 ></TD
1624 ><TD
1625 >left</TD
1626 ><TD
1627 >logical disjunction</TD
1628 ></TR
1629 ></TBODY
1630 ></TABLE
1631 ></DIV
1632 ><P
1633 >    Note that the operator precedence rules also apply to user-defined
1634     operators that have the same names as the built-in operators
1635     mentioned above.  For example, if you define a
1636     <SPAN
1637 CLASS="QUOTE"
1638 >"+"</SPAN
1639 > operator for some custom data type it will have
1640     the same precedence as the built-in <SPAN
1641 CLASS="QUOTE"
1642 >"+"</SPAN
1643 > operator, no
1644     matter what yours does.
1645    </P
1646 ><P
1647 >    When a schema-qualified operator name is used in the
1648     <TT
1649 CLASS="LITERAL"
1650 >OPERATOR</TT
1651 > syntax, as for example in
1652 </P><PRE
1653 CLASS="PROGRAMLISTING"
1654 >SELECT 3 OPERATOR(pg_catalog.+) 4;</PRE
1655 ><P>
1656     the <TT
1657 CLASS="LITERAL"
1658 >OPERATOR</TT
1659 > construct is taken to have the default precedence
1660     shown in <A
1661 HREF="sql-syntax.html#SQL-PRECEDENCE-TABLE"
1662 >Table 4-1</A
1663 > for <SPAN
1664 CLASS="QUOTE"
1665 >"any other"</SPAN
1666 > operator.  This is true no matter
1667     which specific operator name appears inside <TT
1668 CLASS="LITERAL"
1669 >OPERATOR()</TT
1670 >.
1671    </P
1672 ></DIV
1673 ></DIV
1674 ></DIV
1675 ><DIV
1676 CLASS="NAVFOOTER"
1677 ><HR
1678 ALIGN="LEFT"
1679 WIDTH="100%"><TABLE
1680 SUMMARY="Footer navigation table"
1681 WIDTH="100%"
1682 BORDER="0"
1683 CELLPADDING="0"
1684 CELLSPACING="0"
1685 ><TR
1686 ><TD
1687 WIDTH="33%"
1688 ALIGN="left"
1689 VALIGN="top"
1690 ><A
1691 HREF="sql.html"
1692 ACCESSKEY="P"
1693 >Prev</A
1694 ></TD
1695 ><TD
1696 WIDTH="34%"
1697 ALIGN="center"
1698 VALIGN="top"
1699 ><A
1700 HREF="index.html"
1701 ACCESSKEY="H"
1702 >Home</A
1703 ></TD
1704 ><TD
1705 WIDTH="33%"
1706 ALIGN="right"
1707 VALIGN="top"
1708 ><A
1709 HREF="sql-expressions.html"
1710 ACCESSKEY="N"
1711 >Next</A
1712 ></TD
1713 ></TR
1714 ><TR
1715 ><TD
1716 WIDTH="33%"
1717 ALIGN="left"
1718 VALIGN="top"
1719 >The SQL Language</TD
1720 ><TD
1721 WIDTH="34%"
1722 ALIGN="center"
1723 VALIGN="top"
1724 ><A
1725 HREF="sql.html"
1726 ACCESSKEY="U"
1727 >Up</A
1728 ></TD
1729 ><TD
1730 WIDTH="33%"
1731 ALIGN="right"
1732 VALIGN="top"
1733 >Value Expressions</TD
1734 ></TR
1735 ></TABLE
1736 ></DIV
1737 ></BODY
1738 ></HTML
1739 >