Default expectation safe interface. Equivalent to

  with = withConfig' defaultConfig

Exception safe database create with options. See startConfig for more details. Calls stop even in the face of exceptions.

Default start behavior. Equivalent to calling startConfig with the defaultConfig

Create zero or more temporary resources and use them to make a Config.

The passed in config is inspected and a generated config is created. The final config is built by

  generated <> extra

Returns a DB that requires cleanup. startConfig should be used with a bracket and stop, e.g.

  withConfig :: Config -> (DB -> IO a) -> IO (Either StartError a)
  withConfig plan f = bracket (startConfig plan) (either mempty stop) $
     either (pure . Left) (fmap Right . f)

or just use withConfig. If you are calling startConfig you probably want withConfig anyway.

Based on the value of socketClass a "postgresql.conf" is created with

  listen_addresses = 'IP_ADDRESS'

if it is CIpSocket. If is CUnixSocket then the lines

  listen_addresses = ''
  unix_socket_directories = 'SOCKET_DIRECTORY'

are added.

Stop the postgres process and cleanup any temporary resources that might have been created.

The default configuration. This will create a database called "postgres" via initdb (it's default behavior). It will create a temporary directory for the data and a temporary directory for a unix socket on a random port. Additionally it will use append the following onto the "postgresql.conf" which is optimized for performance.

   shared_buffers = 12MB
   fsync = off
   synchronous_commit = off
   full_page_writes = off
   log_min_duration_statement = 0
   log_connections = on
   log_disconnections = on
   client_min_messages = ERROR

defaultConfig also passes the --no-sync flag to initdb.

If you would like to customize this behavior you can start with the defaultConfig and overwrite fields or combine a defaultConfig with another Config using <> (mappend).

Alternatively you can eschew defaultConfig altogether, however your postgres might start and run faster if you use defaultConfig.

defaultConfig also sets the initDbConfig to pure standardProcessConfig and postgresConfig to standardProcessConfig.

To append additional lines to "postgresql.conf" file create a custom Config like the following.

 custom = defaultConfig <> mempty
   { plan = mempty
     { postgresConfigFile =
         [ "wal_level = replica"
         , "archive_mode = on"
         , "max_wal_senders = 2"
         , "fsync = on"
         , "synchronous_commit = on"
         ]
     }
   }

Or using the provided lenses and your favorite lens library

 custom = defaultConfig & planL . postgresConfigFile <>~
   [ "wal_level = replica"
   , "archive_mode = on"
   , "max_wal_senders = 2"
   , "fsync = on"
   , "synchronous_commit = on"
   ]

This is common enough there is defaultPostgresConf which is a helper to do this.

As an alternative to using defaultConfig one could create a config from connections parameters using optionsToDefaultConfig

mappend the defaultConfig with a Config that provides additional "postgresql.conf" lines. Equivalent to

defaultPostgresConf extra = defaultConfig <> mempty
  { plan = mempty
    { postgresConfigFile = extra
    }
  }

The standardProcessConfig sets the handles to stdin, stdout and stderr and inherits the environment variables from the calling process.

Attempt to create a Config from a Options. Useful if you want to create a database owned by a specific user you will also login with among other use cases.

Restart the postgres from DB using the prior Plan

Only stop the postgres process but leave any temporary resources. Useful for testing backup strategies when used in conjunction with restart or withRestart.

Exception safe version of restart

Reload the configuration file without shutting down. Calls pg_reload_conf().

Handle for holding temporary resources, the postgres process handle and postgres connection information. The DB also includes the final CompletePlan that was used to start initdb, createdb and postgres. See toConnectionString for converting a DB to postgresql connection string.

Display a DB

Convert a DB to a connection string. Alternatively one can access the Options using toConnectionOptions

Convert a DB to a connection Options type.

Access the data directory. This was either generated or specified explicitly when creating the Config

Make the data directory permanent. Useful for debugging. If you are using with or withConfig this function will not modify the DB that is passed for cleanup. You will need to setup your own bracket like

   bracket (fmap makeDataDirPermanent start) (either mempty stop)

The high level options for overriding default behavior.

Display a Config.

Lens for plan

Lens for socketClass

Lens for dataDirectory

Lens for port

The monoidial version of CompletePlan. Used to combine overrides with defaults when creating a plan.

Lens for postgresConfigFile

Lens for createDbConfig

Lens for dataDirectoryString

Lens for initDbConfig

Lens for logger

Lens for postgresPlan

postgres process config and corresponding client connection Options.

Lens for connectionOptions

Lens for postgresConfig

The monoidial version of ProcessConfig. Used to combine overrides with defaults when creating a ProcessConfig.

Lens for commandLine

Lens for environmentVariables

Lens for stdErr

Lens for stdIn

Lens for stdOut

The environment variables can be declared to inherit from the running process or they can be specifically added.

Lens for inherit

Lens for specific

A type to help combine command line arguments.

Lens for indexBased

Lens for keyBased

The monoidial version of CompleteDirectoryType. Used to combine overrides with defaults when creating a CompleteDirectoryType. The monoid instance treats Temporary as mempty and takes the last Permanent value.

The monoidial version of CompleteSocketClass. Used to combine overrides with defaults when creating a CompleteSocketClass. The monoid instance treats 'UnixSocket mempty' as mempty and combines the

A way to log internal Events

Internal events for debugging

A list of failures that can occur when starting. This is not and exhaustive list but covers the errors that the system catches for the user.