# doc-cache created by Octave 5.1.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: 415
 -- 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: 368
 -- 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: 66
Return a specific setting from a structure created by 'setdbopts'.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1850
 -- 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.

     See also: pq_exec_params, pq_update_types.


# 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: 4184
 -- 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")'.

     See also: pq_update_types, pq_conninfo.


# 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: 954
 -- 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.





