cjones's questions

Eu normalmente faço o seguinte para dumps SQL:

pg_dump -U username -cOx database > dump.sql

E, em seguida, restaure-o em um novo banco de dados com:

psql -U username new_database < dump.sql

Atualmente, as databasetabelas não estão no publicesquema, mas em um esquema nomeado para um usuário. Não há razão para isso. Acho que aconteceu quando houve uma migração do MySQL para o PostgreSQL alguns anos atrás usando um utilitário cujo nome me escapa.

Eu gostaria de mover tudo para o public. Eu sei que posso fazer isso editando o dump.sql, que é um processo lento devido ao tamanho do arquivo (que é bem pequeno em termos de banco de dados).

Existe uma maneira de fazer isso ao exportar ou importar um dump SQL?

Este é o PostgreSQL 13, aliás.

Basicamente, estou tentando fazer um dump SQL que fará uma cópia exata de um banco de dados: funções definidas pelo usuário, relacionamentos, restrições, tabelas, dados, etc.

Isso é factível pg_dumpou psqlprecisa ser usado em vez disso?

Eu tenho usado pg_dump -U user -cOx database > pg.sql, mas não está totalmente claro para mim se ele captura tudo .

Eu estava olhando para todas as pg_dumpbandeiras aqui:

https://www.postgresql.org/docs/11/app-pgdump.html

O único que posso pensar que pode fazer isso, porque realmente não diz explicitamente, é o -s --schema-onlysinalizador, que exclui dados. Estou bem com isso e executando um segundo pg_dumppara os dados, mas principalmente quero ter certeza de que estou fazendo backup das funções definidas pelo usuário, relacionamentos, etc.

Considerando essas duas tabelas no PosgtreSQL:

# report
+----+-------------+--------------------+
| id | report_name | report_description |
+----+-------------+--------------------+
| 1  | RPT         | ABCDEFGH           |
| 2  | TST         | LMNOPQRS           |
+----+-------------+--------------------+

# report_years
+----+--------------+-------------+------+
| id | report_id_fk | report_name | year |
+----+--------------+-------------+------+
| 11 | 1            | RPT         | 2019 |
| 12 | 1            | RPT         | 2020 |
| 13 | 2            | TST         | 2019 |
+----+--------------+-------------+------+

1. Dado que report_id_fké uma chave estrangeira na report_yearstabela, não haveria uma maneira de CASCADEatualizar o report_namecom base em report_id_fk?
2. Eles teriam que ser chaves estrangeiras separadas?
3. report_namenem deveria estar na report_yearstabela em primeiro lugar, pois é redundante e deve ser consultado com um JOINto report?
4. É possível ter uma restrição de chave estrangeira de vários campos tal que report_namee yearseria necessária para um CASCADE?

Por exemplo:

# report
+----+-------------+------+
| id | report_name | year |
+----+-------------+------+
| 1  | RPT         | 2018 |
| 2  | RPT         | 2019 |
| 3  | RPT         | 2020 |
+----+-------------+------+

# report_details
+----+-----------+----------------+---------+---------+
| id | report_id | report_name_fk | year_fk | details |
+----+-----------+----------------+---------+---------+
| 11 | 1         | RPT            | 2018    | ABC     |
| 12 | 2         | RPT            | 2019    | DEF     |
| 13 | 3         | RPT            | 2020    | GHI     |
+----+-----------+----------------+---------+---------+

5. Se eu quisesse alterar o report_namefor year = 2020in report, ele faria CASCADEe report_detailsatualizaria o report_name_fkcom base no report_name_fkand year_fk?
6. Ou (voltando à pergunta 1), posso configurar um CASCADEque seja atualizado report_name_fke year_fkem report_details?

Eu posso ver como fazer isso com um manual UPDATE, mas vendo se é possível com CASCADE. Ou, como eu acho, isso é redundante, deve ser evitado e se você precisa saber report_namee yearpara um relatório em report_details, você deve apenas escrever uma consulta JOINnele.

