• Last 5 Forum Topics
    Last post

The Web Only This Site



  • MARC

    Mailing list ARChives
    - Search by -


    Computing Dictionary

  • Text Link Ads

  • LINUX man pages
  • Linux Man Page Viewer

    The following form allows you to view linux man pages.





           PREPARE name [ ( datatype [, ...] ) ] AS statement


           PREPARE creates a prepared statement. A prepared statement is a server-
           side object that can be used to optimize performance. When the  PREPARE
           statement  is  executed,  the specified statement is parsed, rewritten,
           and planned. When an EXECUTE command is subsequently issued,  the  pre-
           pared  statement  need  only be executed. Thus, the parsing, rewriting,
           and planning stages are only performed once, instead of every time  the
           statement is executed.
           Prepared  statements  can  take parameters: values that are substituted
           into the statement when it is  executed.  When  creating  the  prepared
           statement, refer to parameters by position, using $1, $2, etc. A corre-
           sponding list of parameter data types can optionally be specified. When
           a parameter's data type is not specified or is declared as unknown, the
           type is inferred from the context in which the parameter  is  used  (if
           possible).  When executing the statement, specify the actual values for
           these parameters in the  EXECUTE  statement.  Refer  to  EXECUTE  [exe-
           cute(7)] for more information about that.
           Prepared  statements only last for the duration of the current database
           session. When the session ends, the prepared statement is forgotten, so
           it  must  be  recreated before being used again. This also means that a
           single prepared statement  cannot  be  used  by  multiple  simultaneous
           database  clients;  however,  each client can create their own prepared
           statement to use. The prepared statement can  be  manually  cleaned  up
           using the DEALLOCATE [deallocate(7)] command.
           Prepared  statements have the largest performance advantage when a sin-
           gle session is being used to execute a large number of  similar  state-
           ments.  The  performance difference will be particularly significant if
           the statements are complex to plan or  rewrite,  for  example,  if  the
           query  involves  a  join  of many tables or requires the application of
           several rules. If the  statement  is  relatively  simple  to  plan  and
           rewrite  but relatively expensive to execute, the performance advantage
           of prepared statements will be less noticeable.


           name   An arbitrary name given to this particular  prepared  statement.
                  It  must  be  unique within a single session and is subsequently
                  used to execute or deallocate a previously prepared statement.
                  The data type of a parameter to the prepared statement.  If  the
                  data  type of a particular parameter is unspecified or is speci-
                  fied as unknown, it will be inferred from the context  in  which
                  the  parameter  is  used. To refer to the parameters in the pre-
                  pared statement itself, use $1, $2, etc.
           ments  with parameters, the chosen plan might be suboptimal. To examine
           the query plan PostgreSQL has chosen  for  a  prepared  statement,  use
           EXPLAIN [explain(7)].
           For  more information on query planning and the statistics collected by
           PostgreSQL for that purpose, see the  ANALYZE  [analyze(7)]  documenta-
           You  can see all available prepared statements of a session by querying
           the pg_prepared_statements system view.


           Create a prepared statement for an INSERT statement, and  then  execute
           PREPARE fooplan (int, text, bool, numeric) AS
               INSERT INTO foo VALUES($1, $2, $3, $4);
           EXECUTE fooplan(1, 'Hunter Valley', 't', 200.00);
           Create  a  prepared  statement for a SELECT statement, and then execute
           PREPARE usrrptplan (int) AS
               SELECT * FROM users u, logs l WHERE u.usrid=$1 AND u.usrid=l.usrid
               AND = $2;
           EXECUTE usrrptplan(1, current_date);
           Note that the data type of the second parameter is not specified, so it
           is inferred from the context in which $2 is used.


           The  SQL  standard includes a PREPARE statement, but it is only for use
           in embedded SQL. This version of the  PREPARE  statement  also  uses  a
           somewhat different syntax.


           DEALLOCATE [deallocate(7)], EXECUTE [execute(7)]

    SQL - Language Statements 2014-02-17 PREPARE(7)


  • Linux

    The Distributions


    The Software


    The News


  • Toll Free
Copyright © 1999 - 2016 by LinuxGuruz