# doc-cache created by Octave 11.3.0
# name: cache
# type: cell
# rows: 3
# columns: 6
# name: <cell-element>
# type: sq_string
# elements: 1
# length: 12
database_doc


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 410
 -- Function File: database_doc ()
 -- Function File: database_doc (KEYWORD)
     Show database package documentation.

     Runs the info viewer Octave is configured with on the documentation in info
     format of the installed database package.  Without argument, the top node
     of the documentation is displayed.  With an argument, the respective index
     entry is searched for and its node displayed.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 36
Show database package documentation.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 9
getdbopts


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 373
 -- Function File: getdbopts (OPTIONS, PARNAME)
 -- Function File: getdbopts (OPTIONS, PARNAME, DEFAULT)
     Return a specific setting from a structure created by ‘setdbopts’.  If
     PARNAME is not a field of the OPTIONS structure, return DEFAULT if
     supplied, otherwise return an empty matrix.

     (This function uses the code of Octaves 'optimget' function.)


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 74
Return a specific setting from a structure created by ‘setdbopts’.  If



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 10
pq_connect


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1892
 -- Function File: CONNECTION = pq_connect (SETTINGS)
     Establishes a connection to a postgresql server according to SETTINGS and
     returns an ‘octave_pq_connection’ object CONNECTION which can be passed to
     other functions of the package.  There can be multiple connections.  An
     ‘octave_pq_connection’ object contains information on a connection and will
     be internally altered by the packages functions even though it is only
     passed as an argument, i.e.  Octaves 'pass by value' semantics are not
     adhered to in this case.

     SETTINGS can be set by ‘setdbopts’ (copied from Octaves ‘optimset’) and can
     contain (defaults depend on Postgresql): ‘host’ (hostname), ‘hostaddr’
     (numeric host address), ‘port’ (port to connect to), ‘dbname’ (database to
     connect to), ‘user’ (user name to connect as), ‘password’,
     ‘connect_timeout’, ‘options’ (command-line options to send to the server at
     run-time, see Postgresql documentation), ‘sslmode’ (‘disable’, ‘allow’,
     ‘prefer’, ‘require’, ‘verify-ca’, or ‘verify-full’; see Postgresql
     documentation of SSL support), ‘sslcert’ (file name of client SSL
     certificate), ‘sslkey’ (location of secret key for client certificate, file
     name or external OpenSSL engine (colon-separated engine name and an
     engine-specific key identifier)), ‘sslrootcert’ (file name of root SSL
     certificate), ‘sslcrl’ (file name of SSL certificate revocation list),
     ‘krbsrvname’ (kerberos service name), ‘service’ (service name in
     pq_service.conf to use for additional parameters).

     All these settings are passed to the server as they are, so it may be
     better to consult the postgresql documentation for them, e.g.  the
     documentation of the PQconnectdb function in libpq.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