Migrado do MySQL onde esta consulta funcionou:

SELECT DISTINCT
    code,
    title,
    country
FROM
    data_a
ORDER BY
    sortorder

Basicamente, obtenha uma lista e classifique-a por um usuário/empresa definido sortorderque não seja baseado em code, title, ou country.

Agora que estou no Postgres, essa consulta não funciona e fica:

ERROR:  for SELECT DISTINCT, ORDER BY expressions must appear in select list
LINE 12:  sortorder
          ^
SQL state: 42P10
Character: 135

No entanto, fazer isso retorna duplicatas porque existem campos adicionais não listados aqui que tornam todo o registro exclusivo. Eu só quero os valores exclusivos de code, titleou countryna ordem do sortorder.

Tentei fazer uma subconsulta pensando que poderia classificá-la na subconsulta e trazê-la para a consulta pai já classificada, mas ela aparece em uma ordem não específica ... bem, talvez seja particular, mas é não é a ordem que queremos.

SELECT
    DISTINCT s.*
FROM
    (
        SELECT
            code,
            title,
            country
        FROM
            data_a
        GROUP BY
            code,
            title,
            country,
            sortorder
        ORDER BY
            sortorder
    ) s;

Alguma sugestão de como fazer isso?

Eu tenho esta consulta MySQL usando AES_DECRYPT()que é o seguinte:

SELECT * 
FROM data_tbl
WHERE AES_DECRYPT(data_point,'aBcDeF')='data_1';

Eu descobri que o equivalente no Postgres 11 é decrypt()(F.25.4. Raw Encryption Functions) e a consulta seria algo assim:

SELECT * 
FROM data_tbl
AND decrypt(data_point,'aBcDeF','aes')='data_1';

Pelo menos, a documentação de ambos me leva a acreditar que são equivalentes.

Os dados foram despejados do MySQL e importados para o PostgreSQL.

• O data-pointcampo no MySQL é tipo varbinary(255)e todos os valores são mostrados BLOBno MySQL Workbench.
• O data_pointcampo no Postgres é tipo byteae todos os valores são mostrados [binary data]no pgAdmin.

Se esses tipos de dados são equivalentes, admito, não tenho certeza.

A consulta MySQL funciona e encontra um registro com base nos critérios. O PostgreSQL não, embora o registro esteja lá. Então, parece uma de três coisas:

1. Os tipos de dados ( varbinary(255)vs bytea) não são equivalentes
2. Os dados não coincidem ( BLOBvs [binary data]) não são equivalentes
3. As funções ( AES_DECRYPTvs decrypt()) não são equivalentes

Eu tentei descriptografar o valor no PostgreSQL apenas para ver o que está em um formato legível, tentando primeiro:

SELECT decrypt(data_point, 'aBcDeF', 'aes') 
FROM data_tbl;

Mas isso acabou de retornar [binary data]para todas as linhas.

Então me deparei com esta resposta para usar convert_fromcomo em:

SELECT convert_from(decrypt(data_point, 'aBcDeF', 'aes'), 'SQL_ASCII')
FROM data_tbl;

No entanto, apenas recebo este erro:

ERROR:  invalid byte sequence for encoding "UTF8": 0xcf 0xf5
SQL state: 22021

Então, neste ponto, estou perplexo sobre como resolver o problema principal. O principal problema é fazer o equivalente a AES_DECRYPTmas no PostgreSQL 11. A última mensagem de erro não é tanto um problema, mas provavelmente está relacionada a decrypt()não retornar os mesmos resultados.

Alguma sugestão?

Então, a maneira como eu tenho feito backup do Postgres é com:

pg_dumpall -U eox-dev -h localhost --clean --file=/home/backups/postgres.sql

Quero ter certeza de que tenho um backup pronto para produção que tenha funções, relacionamentos, gatilhos, além de tabelas e dados.

Estou tentando restaurá-lo agora em um cluster Kubernetes em um banco de dados com um nome diferente prod_db-> staging_db, mas obter FATAL: database "prod_db" does not exist. Estou tentando restaurá-lo para staging_dbque faça sentido. Uma das primeiras linhas do .sqlfaz declare CREATE DATABASE prod_db. Eu não sou sobre a edição do .sql. Se eu tiver que fazer isso, estou fazendo algo errado.

Qual a forma correta de fazer esse backup?

Eu tenho executado uma função no banco de dados que está entrando em cada tabela, ALTER COLUMNem todas as colunas de um determinado tipo de dados, e CASTpara remover zeros à direita. Cerca de 115 tabelas variando de alguns milhares de registros a algumas centenas de milhares de registros. Ele está funcionando há quase 24 horas e meu cálculo aproximado até o tempo de conclusão é de cerca de 58 horas.

Eu tenho htoppara cima e verificá-lo regularmente.

Devo mencionar que esta é uma instalação limpa do CentOS mínima de ontem com realmente apenas o PostgreSQL 9.6.5 nele. Duas CPUs quad core e 32 GB de RAM.

De acordo com htopmeu mem está em 620M/31.3Ge maximiza um núcleo por vez, nunca realmente utilizando outros núcleos ao mesmo tempo. Parece que eu tenho muito espaço para a utilização da CPU e da RAM. Parece que se eu pudesse configurar corretamente o PostgreSQL para utilizar mais CPU e RAM, o processo como estou executando agora seria muito mais rápido. Talvez eu esteja errado.

Quais são algumas configurações que podem ser ajustadas, seja no Postgres ou no CentOS, que permitirão maior utilização?

O meu postgresql.confestá praticamente nas configurações padrão:

# RESOURCE USAGE (except WAL)
#------------------------------------------------------------------------------

# - Memory -

shared_buffers = 128MB                  # min 128kB
                                        # (change requires restart)
#huge_pages = try                       # on, off, or try
                                        # (change requires restart)
#temp_buffers = 8MB                     # min 800kB
#max_prepared_transactions = 0          # zero disables the feature
                                        # (change requires restart)
# Caution: it is not advisable to set max_prepared_transactions nonzero unless
# you actively intend to use prepared transactions.
#work_mem = 4MB                         # min 64kB
#maintenance_work_mem = 64MB            # min 1MB
#replacement_sort_tuples = 150000       # limits use of replacement selection sort
#autovacuum_work_mem = -1               # min 1MB, or -1 to use maintenance_work_mem
#max_stack_depth = 2MB                  # min 100kB
dynamic_shared_memory_type = posix      # the default is the first option
                                        # supported by the operating system:
                                        #   posix
                                        #   sysv
                                        #   windows
                                        #   mmap
                                        # use none to disable dynamic shared memory
                                        # (change requires restart)

# - Disk -

#temp_file_limit = -1                   # limits per-process temp file space
                                        # in kB, or -1 for no limit

# - Kernel Resource Usage -

#max_files_per_process = 1000           # min 25
                                        # (change requires restart)
#shared_preload_libraries = ''          # (change requires restart)

# - Cost-Based Vacuum Delay -

#vacuum_cost_delay = 0                  # 0-100 milliseconds
#vacuum_cost_page_hit = 1               # 0-10000 credits
#vacuum_cost_page_miss = 10             # 0-10000 credits
#vacuum_cost_page_dirty = 20            # 0-10000 credits
#vacuum_cost_limit = 200                # 1-10000 credits

# - Background Writer -

#bgwriter_delay = 200ms                 # 10-10000ms between rounds
#bgwriter_lru_maxpages = 100            # 0-1000 max buffers written/round
#bgwriter_lru_multiplier = 2.0          # 0-10.0 multiplier on buffers scanned/round
#bgwriter_flush_after = 512kB           # measured in pages, 0 disables

# - Asynchronous Behavior -