Establishes a connection to a postgresql server according to SETTINGS and
ret...



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 14
pq_exec_params


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 4228
 -- Function File: pq_exec_params (CONNECTION, COMMAND)
 -- Loadable Function: pq_exec_params (CONNECTION, COMMAND, PARAMS)
 -- Loadable Function: pq_exec_params (CONNECTION, COMMAND, SETTINGS)
 -- Loadable Function: pq_exec_params (CONNECTION, COMMAND, PARAMS, SETTINGS)

     Sends the string COMMAND, which must contain a single SQL command, over the
     connection CONNECTION.  Parameters in COMMAND can be replaced by $1, $2,
     etc and their values given in the one-dimensional cell-array PARAMS.
     Parameters of composite type sent this way must have their type defined in
     the database.  For typeconversions, the package maintains a notion of
     defined types, which should be refreshed with ‘pq_update_types’ if types
     are defined or dropped after establishing the connection, or if the schema
     search path changes.  SETTINGS is a structure of settings, it can be
     created by ‘setdbopts’.

     Settings currently understood by ‘pq_exec_params’:

     ‘param_types’
          One-dimensional cell-array with type specifications for parameters in
          PARAMS.  If present, must have the same length as PARAMS.  Entries may
          be empty if no specification is necessary (see below).  Type
          specifications are strings corresponding to the entries returned by
          ‘SELECT typname FROM pg_type WHERE typarray != 0 OR typtype = 'c';’,
          optionally having ‘[]’ appended (without space) to indicate an array.
          Type specifications can be schema-qualified, otherwise they refer to
          the visible type with that name.
     ‘copy_in_path, copy_out_path’
          Path to files at the client side for ‘copy from stdin’ and ‘copy to
          stdout’, respectively.
     ‘copy_in_from_variable’
          Logical scalar, default ‘false’.  If ‘true’, ‘copy from stdin’ uses
          data from an Octave variable instead of from a file.
     ‘copy_in_data’
          2-dimensional cell-array with columns of suitable type (see below) -
          will be used instead of a file as data for ‘copy from stdin’ if
          ‘copy_in_from_variable’ is ‘true’.
     ‘copy_in_types’
          If some columns in ‘copy_in_data’ need a type specification (see
          below), ‘copy_in_types’ has to be set to a cell-array with type
          specifications, with an entry (possibly empty) for each column.
     ‘copy_in_with_oids’
          If you want to copy in with oids when using data from an Octave
          variable, the first column of the data must contain the OIDs and
          ‘copy_in_with_oids’ has to be set to ‘true’ (default ‘false’); ‘with
          oids’ should be specified together with ‘copy from stdin’ in the
          command, otherwise Postgresql will ignore the copied oids.

     There is no way to ‘copy to stdout’ into an Octave variable, but a ‘select’
     command can be used for this purpose.

     ‘copy from stdin’ from an Octave variable is only supported in binary mode,
     so this has to be specified in the SQL command.

     The output depends on the type of command.
        • queries (commands potentially returning data): The output will be a
          structure with fields ‘data’ (containing a cell array with the data,
          columns correspond to returned database columns, rows correspond to
          returned tuples), ‘columns’ (containing the column headers), and
          ‘types’ (a structure-vector with the postgresql data types of the
          columns, subfields ‘name’ (string with typename), ‘is_array’
          (boolean), ‘is_composite’ (boolean), ‘is_enum’ (boolean), and
          ‘elements’ (if ‘is_composite == true’, structure-vector of element
          types, containing fields corresponding to those of ‘types’)).
        • copy commands: Nothing is returned (this may change in the future).
        • other commands: The output will be the number of affected rows in the
          database.

     For the mapping of currently implemented Postgresql types to Octave types,
     type ‘database_doc ("Postgresql data types")’.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
Sends the string COMMAND, which must contain a single SQL command, over the
c...



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 10
pq_lo_view


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 341
 -- Function File: pq_lo_view (CONNECTION, OID, VIEWER)

     Exports the large object of Oid OID in the database associated with
     CONNECTION to a temporary file and starts the program VIEWER in the
     background with the name of the temporary file as argument.

     The temporary file will be removed after termination of the viewer.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
Exports the large object of Oid OID in the database associated with CONNECTIO...



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 9
setdbopts


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 949
 -- Function File: setdbopts ()
 -- Function File: setdbopts (PAR, VAL, ...)
 -- Function File: setdbopts (OLD, PAR, VAL, ...)
 -- Function File: setdbopts (OLD, NEW)
     Create settings structure for database functions.

     When called without any input or output arguments, 'setdbopts' prints a
     list of all valid optimization parameters.

     When called with one output and no inputs, return an options structure with
     all valid option parameters initialized to '[]'.

     When called with a list of parameter/value pairs, return an options
     structure with only the named parameters initialized.

     When the first input is an existing options structure OLD, the values are
     updated from either the PAR/VAL list or from the options structure NEW.

     Please see individual database functions for valid settings.

     (Most of this documentation and this functions code are copied from Octaves
     'optimset' function.)


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 49
Create settings structure for database functions.