#effective_io_concurrency = 1           # 1-1000; 0 disables prefetching
#max_worker_processes = 8               # (change requires restart)
#max_parallel_workers_per_gather = 0    # taken from max_worker_processes
#old_snapshot_threshold = -1            # 1min-60d; -1 disables; 0 is immediate
                                        # (change requires restart)
#backend_flush_after = 0                # measured in pages, 0 disables


#------------------------------------------------------------------------------
# WRITE AHEAD LOG
#------------------------------------------------------------------------------

# - Settings -

#wal_level = minimal                    # minimal, replica, or logical
                                        # (change requires restart)
#fsync = on                             # flush data to disk for crash safety
                                                # (turning this off can cause
                                                # unrecoverable data corruption)
#synchronous_commit = on                # synchronization level;
                                        # off, local, remote_write, remote_apply, or on
#wal_sync_method = fsync                # the default is the first option
                                        # supported by the operating system:
                                        #   open_datasync
                                        #   fdatasync (default on Linux)
                                        #   fsync
                                        #   fsync_writethrough
                                        #   open_sync
#full_page_writes = on                  # recover from partial page writes
#wal_compression = off                  # enable compression of full-page writes
#wal_log_hints = off                    # also do full page writes of non-critical updates
                                        # (change requires restart)
#wal_buffers = -1                       # min 32kB, -1 sets based on shared_buffers
                                        # (change requires restart)
#wal_writer_delay = 200ms               # 1-10000 milliseconds
#wal_writer_flush_after = 1MB           # measured in pages, 0 disables

#commit_delay = 0                       # range 0-100000, in microseconds
#commit_siblings = 5                    # range 1-1000

# - Checkpoints -

#checkpoint_timeout = 5min              # range 30s-1d
#max_wal_size = 1GB
#min_wal_size = 80MB
#checkpoint_completion_target = 0.5     # checkpoint target duration, 0.0 - 1.0
#checkpoint_flush_after = 256kB         # measured in pages, 0 disables
#checkpoint_warning = 30s               # 0 disables

# - Archiving -

#archive_mode = off             # enables archiving; off, on, or always
                                # (change requires restart)
#archive_command = ''           # command to use to archive a logfile segment
                                # placeholders: %p = path of file to archive
                                #               %f = file name only
                                # e.g. 'test ! -f /mnt/server/archivedir/%f && cp %p /mnt/server/archivedir/%f'
#archive_timeout = 0            # force a logfile segment switch after this
                                # number of seconds; 0 disables


#------------------------------------------------------------------------------
# REPLICATION
#------------------------------------------------------------------------------

# - Sending Server(s) -

# Set these on the master and on any standby that will send replication data.

#max_wal_senders = 0            # max number of walsender processes
                                # (change requires restart)
#wal_keep_segments = 0          # in logfile segments, 16MB each; 0 disables
#wal_sender_timeout = 60s       # in milliseconds; 0 disables

#max_replication_slots = 0      # max number of replication slots
                                # (change requires restart)
#track_commit_timestamp = off   # collect timestamp of transaction commit
                                # (change requires restart)

# - Master Server -

# These settings are ignored on a standby server.

#synchronous_standby_names = '' # standby servers that provide sync rep
                                # number of sync standbys and comma-separated list of application_name
                                # from standby(s); '*' = all
#vacuum_defer_cleanup_age = 0   # number of xacts by which cleanup is delayed

# - Standby Servers -

# These settings are ignored on a master server.

#hot_standby = off                      # "on" allows queries during recovery
                                        # (change requires restart)
#max_standby_archive_delay = 30s        # max delay before canceling queries
                                        # when reading WAL from archive;
                                        # -1 allows indefinite delay
#max_standby_streaming_delay = 30s      # max delay before canceling queries
                                        # when reading streaming WAL;
                                        # -1 allows indefinite delay
#wal_receiver_status_interval = 10s     # send replies at least this often
                                        # 0 disables
#hot_standby_feedback = off             # send info from standby to prevent
                                        # query conflicts
#wal_receiver_timeout = 60s             # time that receiver waits for
                                        # communication from master
                                        # in milliseconds; 0 disables
#wal_retrieve_retry_interval = 5s       # time to wait before retrying to
                                        # retrieve WAL after a failed attempt


#------------------------------------------------------------------------------
# QUERY TUNING
#------------------------------------------------------------------------------

# - Planner Method Configuration -

#enable_bitmapscan = on
#enable_hashagg = on
#enable_hashjoin = on
#enable_indexscan = on
#enable_indexonlyscan = on
#enable_material = on
#enable_mergejoin = on
#enable_nestloop = on
#enable_seqscan = on
#enable_sort = on
#enable_tidscan = on

# - Planner Cost Constants -

#seq_page_cost = 1.0                    # measured on an arbitrary scale
#random_page_cost = 4.0                 # same scale as above
#cpu_tuple_cost = 0.01                  # same scale as above
#cpu_index_tuple_cost = 0.005           # same scale as above
#cpu_operator_cost = 0.0025             # same scale as above
#parallel_tuple_cost = 0.1              # same scale as above
#parallel_setup_cost = 1000.0   # same scale as above
#min_parallel_relation_size = 8MB
#effective_cache_size = 4GB

# - Genetic Query Optimizer -

#geqo = on
#geqo_threshold = 12
#geqo_effort = 5                        # range 1-10
#geqo_pool_size = 0                     # selects default based on effort
#geqo_generations = 0                   # selects default based on effort
#geqo_selection_bias = 2.0              # range 1.5-2.0
#geqo_seed = 0.0                        # range 0.0-1.0

# - Other Planner Options -

#default_statistics_target = 100        # range 1-10000
#constraint_exclusion = partition       # on, off, or partition
#cursor_tuple_fraction = 0.1            # range 0.0-1.0
#from_collapse_limit = 8
#join_collapse_limit = 8                # 1 disables collapsing of explicit
                                        # JOIN clauses
#force_parallel_mode = off


#------------------------------------------------------------------------------
# ERROR REPORTING AND LOGGING
#------------------------------------------------------------------------------

# - Where to Log -

log_destination = 'stderr'              # Valid values are combinations of
                                        # stderr, csvlog, syslog, and eventlog,
                                        # depending on platform.  csvlog
                                        # requires logging_collector to be on.

# This is used when logging to stderr:
logging_collector = on                  # Enable capturing of stderr and csvlog
                                        # into log files. Required to be on for
                                        # csvlogs.
                                        # (change requires restart)

# These are only used if logging_collector is on:
log_directory = 'pg_log'                # directory where log files are written,
                                        # can be absolute or relative to PGDATA
log_filename = 'postgresql-%a.log'      # log file name pattern,
                                        # can include strftime() escapes
#log_file_mode = 0600                   # creation mode for log files,
                                        # begin with 0 to use octal notation
log_truncate_on_rotation = on           # If on, an existing log file with the
                                        # same name as the new log file will be
                                        # truncated rather than appended to.
                                        # But such truncation only occurs on
                                        # time-driven rotation, not on restarts
                                        # or size-driven rotation.  Default is
                                        # off, meaning append to existing files
                                        # in all cases.
log_rotation_age = 1d                   # Automatic rotation of logfiles will
                                        # happen after that time.  0 disables.
log_rotation_size = 0                   # Automatic rotation of logfiles will
                                        # happen after that much log output.
                                        # 0 disables.

# These are relevant when logging to syslog:
#syslog_facility = 'LOCAL0'
#syslog_ident = 'postgres'
#syslog_sequence_numbers = on
#syslog_split_messages = on

# This is only relevant when logging to eventlog (win32):
# (change requires restart)
#event_source = 'PostgreSQL'

# - When to Log -

CLient_min_messages = notice            # values in order of decreasing detail:
                                        #   debug5
                                        #   debug4
                                        #   debug3
                                        #   debug2
                                        #   debug1
                                        #   log
                                        #   notice
                                        #   warning
                                        #   error

log_min_messages = warning              # values in order of decreasing detail:
                                        #   debug5
                                        #   debug4
                                        #   debug3
                                        #   debug2
                                        #   debug1
                                        #   info
                                        #   notice
                                        #   warning
                                        #   error
                                        #   log
                                        #   fatal
                                        #   panic

log_min_error_statement = error         # VALUEs in order of decreasing detail:
                                        #   debug5
                                        #   debug4
                                        #   debug3
                                        #   debug2
                                        #   debug1
                                        #   info
                                        #   notice
                                        #   warning
                                        #   error
                                        #   log
                                        #   fatal
                                        #   panic (effectively off)

#log_min_duration_statement = -1        # -1 is disabled, 0 logs all statements
                                        # and their durations, > 0 logs only
                                        # statements running at least this number
                                        # of milliseconds


# - What to Log -

#debug_print_parse = off
#debug_print_rewritten = off
#debug_print_plan = off
#debug_pretty_print = on
#log_checkpoints = off
log_connections = off
#log_disconnections = off
#log_duration = off
log_error_verbosity = default           # terse, default, or verbose messages
#log_hostname = off
log_line_prefix = '< %m > '                     # special values:
                                        #   %a = application name
                                        #   %u = user name
                                        #   %d = database name
                                        #   %r = remote host and port
                                        #   %h = remote host
                                        #   %p = process ID
                                        #   %t = timestamp without milliseconds
                                        #   %m = timestamp with milliseconds
                                        #   %n = timestamp with milliseconds (as a Unix epoch)
                                        #   %i = command tag
                                        #   %e = SQL state
                                        #   %c = session ID
                                        #   %l = session line number
                                        #   %s = session start timestamp
                                        #   %v = virtual transaction ID
                                        #   %x = transaction ID (0 if none)
                                        #   %q = stop here in non-session
                                        #        processes
                                        #   %% = '%'
                                        # e.g. '<%u%%%d> '
#log_lock_waits = off                   # log lock waits >= deadlock_timeout
#log_statement = 'none'                 # none, ddl, mod, all
#log_replication_commands = off
#log_temp_files = -1                    # log temporary files equal or larger
                                        # than the specified size in kilobytes;
                                        # -1 disables, 0 logs all temp files
log_timezone = 'US/Pacific'


# - Process Title -

#cluster_name = ''                      # added to process titles if nonempty
                                        # (change requires restart)
#update_process_title = on


#------------------------------------------------------------------------------
# RUNTIME STATISTICS
#------------------------------------------------------------------------------

# - Query/Index Statistics Collector -

#track_activities = on
#track_counts = on
#track_io_timing = off
#track_functions = none                 # none, pl, all
#track_activity_query_size = 1024       # (change requires restart)
#stats_temp_directory = 'pg_stat_tmp'


# - Statistics Monitoring -

#log_parser_stats = off
#log_planner_stats = off
#log_executor_stats = off
#log_statement_stats = off


#------------------------------------------------------------------------------
# AUTOVACUUM PARAMETERS
#------------------------------------------------------------------------------

#autovacuum = on                        # Enable autovacuum subprocess?  'on'
                                        # requires track_counts to also be on.
#log_autovacuum_min_duration = -1       # -1 disables, 0 logs all actions and
                                        # their durations, > 0 logs only
                                        # actions running at least this number
                                        # of milliseconds.
#autovacuum_max_workers = 3             # max number of autovacuum subprocesses
                                        # (change requires restart)
#autovacuum_naptime = 1min              # time between autovacuum runs
#autovacuum_vacuum_threshold = 50       # min number of row updates before
                                        # vacuum
#autovacuum_analyze_threshold = 50      # min number of row updates before
                                        # analyze
#autovacuum_vacuum_scale_factor = 0.2   # fraction of table size before vacuum
#autovacuum_analyze_scale_factor = 0.1  # fraction of table size before analyze
#autovacuum_freeze_max_age = 200000000  # maximum XID age before forced vacuum
                                        # (change requires restart)
#autovacuum_multixact_freeze_max_age = 400000000        # maximum multixact age
                                        # before forced vacuum
                                        # (change requires restart)
#autovacuum_vacuum_cost_delay = 20ms    # default vacuum cost delay for
                                        # autovacuum, in milliseconds;
                                        # -1 means use vacuum_cost_delay
#autovacuum_vacuum_cost_limit = -1      # default vacuum cost limit for
                                        # autovacuum, -1 means use
                                        # vacuum_cost_limit


#------------------------------------------------------------------------------
# CLIENT CONNECTION DEFAULTS
#------------------------------------------------------------------------------

# - Statement Behavior -

#search_path = '"$user", public'        # schema names
#default_tablespace = ''                # a tablespace name, '' uses the default
#temp_tablespaces = ''                  # a list of tablespace names, '' uses
                                        # only default tablespace
#check_function_bodies = on
#default_transaction_isolation = 'read committed'
#default_transaction_read_only = off
#default_transaction_deferrable = off
#session_replication_role = 'origin'
#statement_timeout = 0                  # in milliseconds, 0 is disabled
#lock_timeout = 0                       # in milliseconds, 0 is disabled
#idle_in_transaction_session_timeout = 0                # in milliseconds, 0 is disabled
#vacuum_freeze_min_age = 50000000
#vacuum_freeze_table_age = 150000000
#vacuum_multixact_freeze_min_age = 5000000
#vacuum_multixact_freeze_table_age = 150000000
#bytea_output = 'hex'                   # hex, escape
#xmlbinary = 'base64'
#xmloption = 'content'
#gin_fuzzy_search_limit = 0
#gin_pending_list_limit = 4MB

# - Locale and Formatting -

datestyle = 'iso, mdy'
#intervalstyle = 'postgres'
timezone = 'US/Pacific'
#timezone_abbreviations = 'Default'     # Select the set of available time zone
                                        # abbreviations.  Currently, there are
                                        #   Default
                                        #   Australia (historical usage)
                                        #   India
                                        # You can create your own file in
                                        # share/timezonesets/.
#extra_float_digits = 0                 # min -15, max 3
#client_encoding = sql_ascii            # actually, defaults to database
                                        # encoding

# These settings are initialized by initdb, but they can be changed.
lc_messages = 'en_US.UTF-8'                     # locale for system error message
                                        # strings
lc_monetary = 'en_US.UTF-8'                     # locale for monetary formatting
lc_numeric = 'en_US.UTF-8'                      # locale for number formatting
lc_time = 'en_US.UTF-8'                         # locale for time formatting

# default configuration for text search
default_text_search_config = 'pg_catalog.english'

# - Other Defaults -

#dynamic_library_path = '$libdir'
#local_preload_libraries = ''
#session_preload_libraries = ''


#------------------------------------------------------------------------------
# LOCK MANAGEMENT
#------------------------------------------------------------------------------

#deadlock_timeout = 1s
#max_locks_per_transaction = 64         # min 10
                                        # (change requires restart)
#max_pred_locks_per_transaction = 64    # min 10
                                        # (change requires restart)


#------------------------------------------------------------------------------
# VERSION/PLATFORM COMPATIBILITY
#------------------------------------------------------------------------------

# - Previous PostgreSQL Versions -

#array_nulls = on
#backslash_quote = safe_encoding        # on, off, or safe_encoding
#default_with_oids = off
#escape_string_warning = on
#lo_compat_privileges = off
#operator_precedence_warning = off
#quote_all_identifiers = off
#sql_inheritance = on
#standard_conforming_strings = on
#synchronize_seqscans = on

# - Other Platforms and Clients -

#transform_null_equals = off


#------------------------------------------------------------------------------
# ERROR HANDLING
#------------------------------------------------------------------------------

#exit_on_error = off                    # terminate session on any error?
#restart_after_crash = on               # reinitialize after backend crash?


#------------------------------------------------------------------------------
# CONFIG FILE INCLUDES
#------------------------------------------------------------------------------

# These options allow settings to be loaded from files other than the
# default postgresql.conf.

#include_dir = 'conf.d'                 # include files ending in '.conf' from
                                        # directory 'conf.d'
#include_if_exists = 'exists.conf'      # include file only if it exists
#include = 'special.conf'               # include file


#------------------------------------------------------------------------------
# CUSTOMIZED OPTIONS
#------------------------------------------------------------------------------

# Add settings for extensions here

Apenas querendo saber como atribuir o caminho binário a um servidor remoto. Eu tenho o pgAdmin no meu computador pessoal, mas o servidor (CentOS) no qual o PostgreSQL reside está em um local diferente.

Migramos nosso servidor web para um servidor mais novo. Temos o antigo e o novo em execução enquanto testamos o novo. O antigo ainda está sendo usado em produção por nossos clientes e equipe interna, portanto, está mais atualizado do que o novo, que estava atualizado há uma semana, quando tirou uma foto instantânea e fez a migração. Portanto, preciso migrar os novos dados do servidor antigo para o novo servidor. Qual é o melhor jeito de concluir isso? Se eu fizer um mysqldump e importar para o novo servidor, ele substituirá os dados que já estão lá? Tudo bem se assim for, apenas preocupado com a duplicação de registros. Basicamente, só quero pegar tudo o que está no servidor antigo e despejá-lo no novo quando não houver ninguém no sistema.

Estou tentando entender melhor as chaves primárias, como usá-las efetivamente no design da tabela e nas consultas.

Primeiro, as próprias chaves primárias são usadas nas cláusulas WHERE? Por exemplo, se eu tiver uma tabela de nomes e a chave primária estiver configurada como 'A' para todas as entradas com sobrenome começando com 'A', 'B' para todos os sobrenomes começando com 'B', etc. melhor prática para ter algo como:

WHERE pk_field = 'B' AND last_name = 'Bluthe'

Em segundo lugar, quero entender como uma chave primária de incremento automático seria melhor para desempenho do que apenas algo como:

SELECT last_name FROM names WHERE last_name = 'Bluthe'

Se a chave primária para este registro for 1247, seria

WHERE pk_field = 1247

ser muito melhor. A busca ainda não passaria por cada registro naquela coluna até encontrar uma correspondência?

realmente uma questão newb. No caso de algo como um sistema corporativo para uma empresa, onde os usuários finais estão executando leituras e gravações contínuas em um banco de dados, não parece que na maioria dos casos cada estação de trabalho precise dos drivers do banco de dados sendo usado. As credenciais estão sendo passadas pelo software, para o IP e a porta do banco de dados, e suponho que quando um novo usuário é adicionado ao software, ele o adiciona ao banco de dados e seus privilégios de leitura / gravação são atribuídos nesse ponto. O usuário fornece suas informações de login ao software que serve como suas credenciais para fazer leituras/gravações no banco de dados.

No entanto, se eu quiser acessar o banco de dados de um software de terceiros, Excel ou outro, preciso dos drivers para o banco de dados. Acho que não tenho certeza do porquê disso e queria saber se alguém poderia me explicar.

Um exemplo, uma empresa para a qual trabalhei, usava o IBM DB2. Tínhamos um sistema corporativo com o DB2 como banco de dados. Usando o software que o envolve, não me lembro de precisar dos drivers para ele. Quando começamos a escrever relatórios personalizados para ele no Excel, eu precisava dos drivers ODBC, assim como qualquer outra estação de trabalho que precisava da conexão Excel -> DB2.