/*
* Reconnect to the server. If dbname is not NULL, use that database,
* else the one associated with the archive handle. If username is
* not NULL, use that user name, else the one from the handle. If
* both the database and the user match the existing connection already,
* nothing will be done.
*
* Returns 1 in any case.
*/
int
ReconnectToServer(ArchiveHandle *AH, const char *dbname, const char *username)
{
PGconn *newConn;
const char *newdbname;
const char *newusername;
if (!dbname)
newdbname = PQdb(AH->connection);
else
newdbname = dbname;
if (!username)
newusername = PQuser(AH->connection);
else
newusername = username;
/* Let's see if the request is already satisfied */
if (strcmp(newdbname, PQdb(AH->connection)) == 0 &&
strcmp(newusername, PQuser(AH->connection)) == 0)
return 1;
newConn = _connectDB(AH, newdbname, newusername);
PQfinish(AH->connection);
AH->connection = newConn;
return 1;
}
/*
* Send a vacuum/analyze command to the server. In async mode, return after
* sending the command; else, wait for it to finish.
*
* Any errors during command execution are reported to stderr. If async is
* false, this function exits the program after reporting the error.
*/
static void
run_vacuum_command(PGconn *conn, const char *sql, bool echo,
const char *table, const char *progname, bool async)
{
bool status;
if (async)
{
if (echo)
printf("%s\n", sql);
status = PQsendQuery(conn, sql) == 1;
}
else
status = executeMaintenanceCommand(conn, sql, echo);
if (!status)
{
if (table)
fprintf(stderr,
_("%s: vacuuming of table \"%s\" in database \"%s\" failed: %s"),
progname, table, PQdb(conn), PQerrorMessage(conn));
else
fprintf(stderr, _("%s: vacuuming of database \"%s\" failed: %s"),
progname, PQdb(conn), PQerrorMessage(conn));
if (!async)
{
PQfinish(conn);
exit(1);
}
}
}
/* internal function to check if a table exists in the database
* takes an unescaped table name and returns an escaped one or null */
int db_unsafe_check_table(PGconn *pgsql, const char *table) {
int status;
char *query;
char *db;
PGresult *result;
db = PQdb(pgsql);
asprintf(&query,
"SELECT \"table_name\" FROM information_schema.tables WHERE table_catalog = '%s' AND table_schema = current_schema() AND table_name = '%s'",
db, table);
db_debug(HIGH, "Query = %s\n", query);
result = PQexec(pgsql, query);
free(query);
if (PQresultStatus(result) == PGRES_TUPLES_OK) {
if (PQntuples(result) == 1) {
debug(DEBUG, "%s found!\n", table);
status = TRUE;
} else {
debug(DEBUG, "%s missing!\n", table);
status = FALSE;
}
} else {
db_debug(LOW, "%s", PQerrorMessage(pgsql));
status = FALSE;
}
(void)PQclear(result);
return status;
}
void test_database_init()
{
scheduler_t* scheduler;
PGresult* db_result;
GString* sql;
scheduler = scheduler_init(testdb, NULL);
database_init(scheduler);
FO_ASSERT_PTR_NOT_NULL(scheduler->db_conn);
sprintf(sqltmp, check_scheduler_tables, PQdb(scheduler->db_conn));
sql = g_string_new(sqltmp);
g_string_append(sql, "'users';");
/* get the url for the fossology instance */
db_result = database_exec(scheduler, sql->str);
//printf("sql: %s\n", sql->str);
// TODO skip this test since the order reported here is random, also it will crash if PQntuples < 5
#if 0
if(PQresultStatus(db_result) == PGRES_TUPLES_OK && PQntuples(db_result) != 0)
{
//printf("result: %s\n", g_strdup(PQgetvalue(db_result, 0, 0)));
FO_ASSERT_STRING_EQUAL(g_strdup(PQgetvalue(db_result, 0, 0)), "user_pk");
FO_ASSERT_STRING_EQUAL(g_strdup(PQgetvalue(db_result, 1, 0)), "user_name");
FO_ASSERT_STRING_EQUAL(g_strdup(PQgetvalue(db_result, 2, 0)), "root_folder_fk");
FO_ASSERT_STRING_EQUAL(g_strdup(PQgetvalue(db_result, 3, 0)), "user_desc");
FO_ASSERT_STRING_EQUAL(g_strdup(PQgetvalue(db_result, 4, 0)), "user_seed");
}
#endif
PQclear(db_result);
g_string_free(sql, TRUE);
scheduler_destroy(scheduler);
}
/*
* Pass remote error/notice/warning through.
*/
void
plproxy_remote_error(ProxyFunction *func, ProxyConnection *conn, const PGresult *res, bool iserr)
{
const char *ss = PQresultErrorField(res, PG_DIAG_SQLSTATE);
const char *sev = PQresultErrorField(res, PG_DIAG_SEVERITY);
const char *msg = PQresultErrorField(res, PG_DIAG_MESSAGE_PRIMARY);
const char *det = PQresultErrorField(res, PG_DIAG_MESSAGE_DETAIL);
const char *hint = PQresultErrorField(res, PG_DIAG_MESSAGE_HINT);
const char *spos = PQresultErrorField(res, PG_DIAG_STATEMENT_POSITION);
const char *ipos = PQresultErrorField(res, PG_DIAG_INTERNAL_POSITION);
const char *iquery = PQresultErrorField(res, PG_DIAG_INTERNAL_QUERY);
const char *ctx = PQresultErrorField(res, PG_DIAG_CONTEXT);
int elevel;
/* libpq errors may not have sqlstate */
if (!ss)
ss = "XX000";
if (iserr)
/* must ignore remote level, as it may be FATAL/PANIC */
elevel = ERROR;
else
/* cannot look at sev here, as it may be localized */
elevel = !strncmp(ss, "00", 2) ? NOTICE : WARNING;
ereport(elevel, (
errcode(MAKE_SQLSTATE(ss[0], ss[1], ss[2], ss[3], ss[4])),
errmsg("%s(%d): [%s] REMOTE %s: %s", func->name, func->arg_count, PQdb(conn->cur->db), sev, msg),
det ? errdetail("Remote detail: %s", det) : 0,
hint ? errhint("Remote hint: %s", hint) : 0,
spos ? errposition(atoi(spos)) : 0,
ipos ? internalerrposition(atoi(ipos)) : 0,
iquery ? internalerrquery(iquery) : 0,
ctx ? errcontext("Remote context: %s", ctx) : 0));
}
/*! \param connect DB connect string
*/
QuillErrCode
PGSQLDatabase::connectDB()
{
if ((connection = PQconnectdb(con_str)) == NULL)
{
dprintf(D_ALWAYS, "Fatal error - unable to allocate connection to DB\n");
return QUILL_FAILURE;
}
if (PQstatus(connection) != CONNECTION_OK)
{
char *dbname;
dbname = PQdb(connection);
dprintf(D_ALWAYS, "Connection to database '%s' failed.\n", dbname);
dprintf(D_ALWAYS, "%s", PQerrorMessage(connection));
dprintf(D_ALWAYS, "Deallocating connection resources to database '%s'\n", dbname);
PQfinish(connection);
connection = NULL;
return QUILL_FAILURE;
}
connected = true;
return QUILL_SUCCESS;
}
static int
switch_database(struct dbpath *dbpath)
{
PGconn *newdbconn;
if (dbpath_is_root(*dbpath))
return 1;
if (strcmp(dbpath->database, PQdb(dbconn)) == 0)
return 1;
newdbconn = PQsetdbLogin(PQhost(dbconn),
PQport(dbconn),
PQoptions(dbconn),
PQtty(dbconn),
dbpath->database,
PQuser(dbconn),
PQpass(dbconn));
if (PQstatus(newdbconn) != CONNECTION_OK)
{
debug("new connection failed");
PQfinish(newdbconn);
return 0;
}
PQfinish(dbconn);
dbconn = newdbconn;
return 1;
}
/*
* GetQueryResult
*
* Process the query result. Returns true if there's no error, false
* otherwise -- but errors about trying to vacuum a missing relation are
* reported and subsequently ignored.
*/
static bool
GetQueryResult(PGconn *conn, const char *progname)
{
PGresult *result;
SetCancelConn(conn);
while ((result = PQgetResult(conn)) != NULL)
{
/*
* If errors are found, report them. Errors about a missing table are
* harmless so we continue processing; but die for other errors.
*/
if (PQresultStatus(result) != PGRES_COMMAND_OK)
{
char *sqlState = PQresultErrorField(result, PG_DIAG_SQLSTATE);
fprintf(stderr, _("%s: vacuuming of database \"%s\" failed: %s"),
progname, PQdb(conn), PQerrorMessage(conn));
if (sqlState && strcmp(sqlState, ERRCODE_UNDEFINED_TABLE) != 0)
{
PQclear(result);
return false;
}
}
PQclear(result);
}
ResetCancelConn();
return true;
}
/* [Re]connects to database */
static GSM_Error SMSDPgSQL_Connect(GSM_SMSDConfig * Config)
{
unsigned char buf[400];
PGresult *Res;
unsigned int port = 5432;
char *pport;
pport = strstr(Config->host, ":");
if (pport) {
*pport++ = '\0';
port = atoi(pport);
}
sprintf(buf, "host = '%s' user = '******' password = '******' dbname = '%s' port = %d", Config->host, Config->user, Config->password, Config->database, port);
SMSDPgSQL_Free(Config);
Config->conn.pg = PQconnectdb(buf);
if (PQstatus(Config->conn.pg) != CONNECTION_OK) {
SMSD_Log(DEBUG_ERROR, Config, "Error connecting to database: %s", PQerrorMessage(Config->conn.pg));
PQfinish(Config->conn.pg);
return ERR_DB_CONNECT;
}
Res = PQexec(Config->conn.pg, "SET NAMES UTF8");
PQclear(Res);
SMSD_Log(DEBUG_INFO, Config, "Connected to database: %s on %s. Server version: %d Protocol: %d",
PQdb(Config->conn.pg), PQhost(Config->conn.pg), PQserverVersion(Config->conn.pg), PQprotocolVersion(Config->conn.pg));
return ERR_NONE;
}
static int c_psql_check_connection (c_psql_database_t *db)
{
/* "ping" */
PQclear (PQexec (db->conn, "SELECT 42;"));
if (CONNECTION_OK != PQstatus (db->conn)) {
PQreset (db->conn);
/* trigger c_release() */
if (0 == db->conn_complaint.interval)
db->conn_complaint.interval = 1;
if (CONNECTION_OK != PQstatus (db->conn)) {
c_complain (LOG_ERR, &db->conn_complaint,
"Failed to connect to database %s: %s",
db->database, PQerrorMessage (db->conn));
return -1;
}
db->proto_version = PQprotocolVersion (db->conn);
if (3 > db->proto_version)
log_warn ("Protocol version %d does not support parameters.",
db->proto_version);
}
db->server_version = PQserverVersion (db->conn);
c_release (LOG_INFO, &db->conn_complaint,
"Successfully reconnected to database %s", PQdb (db->conn));
return 0;
} /* c_psql_check_connection */
static int c_psql_check_connection (c_psql_database_t *db)
{
_Bool init = 0;
if (! db->conn) {
init = 1;
/* trigger c_release() */
if (0 == db->conn_complaint.interval)
db->conn_complaint.interval = 1;
c_psql_connect (db);
}
/* "ping" */
PQclear (PQexec (db->conn, "SELECT 42;"));
if (CONNECTION_OK != PQstatus (db->conn)) {
PQreset (db->conn);
/* trigger c_release() */
if (0 == db->conn_complaint.interval)
db->conn_complaint.interval = 1;
if (CONNECTION_OK != PQstatus (db->conn)) {
c_complain (LOG_ERR, &db->conn_complaint,
"Failed to connect to database %s (%s): %s",
db->database, db->instance,
PQerrorMessage (db->conn));
return -1;
}
db->proto_version = PQprotocolVersion (db->conn);
}
db->server_version = PQserverVersion (db->conn);
if (c_would_release (&db->conn_complaint)) {
char *server_host;
int server_version;
server_host = PQhost (db->conn);
server_version = PQserverVersion (db->conn);
c_do_release (LOG_INFO, &db->conn_complaint,
"Successfully %sconnected to database %s (user %s) "
"at server %s%s%s (server version: %d.%d.%d, "
"protocol version: %d, pid: %d)", init ? "" : "re",
PQdb (db->conn), PQuser (db->conn),
C_PSQL_SOCKET3 (server_host, PQport (db->conn)),
C_PSQL_SERVER_VERSION3 (server_version),
db->proto_version, PQbackendPID (db->conn));
if (3 > db->proto_version)
log_warn ("Protocol version %d does not support parameters.",
db->proto_version);
}
return 0;
} /* c_psql_check_connection */
const wxString dbgPgConn::getName() const
{
wxString result = wxString( PQhost( m_pgConn ), wxConvUTF8 );
result += wxT( "/" );
result.Append( wxString( PQdb( m_pgConn ), wxConvUTF8 ));
return( result );
}
static void
cluster_one_database(const char *dbname, bool verbose, const char *table,
const char *host, const char *port,
const char *username, enum trivalue prompt_password,
const char *progname, bool echo)
{
PQExpBufferData sql;
PGconn *conn;
conn = connectDatabase(dbname, host, port, username, prompt_password,
progname, echo, false);
initPQExpBuffer(&sql);
appendPQExpBufferStr(&sql, "CLUSTER");
if (verbose)
appendPQExpBufferStr(&sql, " VERBOSE");
if (table)
{
appendPQExpBufferChar(&sql, ' ');
appendQualifiedRelation(&sql, table, conn, progname, echo);
}
appendPQExpBufferChar(&sql, ';');
if (!executeMaintenanceCommand(conn, sql.data, echo))
{
if (table)
fprintf(stderr, _("%s: clustering of table \"%s\" in database \"%s\" failed: %s"),
progname, table, PQdb(conn), PQerrorMessage(conn));
else
fprintf(stderr, _("%s: clustering of database \"%s\" failed: %s"),
progname, PQdb(conn), PQerrorMessage(conn));
PQfinish(conn);
exit(1);
}
PQfinish(conn);
termPQExpBuffer(&sql);
}
/*************************************************************************
*
* Function: sql_create_socket
*
* Purpose: Establish connection to the db
*
*************************************************************************/
static int sql_init_socket(rlm_sql_handle_t *handle, rlm_sql_config_t *config) {
char *dbstring;
rlm_sql_postgres_conn_t *conn;
#ifdef HAVE_OPENSSL_CRYPTO_H
static bool ssl_init = false;
if (!ssl_init) {
PQinitOpenSSL(0, 0);
ssl_init = true;
}
#endif
MEM(conn = handle->conn = talloc_zero(handle, rlm_sql_postgres_conn_t));
talloc_set_destructor(conn, _sql_socket_destructor);
dbstring = strchr(config->sql_db, '=') ?
talloc_strdup(conn, config->sql_db) :
talloc_asprintf(conn, "dbname='%s'", config->sql_db);
if (config->sql_server[0] != '\0') {
dbstring = talloc_asprintf_append(dbstring, " host='%s'", config->sql_server);
}
if (config->sql_port[0] != '\0') {
dbstring = talloc_asprintf_append(dbstring, " port=%s", config->sql_port);
}
if (config->sql_login[0] != '\0') {
dbstring = talloc_asprintf_append(dbstring, " user='******'", config->sql_login);
}
if (config->sql_password[0] != '\0') {
dbstring = talloc_asprintf_append(dbstring, " password='******'", config->sql_password);
}
conn->dbstring = dbstring;
conn->db = PQconnectdb(dbstring);
DEBUG2("rlm_sql_postgresql: Connecting using parameters: %s", dbstring);
if (!conn->db || (PQstatus(conn->db) != CONNECTION_OK)) {
ERROR("rlm_sql_postgresql: Connection failed: %s", PQerrorMessage(conn->db));
return -1;
}
DEBUG2("Connected to database '%s' on '%s' server version %i, protocol version %i, backend PID %i ",
PQdb(conn->db), PQhost(conn->db), PQserverVersion(conn->db), PQprotocolVersion(conn->db),
PQbackendPID(conn->db));
return 0;
}
void
sql_shutdown()
{
PGconn *pgsql;
if (!pgsql_struct)
return;
pgsql = pgsql_struct;
STARTLOG(LOG_ALWAYS, "SQL", "DISC")
log_printf
("Disconnected from SQL server %s, SQL database selected: %s",
PQhost(pgsql), PQdb(pgsql));
ENDLOG PQfinish(pgsql);
pgsql_struct = NULL;
mudstate.sql_socket = -1;
}
/*
* SyncVariables
*
* Make psql's internal variables agree with connection state upon
* establishing a new connection.
*/
void
SyncVariables(void)
{
/* get stuff from connection */
pset.encoding = PQclientEncoding(pset.db);
pset.popt.topt.encoding = pset.encoding;
pset.sversion = PQserverVersion(pset.db);
SetVariable(pset.vars, "DBNAME", PQdb(pset.db));
SetVariable(pset.vars, "USER", PQuser(pset.db));
SetVariable(pset.vars, "HOST", PQhost(pset.db));
SetVariable(pset.vars, "PORT", PQport(pset.db));
SetVariable(pset.vars, "ENCODING", pg_encoding_to_char(pset.encoding));
/* send stuff to it, too */
PQsetErrorVerbosity(pset.db, pset.verbosity);
}
/**
@brief Check if table exists.
Note, this assumes the database name is 'fossology'.
@param pgConn database connection
@param tableName
@todo REMOVE hardcoded catalog name "fossology"
@return 1 if table exists, 0 on error (which is logged) or if table does not exist.
****************************************************/
int fo_tableExists(PGconn *pgConn, char *tableName)
{
char sql[256];
PGresult *result;
int TabCount;
snprintf(sql, sizeof(sql),
"select count(*) from information_schema.tables where table_catalog='%s' and table_name='%s'",
PQdb(pgConn), tableName);
result = PQexec(pgConn, sql);
if (fo_checkPQresult(pgConn, result, sql, __FILE__, __LINE__)) return 0;
TabCount = atol(PQgetvalue(result, 0, 0));
PQclear(result);
return(TabCount);
} /* fo_tableExists() */
void test_database_exec_event()
{
scheduler_t* scheduler;
GString* sql;
scheduler = scheduler_init(testdb, NULL);
FO_ASSERT_PTR_NULL(scheduler->db_conn);
database_init(scheduler);
FO_ASSERT_PTR_NOT_NULL(scheduler->db_conn);
sprintf(sqltmp, check_scheduler_tables, PQdb(scheduler->db_conn));
sql = g_string_new(sqltmp);
g_string_append(sql, "'user';");
database_exec_event(scheduler, sql->str);
scheduler_destroy(scheduler);
}
EtatConnexion::EtatConnexion()
{
map <string, string> paramsDic;
SIPgSql& instance = SIPgSql::Instance(paramsDic);
conn = instance.getConn();
if (PQstatus(conn) == CONNECTION_OK) { // --------
PGresult *res; // --------
res = PQexec(conn, "select version() as version"); // --------
wxString textValue;
textValue.Append("host : '"); textValue.Append(PQhost(conn));
textValue.Append("' ; port : '"); textValue.Append(PQport(conn));
textValue.Append("' ; dbname : '"); textValue.Append(PQdb(conn));
textValue.Append("' ; user : '******' ;\n\n"); textValue.Append(PQgetvalue(res, 0, 0));
wxMessageBox(textValue, wxT("Statut de la connexion : OK"));
} else { // devrait pas arriver !!!
wxMessageBox(wxT("Choisir : Connexion->Nouvelle connexion"), wxT("Statut de la connexion : pas de connexion"));
}
}
LispObj *
Lisp_PQdb(LispBuiltin *builtin)
/*
pq-db connection
*/
{
char *string;
PGconn *conn;
LispObj *connection;
connection = ARGUMENT(0);
if (!CHECKO(connection, PGconn_t))
LispDestroy("%s: cannot convert %s to PGconn*",
STRFUN(builtin), STROBJ(connection));
conn = (PGconn*)(connection->data.opaque.data);
string = PQdb(conn);
return (string ? STRING(string) : NIL);
}
/*
* Attempt to get the name of relation and copy to relName
* (if there's a database connection and the reloid changed)
* Copy a string with oid if not found
*/
char *
getRelName(uint32 relid, char *buf, size_t buflen)
{
char dbQry[1024];
/* Try the relfilenode and oid just in case the filenode has changed
If it has changed more than once we can't translate it's name */
snprintf(dbQry, sizeof(dbQry), "SELECT relname, oid FROM pg_class WHERE relfilenode = %i OR oid = %i", relid, relid);
if (cache_get(relid))
{
snprintf(buf, buflen, "%s", cache_get(relid));
return buf;
}
/*
* If the xlog record has some information about rmgr operation on
* a different database, it needs to establish a new connection
* to the different database in order to retrieve a object name
* from the system catalog.
*/
if (conn && strcmp(PQdb(conn), dbName) != 0)
{
/*
* Re-connect to the different database.
*/
if (conn)
PQfinish(conn);
conn = PQsetdbLogin(pghost, pgport, NULL, NULL,
dbName, pguser, pgpass);
}
oid2name_get_name(relid, buf, buflen, dbQry);
return buf;
}
int main()
{
// próba po³±czenia
PGconn *myconnection = PQconnectdb("");
// sprawdzamy status po³±czenia
if(PQstatus(myconnection) == CONNECTION_OK) {
printf("connection made\n");
// informacje o po³±czeniu
printf("PGDBNAME = %s\n",PQdb(myconnection));
printf("PGUSER = %s\n",PQuser(myconnection));
printf("PGPASSWORD = %s\n",PQpass(myconnection));
printf("PGHOST = %s\n",PQhost(myconnection));
printf("PGPORT = %s\n",PQport(myconnection));
printf("OPTIONS = %s\n",PQoptions(myconnection));
}
else
printf("connection failed: %s\n", PQerrorMessage(myconnection));
// w razie utraty po³±czenia wywo³anie
// PQreset(myconnection);
// zamyka op³±czenie i nawi±zuje je raz jeszcze
// z dotychczasowymi parametrami
PQfinish(myconnection);
return EXIT_SUCCESS;
}
/*
* ProcessQueryResult
*
* Process (and delete) a query result. Returns true if there's no error,
* false otherwise -- but errors about trying to vacuum a missing relation
* are reported and subsequently ignored.
*/
static bool
ProcessQueryResult(PGconn *conn, PGresult *result, const char *progname)
{
/*
* If it's an error, report it. Errors about a missing table are harmless
* so we continue processing; but die for other errors.
*/
if (PQresultStatus(result) != PGRES_COMMAND_OK)
{
char *sqlState = PQresultErrorField(result, PG_DIAG_SQLSTATE);
fprintf(stderr, _("%s: vacuuming of database \"%s\" failed: %s"),
progname, PQdb(conn), PQerrorMessage(conn));
if (sqlState && strcmp(sqlState, ERRCODE_UNDEFINED_TABLE) != 0)
{
PQclear(result);
return false;
}
}
PQclear(result);
return true;
}
/*
* slashUsage
*
* print out help for the backslash commands
*/
void
slashUsage(unsigned short int pager)
{
FILE *output;
char *currdb;
currdb = PQdb(pset.db);
if (currdb == NULL)
currdb = "";
output = PageOutput(90, pager);
/* if you add/remove a line here, change the row count above */
fprintf(output, _("General\n"));
fprintf(output, _(" \\copyright show PostgreSQL usage and distribution terms\n"));
fprintf(output, _(" \\g [FILE] or ; execute query (and send results to file or |pipe)\n"));
fprintf(output, _(" \\h [NAME] help on syntax of SQL commands, * for all commands\n"));
fprintf(output, _(" \\q quit psql\n"));
fprintf(output, "\n");
fprintf(output, _("Query Buffer\n"));
fprintf(output, _(" \\e [FILE] edit the query buffer (or file) with external editor\n"));
fprintf(output, _(" \\ef [FUNCNAME] edit function definition with external editor\n"));
fprintf(output, _(" \\p show the contents of the query buffer\n"));
fprintf(output, _(" \\r reset (clear) the query buffer\n"));
#ifdef USE_READLINE
fprintf(output, _(" \\s [FILE] display history or save it to file\n"));
#endif
fprintf(output, _(" \\w FILE write query buffer to file\n"));
fprintf(output, "\n");
fprintf(output, _("Input/Output\n"));
fprintf(output, _(" \\copy ... perform SQL COPY with data stream to the client host\n"));
fprintf(output, _(" \\echo [STRING] write string to standard output\n"));
fprintf(output, _(" \\i FILE execute commands from file\n"));
fprintf(output, _(" \\o [FILE] send all query results to file or |pipe\n"));
fprintf(output, _(" \\qecho [STRING] write string to query output stream (see \\o)\n"));
fprintf(output, "\n");
fprintf(output, _("Informational\n"));
fprintf(output, _(" (options: S = show system objects, + = additional detail)\n"));
fprintf(output, _(" \\d[S+] list tables, views, and sequences\n"));
fprintf(output, _(" \\d[S+] NAME describe table, view, sequence, or index\n"));
fprintf(output, _(" \\da[S] [PATTERN] list aggregates\n"));
fprintf(output, _(" \\db[+] [PATTERN] list tablespaces\n"));
fprintf(output, _(" \\dc[S] [PATTERN] list conversions\n"));
fprintf(output, _(" \\dC [PATTERN] list casts\n"));
fprintf(output, _(" \\dd[S] [PATTERN] show comments on objects\n"));
fprintf(output, _(" \\ddp [PATTERN] list default privileges\n"));
fprintf(output, _(" \\dD[S] [PATTERN] list domains\n"));
fprintf(output, _(" \\des[+] [PATTERN] list foreign servers\n"));
fprintf(output, _(" \\deu[+] [PATTERN] list user mappings\n"));
fprintf(output, _(" \\dew[+] [PATTERN] list foreign-data wrappers\n"));
fprintf(output, _(" \\df[antw][S+] [PATRN] list [only agg/normal/trigger/window] functions\n"));
fprintf(output, _(" \\dF[+] [PATTERN] list text search configurations\n"));
fprintf(output, _(" \\dFd[+] [PATTERN] list text search dictionaries\n"));
fprintf(output, _(" \\dFp[+] [PATTERN] list text search parsers\n"));
fprintf(output, _(" \\dFt[+] [PATTERN] list text search templates\n"));
fprintf(output, _(" \\dg[+] [PATTERN] list roles (groups)\n"));
fprintf(output, _(" \\dx[+] [PATTERN] list extensions\n"));
fprintf(output, _(" \\di[S+] [PATTERN] list indexes\n"));
fprintf(output, _(" \\dl list large objects, same as \\lo_list\n"));
fprintf(output, _(" \\dn[+] [PATTERN] list schemas\n"));
fprintf(output, _(" \\do[S] [PATTERN] list operators\n"));
fprintf(output, _(" \\dp [PATTERN] list table, view, and sequence access privileges\n"));
fprintf(output, _(" \\dr[S+] [PATTERN] list foreign tables\n")); /* GPDB Only */
fprintf(output, _(" \\drds [PATRN1 [PATRN2]] list per-database role settings\n"));
fprintf(output, _(" \\ds[S+] [PATTERN] list sequences\n"));
fprintf(output, _(" \\dt[S+] [PATTERN] list tables\n"));
fprintf(output, _(" \\dT[S+] [PATTERN] list data types\n"));
fprintf(output, _(" \\du[+] [PATTERN] list roles (users)\n"));
fprintf(output, _(" \\dv[S+] [PATTERN] list views\n"));
fprintf(output, _(" \\dE [PATTERN] list external tables\n"));
fprintf(output, _(" \\l[+] list all databases\n"));
fprintf(output, _(" \\z [PATTERN] same as \\dp\n"));
fprintf(output, "\n");
fprintf(output, _("Formatting\n"));
fprintf(output, _(" \\a toggle between unaligned and aligned output mode\n"));
fprintf(output, _(" \\C [STRING] set table title, or unset if none\n"));
fprintf(output, _(" \\f [STRING] show or set field separator for unaligned query output\n"));
fprintf(output, _(" \\H toggle HTML output mode (currently %s)\n"),
ON(pset.popt.topt.format == PRINT_HTML));
fprintf(output, _(" \\pset NAME [VALUE] set table output option\n"
" (NAME := {format|border|expanded|fieldsep|footer|null|\n"
" numericlocale|recordsep|tuples_only|title|tableattr|pager})\n"));
fprintf(output, _(" \\t [on|off] show only rows (currently %s)\n"),
ON(pset.popt.topt.tuples_only));
fprintf(output, _(" \\T [STRING] set HTML <table> tag attributes, or unset if none\n"));
fprintf(output, _(" \\x [on|off] toggle expanded output (currently %s)\n"),
ON(pset.popt.topt.expanded));
fprintf(output, "\n");
fprintf(output, _("Connection\n"));
fprintf(output, _(" \\c[onnect] [DBNAME|- USER|- HOST|- PORT|-]\n"
" connect to new database (currently \"%s\")\n"),
PQdb(pset.db));
fprintf(output, _(" \\encoding [ENCODING] show or set client encoding\n"));
fprintf(output, _(" \\password [USERNAME] securely change the password for a user\n"));
fprintf(output, _(" \\conninfo display information about current connection\n"));
fprintf(output, "\n");
fprintf(output, _("Operating System\n"));
fprintf(output, _(" \\cd [DIR] change the current working directory\n"));
fprintf(output, _(" \\timing [on|off] toggle timing of commands (currently %s)\n"),
ON(pset.timing));
fprintf(output, _(" \\! [COMMAND] execute command in shell or start interactive shell\n"));
fprintf(output, "\n");
fprintf(output, _("Variables\n"));
fprintf(output, _(" \\prompt [TEXT] NAME prompt user to set internal variable\n"));
fprintf(output, _(" \\set [NAME [VALUE]] set internal variable, or list all if no parameters\n"));
fprintf(output, _(" \\unset NAME unset (delete) internal variable\n"));
fprintf(output, "\n");
fprintf(output, _("Large Objects\n"));
fprintf(output, _(" \\lo_export LOBOID FILE\n"
" \\lo_import FILE [COMMENT]\n"
" \\lo_list\n"
" \\lo_unlink LOBOID large object operations\n"));
if (output != stdout)
{
pclose(output);
#ifndef WIN32
pqsignal(SIGPIPE, SIG_DFL);
#endif
}
}
Con_Handle *
RS_PostgreSQL_newConnection(Mgr_Handle * mgrHandle, s_object * con_params)
{
S_EVALUATOR RS_DBI_connection * con;
RS_PostgreSQL_conParams *conParams;
Con_Handle *conHandle;
PGconn *my_connection;
const char *user = NULL, *password = NULL, *host = NULL, *dbname = NULL, *port = NULL, *tty = NULL, *options = NULL;
if (!is_validHandle(mgrHandle, MGR_HANDLE_TYPE)) {
RS_DBI_errorMessage("invalid PostgreSQLManager", RS_DBI_ERROR);
}
user = CHR_EL(con_params, 0);
password = CHR_EL(con_params, 1);
host = CHR_EL(con_params, 2);
dbname = CHR_EL(con_params, 3);
port = CHR_EL(con_params, 4);
tty = CHR_EL(con_params, 5);
options = CHR_EL(con_params, 6);
my_connection = PQsetdbLogin(host, port, options, tty, dbname, user, password);
conParams = RS_postgresql_allocConParams();
/* save actual connection parameters */
conParams->user = RS_DBI_copyString(PQuser(my_connection));
conParams->password = RS_DBI_copyString(PQpass(my_connection));
{
const char *tmphost = PQhost(my_connection);
if (tmphost) {
conParams->host = RS_DBI_copyString(tmphost);
} else {
conParams->host = RS_DBI_copyString("");
}
}
conParams->dbname = RS_DBI_copyString(PQdb(my_connection));
conParams->port = RS_DBI_copyString(PQport(my_connection));
conParams->tty = RS_DBI_copyString(PQtty(my_connection));
conParams->options = RS_DBI_copyString(PQoptions(my_connection));
if (PQstatus(my_connection) != CONNECTION_OK) {
char buf[1000];
sprintf(buf, "could not connect %s@%s on dbname \"%s\"\n", PQuser(my_connection), host?host:"local", PQdb(my_connection));
PQfinish(my_connection);
my_connection = NULL;
RS_PostgreSQL_freeConParams(conParams); /*free BEFORE emitting err message that do not come back */
RS_DBI_errorMessage(buf, RS_DBI_ERROR);
return R_NilValue; /* don't reach here as it goes back to R proc */
}
PROTECT(conHandle = RS_DBI_allocConnection(mgrHandle, (Sint) 1)); /* The second argument (1) specifies the number of result sets allocated */
con = RS_DBI_getConnection(conHandle);
if (my_connection && !con) {
PQfinish(my_connection);
my_connection = NULL;
RS_PostgreSQL_freeConParams(conParams);
conParams = (RS_PostgreSQL_conParams *) NULL;
RS_DBI_errorMessage("could not alloc space for connection object", RS_DBI_ERROR);
}
if(con) {
con->drvConnection = (void *) my_connection;
con->conParams = (void *) conParams;
}
UNPROTECT(1);
return conHandle;
}
bool
GetRestoreSegmentDatabaseArray(PGconn *pConn,
RestorePairArray * restorePairAr,
BackupLoc backupLocation,
char *restore_set_str,
bool dataOnly)
{
bool bRtn = true;
PQExpBuffer pQry = NULL;
PGresult *pRes = NULL;
int ntups;
int count;
int i_dbid;
int i_content;
int i_host;
int i_port;
int i;
int j;
int x;
int dbidset_count = 0;
int *dbidset = NULL;
SegmentDatabase *sourceSegDB;
SegmentDatabase *targetSegDB;
pQry = createPQExpBuffer();
appendPQExpBuffer(pQry, "SELECT"
" dbid,"
" content,"
" hostname,"
" port "
"FROM "
" gp_segment_configuration "
"WHERE role='p' "
"ORDER BY content DESC");
pRes = PQexec(pConn, pQry->data);
if (!pRes || PQresultStatus(pRes) != PGRES_TUPLES_OK)
{
mpp_err_msg("ERROR", "gp_restore", "query to obtain list of Greenplum segment databases failed: %s",
PQerrorMessage(pConn));
bRtn = false;
goto cleanup;
}
ntups = PQntuples(pRes);
if (ntups <= 0)
{
mpp_err_msg("ERROR", "gp_restore", "no Greenplum segment databases found on master segment schema");
bRtn = false;
goto cleanup;
}
count = ntups + 1;
/*
* Allocate enough memory for all of them, even though some may be
* filtered out.
*/
restorePairAr->count = 0;
restorePairAr->pData = (RestorePair *) calloc(count, sizeof(RestorePair));
if (restorePairAr->pData == NULL)
{
mpp_err_msg("ERROR", "gp_restore", "Unable to allocate memory for Greenplum segment database information\n");
bRtn = false;
goto cleanup;
}
/* get the column numbers */
i_dbid = PQfnumber(pRes, "dbid");
i_content = PQfnumber(pRes, "content");
i_host = PQfnumber(pRes, "hostname");
i_port = PQfnumber(pRes, "port");
/*
* if the dump file is on individual databases, parse the list of dbid's
* where those files exist.
*/
if (backupLocation == FILE_ON_INDIVIDUAL)
{
/* allocate dbidset. len is more than we need but it's a safe bet */
dbidset = (int *) calloc(strlen(restore_set_str), sizeof(int));
MemSet(dbidset, 0, strlen(restore_set_str) * sizeof(int));
if (dbidset == NULL)
{
mpp_err_msg("ERROR", "gp_restore", "Unable to allocate memory for Greenplum dbidset information\n");
bRtn = false;
goto cleanup;
}
/* parse the user specified dbid list, return dbid count */
dbidset_count = parseDbidSet(dbidset, restore_set_str);
if (dbidset_count < 1)
{
bRtn = false;
goto cleanup;
}
for (i = 0; i < dbidset_count; i++)
{
bool match = false;
for (j = 0; j < ntups; j++)
{
int dbid = atoi(PQgetvalue(pRes, j, i_dbid));
if (dbid == dbidset[i])
{
match = true;
break;
}
}
if (!match)
{
mpp_err_msg("ERROR", "gp_restore", "dbid %d is not a primary Greenplum segment databases entry\n",
dbidset[i]);
bRtn = false;
goto cleanup;
}
}
}
mpp_err_msg("INFO", "gp_restore", "Preparing to restore the following segments:\n");
/* Read through the results set. */
x = 0;
for (i = 0; i < ntups; i++)
{
int dbid = atoi(PQgetvalue(pRes, i, i_dbid));
int contentid = atoi(PQgetvalue(pRes, i, i_content));
bool should_restore = false;
/* if dataOnly don't restore the master (table definitions) */
if (dataOnly && contentid == -1)
continue;
if (backupLocation == FILE_ON_INDIVIDUAL)
{
should_restore = false;
for (j = 0; j < dbidset_count; j++)
{
if (dbid == dbidset[j])
should_restore = true;
}
if (!should_restore)
continue;
}
targetSegDB = &restorePairAr->pData[x].segdb_target;
targetSegDB->dbid = dbid;
targetSegDB->role = (contentid == -1 ? ROLE_MASTER : ROLE_SEGDB);
targetSegDB->port = atoi(PQgetvalue(pRes, i, i_port));
targetSegDB->pszHost = strdup(PQgetvalue(pRes, i, i_host));
targetSegDB->pszDBName = PQdb(pConn);
targetSegDB->pszDBUser = PQuser(pConn);
targetSegDB->pszDBPswd = PQpass(pConn);
targetSegDB->content = contentid;
sourceSegDB = &restorePairAr->pData[x].segdb_source;
sourceSegDB->dbid = targetSegDB->dbid;
sourceSegDB->role = targetSegDB->role;
sourceSegDB->port = targetSegDB->port;
sourceSegDB->pszHost = targetSegDB->pszHost;
sourceSegDB->pszDBName = targetSegDB->pszDBName;
sourceSegDB->pszDBUser = targetSegDB->pszDBUser;
if (targetSegDB->pszDBPswd)
sourceSegDB->pszDBPswd = targetSegDB->pszDBPswd;
if (targetSegDB->role == ROLE_MASTER)
mpp_err_msg("INFO", "gp_restore", "Master (dbid 1)\n");
else
mpp_err_msg("INFO", "gp_restore", "Segment %d (dbid %d)\n",
contentid,
targetSegDB->dbid);
x++;
}
/* set the count to be the number that passed the set inclusion test */
restorePairAr->count = x;
cleanup:
if (pQry != NULL)
destroyPQExpBuffer(pQry);
if (pRes != NULL)
PQclear(pRes);
return bRtn;
}
snprintf(connect_string, CONNECT_STRING_SIZE,
"host = '%s' dbname = '%s' user = '******' password = '******'",
mudconf.sql_host, mudconf.sql_db, mudconf.sql_username,
mudconf.sql_password);
pgsql = PQconnectdb(connect_string);
if (!pgsql)
{
STARTLOG(LOG_ALWAYS, "SQL", "CONN")
log_printf("Failed connection to SQL server %s: %s",
mudconf.sql_host, PQerrorMessage(pgsql));
ENDLOG return -1;
}
STARTLOG(LOG_ALWAYS, "SQL", "CONN")
log_printf("Connected to SQL server %s, SQL database selected: %s",
PQhost(pgsql), PQdb(pgsql));
ENDLOG pgsql_struct = pgsql;
mudstate.sql_socket = PQsocket(pgsql);
return 1;
}
int
sql_query(player, q_string, buff, bufc, row_delim, field_delim)
dbref player;
char *q_string;
char *buff;
char **bufc;
/*
* do_connect -- handler for \connect
*
* Connects to a database with given parameters. If there exists an
* established connection, NULL values will be replaced with the ones
* in the current connection. Otherwise NULL will be passed for that
* parameter to PQconnectdbParams(), so the libpq defaults will be used.
*
* In interactive mode, if connection fails with the given parameters,
* the old connection will be kept.
*/
static bool
do_connect(char *dbname, char *user, char *host, char *port)
{
PGconn *o_conn = pset.db,
*n_conn;
char *password = NULL;
if (!dbname)
dbname = PQdb(o_conn);
if (!user)
user = PQuser(o_conn);
if (!host)
host = PQhost(o_conn);
if (!port)
port = PQport(o_conn);
/*
* If the user asked to be prompted for a password, ask for one now. If
* not, use the password from the old connection, provided the username
* has not changed. Otherwise, try to connect without a password first,
* and then ask for a password if needed.
*
* XXX: this behavior leads to spurious connection attempts recorded in
* the postmaster's log. But libpq offers no API that would let us obtain
* a password and then continue with the first connection attempt.
*/
if (pset.getPassword == TRI_YES)
{
password = prompt_for_password(user);
}
else if (o_conn && user && strcmp(PQuser(o_conn), user) == 0)
{
password = strdup(PQpass(o_conn));
}
while (true)
{
#define PARAMS_ARRAY_SIZE 7
const char **keywords = pg_malloc(PARAMS_ARRAY_SIZE * sizeof(*keywords));
const char **values = pg_malloc(PARAMS_ARRAY_SIZE * sizeof(*values));
keywords[0] = "host";
values[0] = host;
keywords[1] = "port";
values[1] = port;
keywords[2] = "user";
values[2] = user;
keywords[3] = "password";
values[3] = password;
keywords[4] = "dbname";
values[4] = dbname;
keywords[5] = "fallback_application_name";
values[5] = pset.progname;
keywords[6] = NULL;
values[6] = NULL;
n_conn = PQconnectdbParams(keywords, values, true);
free(keywords);
free(values);
/* We can immediately discard the password -- no longer needed */
if (password)
free(password);
if (PQstatus(n_conn) == CONNECTION_OK)
break;
/*
* Connection attempt failed; either retry the connection attempt with
* a new password, or give up.
*/
if (!password && PQconnectionNeedsPassword(n_conn) && pset.getPassword != TRI_NO)
{
PQfinish(n_conn);
password = prompt_for_password(user);
continue;
}
/*
* Failed to connect to the database. In interactive mode, keep the
* previous connection to the DB; in scripting mode, close our
* previous connection as well.
*/
if (pset.cur_cmd_interactive)
{
psql_error("%s", PQerrorMessage(n_conn));
/* pset.db is left unmodified */
if (o_conn)
fputs(_("Previous connection kept\n"), stderr);
}
else
{
psql_error("\\connect: %s", PQerrorMessage(n_conn));
if (o_conn)
{
PQfinish(o_conn);
pset.db = NULL;
}
}
PQfinish(n_conn);
return false;
}
/*
* Replace the old connection with the new one, and update
* connection-dependent variables.
*/
PQsetNoticeProcessor(n_conn, NoticeProcessor, NULL);
pset.db = n_conn;
SyncVariables();
connection_warnings(false); /* Must be after SyncVariables */
/* Tell the user about the new connection */
if (!pset.quiet)
{
if (param_is_newly_set(PQhost(o_conn), PQhost(pset.db)) ||
param_is_newly_set(PQport(o_conn), PQport(pset.db)))
{
char *host = PQhost(pset.db);
if (host == NULL)
host = DEFAULT_PGSOCKET_DIR;
/* If the host is an absolute path, the connection is via socket */
if (is_absolute_path(host))
printf(_("You are now connected to database \"%s\" as user \"%s\" via socket in \"%s\" at port \"%s\".\n"),
PQdb(pset.db), PQuser(pset.db), host, PQport(pset.db));
else
printf(_("You are now connected to database \"%s\" as user \"%s\" on host \"%s\" at port \"%s\".\n"),
PQdb(pset.db), PQuser(pset.db), host, PQport(pset.db));
}
else
printf(_("You are now connected to database \"%s\" as user \"%s\".\n"),
PQdb(pset.db), PQuser(pset.db));
}
if (o_conn)
PQfinish(o_conn);
return true;
}
/*
* Subroutine to actually try to execute a backslash command.
*/
static backslashResult
exec_command(const char *cmd,
PsqlScanState scan_state,
PQExpBuffer query_buf)
{
bool success = true; /* indicate here if the command ran ok or
* failed */
backslashResult status = PSQL_CMD_SKIP_LINE;
/*
* \a -- toggle field alignment This makes little sense but we keep it
* around.
*/
if (strcmp(cmd, "a") == 0)
{
if (pset.popt.topt.format != PRINT_ALIGNED)
success = do_pset("format", "aligned", &pset.popt, pset.quiet);
else
success = do_pset("format", "unaligned", &pset.popt, pset.quiet);
}
/* \C -- override table title (formerly change HTML caption) */
else if (strcmp(cmd, "C") == 0)
{
char *opt = psql_scan_slash_option(scan_state,
OT_NORMAL, NULL, true);
success = do_pset("title", opt, &pset.popt, pset.quiet);
free(opt);
}
/*
* \c or \connect -- connect to database using the specified parameters.
*
* \c dbname user host port
*
* If any of these parameters are omitted or specified as '-', the current
* value of the parameter will be used instead. If the parameter has no
* current value, the default value for that parameter will be used. Some
* examples:
*
* \c - - hst Connect to current database on current port of host
* "hst" as current user. \c - usr - prt Connect to current database on
* "prt" port of current host as user "usr". \c dbs Connect to
* "dbs" database on current port of current host as current user.
*/
else if (strcmp(cmd, "c") == 0 || strcmp(cmd, "connect") == 0)
{
char *opt1,
*opt2,
*opt3,
*opt4;
opt1 = read_connect_arg(scan_state);
opt2 = read_connect_arg(scan_state);
opt3 = read_connect_arg(scan_state);
opt4 = read_connect_arg(scan_state);
success = do_connect(opt1, opt2, opt3, opt4);
free(opt1);
free(opt2);
free(opt3);
free(opt4);
}
/* \cd */
else if (strcmp(cmd, "cd") == 0)
{
char *opt = psql_scan_slash_option(scan_state,
OT_NORMAL, NULL, true);
char *dir;
if (opt)
dir = opt;
else
{
#ifndef WIN32
struct passwd *pw;
pw = getpwuid(geteuid());
if (!pw)
{
psql_error("could not get home directory: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
dir = pw->pw_dir;
#else /* WIN32 */
/*
* On Windows, 'cd' without arguments prints the current
* directory, so if someone wants to code this here instead...
*/
dir = "/";
#endif /* WIN32 */
}
if (chdir(dir) == -1)
{
psql_error("\\%s: could not change directory to \"%s\": %s\n",
cmd, dir, strerror(errno));
success = false;
}
if (pset.dirname)
free(pset.dirname);
pset.dirname = pg_strdup(dir);
canonicalize_path(pset.dirname);
if (opt)
free(opt);
}
/* \conninfo -- display information about the current connection */
else if (strcmp(cmd, "conninfo") == 0)
{
char *db = PQdb(pset.db);
char *host = PQhost(pset.db);
if (db == NULL)
printf(_("You are not connected.\n"));
else
{
if (host == NULL)
host = DEFAULT_PGSOCKET_DIR;
/* If the host is an absolute path, the connection is via socket */
if (is_absolute_path(host))
printf(_("You are connected to database \"%s\" as user \"%s\" via socket in \"%s\" at port \"%s\".\n"),
db, PQuser(pset.db), host, PQport(pset.db));
else
printf(_("You are connected to database \"%s\" as user \"%s\" on host \"%s\" at port \"%s\".\n"),
db, PQuser(pset.db), host, PQport(pset.db));
}
}
/* \copy */
else if (pg_strcasecmp(cmd, "copy") == 0)
{
/* Default fetch-it-all-and-print mode */
instr_time before,
after;
char *opt = psql_scan_slash_option(scan_state,
OT_WHOLE_LINE, NULL, false);
if (pset.timing)
INSTR_TIME_SET_CURRENT(before);
success = do_copy(opt);
if (pset.timing && success)
{
INSTR_TIME_SET_CURRENT(after);
INSTR_TIME_SUBTRACT(after, before);
printf(_("Time: %.3f ms\n"), INSTR_TIME_GET_MILLISEC(after));
}
free(opt);
}
/* \copyright */
else if (strcmp(cmd, "copyright") == 0)
print_copyright();
/* \d* commands */
else if (cmd[0] == 'd')
{
char *pattern;
bool show_verbose,
show_system;
/* We don't do SQLID reduction on the pattern yet */
pattern = psql_scan_slash_option(scan_state,
OT_NORMAL, NULL, true);
show_verbose = strchr(cmd, '+') ? true : false;
show_system = strchr(cmd, 'S') ? true : false;
switch (cmd[1])
{
case '\0':
case '+':
case 'S': /* GPDB: This is a change from old behavior: We used to show just system tables */
if (pattern)
success = describeTableDetails(pattern, show_verbose, show_system);
else
/* standard listing of interesting things */
success = listTables("tvsxr", NULL, show_verbose, show_system);
break;
case 'a':
success = describeAggregates(pattern, show_verbose, show_system);
break;
case 'b':
success = describeTablespaces(pattern, show_verbose);
break;
case 'c':
success = listConversions(pattern, show_system);
break;
case 'C':
success = listCasts(pattern);
break;
case 'd':
if (strncmp(cmd, "ddp", 3) == 0)
success = listDefaultACLs(pattern);
else
success = objectDescription(pattern, show_system);
break;
case 'D':
success = listDomains(pattern, show_system);
break;
case 'f': /* function subsystem */
switch (cmd[2])
{
case '\0':
case '+':
case 'S':
case 'a':
case 'n':
case 't':
case 'w':
success = describeFunctions(&cmd[2], pattern, show_verbose, show_system);
break;
default:
status = PSQL_CMD_UNKNOWN;
break;
}
break;
case 'g':
/* no longer distinct from \du */
success = describeRoles(pattern, show_verbose);
break;
case 'l':
success = do_lo_list();
break;
case 'n':
success = listSchemas(pattern, show_verbose);
break;
case 'o':
success = describeOperators(pattern, show_system);
break;
case 'p':
success = permissionsList(pattern);
break;
case 'T':
success = describeTypes(pattern, show_verbose, show_system);
break;
case 't':
case 'v':
case 'i':
case 's':
case 'E': /* PostgreSQL use dx for extension, change to dE for foreign table */
/* case 'S': // GPDB: We used to show just system tables for this */
case 'P': /* GPDB: Parent-only tables, no children */
success = listTables(&cmd[1], pattern, show_verbose, show_system);
break;
case 'r':
if (cmd[2] == 'd' && cmd[3] == 's')
{
char *pattern2 = NULL;
if (pattern)
pattern2 = psql_scan_slash_option(scan_state,
OT_NORMAL, NULL, true);
success = listDbRoleSettings(pattern, pattern2);
}
else
//success = PSQL_CMD_UNKNOWN;
/* GPDB uses \dr for foreign tables ? */
success = listTables(&cmd[1], pattern, show_verbose, show_system);
break;
case 'u':
success = describeRoles(pattern, show_verbose);
break;
case 'F': /* text search subsystem */
switch (cmd[2])
{
case '\0':
case '+':
success = listTSConfigs(pattern, show_verbose);
break;
case 'p':
success = listTSParsers(pattern, show_verbose);
break;
case 'd':
success = listTSDictionaries(pattern, show_verbose);
break;
case 't':
success = listTSTemplates(pattern, show_verbose);
break;
default:
status = PSQL_CMD_UNKNOWN;
break;
}
break;
case 'x': /* Extensions */
if (show_verbose)
success = listExtensionContents(pattern);
else
success = listExtensions(pattern);
break;
default:
status = PSQL_CMD_UNKNOWN;
}
if (pattern)
free(pattern);
}
/*
* \e or \edit -- edit the current query buffer, or edit a file and make
* it the query buffer
*/
else if (strcmp(cmd, "e") == 0 || strcmp(cmd, "edit") == 0)
{
if (!query_buf)
{
psql_error("no query buffer\n");
status = PSQL_CMD_ERROR;
}
else
{
char *fname;
fname = psql_scan_slash_option(scan_state,
OT_NORMAL, NULL, true);
expand_tilde(&fname);
if (fname)
canonicalize_path(fname);
if (do_edit(fname, query_buf, NULL))
status = PSQL_CMD_NEWEDIT;
else
status = PSQL_CMD_ERROR;
free(fname);
}
}
/*
* \ef -- edit the named function, or present a blank CREATE FUNCTION
* template if no argument is given
*/
else if (strcmp(cmd, "ef") == 0)
{
if (!query_buf)
{
psql_error("no query buffer\n");
status = PSQL_CMD_ERROR;
}
else
{
char *func;
Oid foid = InvalidOid;
func = psql_scan_slash_option(scan_state,
OT_WHOLE_LINE, NULL, true);
if (!func)
{
/* set up an empty command to fill in */
printfPQExpBuffer(query_buf,
"CREATE FUNCTION ( )\n"
" RETURNS \n"
" LANGUAGE \n"
" -- common options: IMMUTABLE STABLE STRICT SECURITY DEFINER\n"
"AS $function$\n"
"\n$function$\n");
}
else if (!lookup_function_oid(pset.db, func, &foid))
{
/* error already reported */
status = PSQL_CMD_ERROR;
}
else if (!get_create_function_cmd(pset.db, foid, query_buf))
{
/* error already reported */
status = PSQL_CMD_ERROR;
}
if (func)
free(func);
}
if (status != PSQL_CMD_ERROR)
{
bool edited = false;
if (!do_edit(0, query_buf, &edited))
status = PSQL_CMD_ERROR;
else if (!edited)
puts(_("No changes"));
else
status = PSQL_CMD_NEWEDIT;
}
}
/* \echo and \qecho */
else if (strcmp(cmd, "echo") == 0 || strcmp(cmd, "qecho") == 0)
{
char *value;
char quoted;
bool no_newline = false;
bool first = true;
FILE *fout;
if (strcmp(cmd, "qecho") == 0)
fout = pset.queryFout;
else
fout = stdout;
while ((value = psql_scan_slash_option(scan_state,
OT_NORMAL, "ed, false)))
{
if (!quoted && strcmp(value, "-n") == 0)
no_newline = true;
else
{
if (first)
first = false;
else
fputc(' ', fout);
fputs(value, fout);
}
free(value);
}
if (!no_newline)
fputs("\n", fout);
}
/* \encoding -- set/show client side encoding */
else if (strcmp(cmd, "encoding") == 0)
{
char *encoding = psql_scan_slash_option(scan_state,
OT_NORMAL, NULL, false);
if (!encoding)
{
/* show encoding */
puts(pg_encoding_to_char(pset.encoding));
}
else
{
/* set encoding */
if (PQsetClientEncoding(pset.db, encoding) == -1)
psql_error("%s: invalid encoding name or conversion procedure not found\n", encoding);
else
{
/* save encoding info into psql internal data */
pset.encoding = PQclientEncoding(pset.db);
pset.popt.topt.encoding = pset.encoding;
SetVariable(pset.vars, "ENCODING",
pg_encoding_to_char(pset.encoding));
}
free(encoding);
}
}
/* \f -- change field separator */
else if (strcmp(cmd, "f") == 0)
{
char *fname = psql_scan_slash_option(scan_state,
OT_NORMAL, NULL, false);
success = do_pset("fieldsep", fname, &pset.popt, pset.quiet);
free(fname);
}
/* \g means send query */
else if (strcmp(cmd, "g") == 0)
{
char *fname = psql_scan_slash_option(scan_state,
OT_FILEPIPE, NULL, false);
if (!fname)
pset.gfname = NULL;
else
{
expand_tilde(&fname);
pset.gfname = pg_strdup(fname);
}
free(fname);
status = PSQL_CMD_SEND;
}
/* help */
else if (strcmp(cmd, "h") == 0 || strcmp(cmd, "help") == 0)
{
char *opt = psql_scan_slash_option(scan_state,
OT_WHOLE_LINE, NULL, false);
size_t len;
/* strip any trailing spaces and semicolons */
if (opt)
{
len = strlen(opt);
while (len > 0 &&
(isspace((unsigned char) opt[len - 1])
|| opt[len - 1] == ';'))
opt[--len] = '\0';
}
helpSQL(opt, pset.popt.topt.pager);
free(opt);
}
/* HTML mode */
else if (strcmp(cmd, "H") == 0 || strcmp(cmd, "html") == 0)
{
if (pset.popt.topt.format != PRINT_HTML)
success = do_pset("format", "html", &pset.popt, pset.quiet);
else
success = do_pset("format", "aligned", &pset.popt, pset.quiet);
}
/* \i is include file */
else if (strcmp(cmd, "i") == 0 || strcmp(cmd, "include") == 0)
{
char *fname = psql_scan_slash_option(scan_state,
OT_NORMAL, NULL, true);
if (!fname)
{
psql_error("\\%s: missing required argument\n", cmd);
success = false;
}
else
{
expand_tilde(&fname);
success = (process_file(fname, false) == EXIT_SUCCESS);
free(fname);
}
}
/* \l is list databases */
else if (strcmp(cmd, "l") == 0 || strcmp(cmd, "list") == 0)
success = listAllDbs(false);
else if (strcmp(cmd, "l+") == 0 || strcmp(cmd, "list+") == 0)
success = listAllDbs(true);
/*
* large object things
*/
else if (strncmp(cmd, "lo_", 3) == 0)
{
char *opt1,
*opt2;
opt1 = psql_scan_slash_option(scan_state,
OT_NORMAL, NULL, true);
opt2 = psql_scan_slash_option(scan_state,
OT_NORMAL, NULL, true);
if (strcmp(cmd + 3, "export") == 0)
{
if (!opt2)
{
psql_error("\\%s: missing required argument\n", cmd);
success = false;
}
else
{
expand_tilde(&opt2);
success = do_lo_export(opt1, opt2);
}
}
else if (strcmp(cmd + 3, "import") == 0)
{
if (!opt1)
{
psql_error("\\%s: missing required argument\n", cmd);
success = false;
}
else
{
expand_tilde(&opt1);
success = do_lo_import(opt1, opt2);
}
}
else if (strcmp(cmd + 3, "list") == 0)
success = do_lo_list();
else if (strcmp(cmd + 3, "unlink") == 0)
{
if (!opt1)
{
psql_error("\\%s: missing required argument\n", cmd);
success = false;
}
else
success = do_lo_unlink(opt1);
}
else
status = PSQL_CMD_UNKNOWN;
free(opt1);
free(opt2);
}
/* \o -- set query output */
else if (strcmp(cmd, "o") == 0 || strcmp(cmd, "out") == 0)
{
char *fname = psql_scan_slash_option(scan_state,
OT_FILEPIPE, NULL, true);
expand_tilde(&fname);
success = setQFout(fname);
free(fname);
}
/* \p prints the current query buffer */
else if (strcmp(cmd, "p") == 0 || strcmp(cmd, "print") == 0)
{
if (query_buf && query_buf->len > 0)
puts(query_buf->data);
else if (!pset.quiet)
puts(_("Query buffer is empty."));
fflush(stdout);
}
/* \password -- set user password */
else if (strcmp(cmd, "password") == 0)
{
char *pw1;
char *pw2;
pw1 = simple_prompt("Enter new password: "******"Enter it again: ", 100, false);
if (strcmp(pw1, pw2) != 0)
{
fprintf(stderr, _("Passwords didn't match.\n"));
success = false;
}
else
{
char *opt0 = psql_scan_slash_option(scan_state, OT_SQLID, NULL, true);
char *user;
char *encrypted_password;
if (opt0)
user = opt0;
else
user = PQuser(pset.db);
encrypted_password = PQencryptPassword(pw1, user);
if (!encrypted_password)
{
fprintf(stderr, _("Password encryption failed.\n"));
success = false;
}
else
{
PQExpBufferData buf;
PGresult *res;
initPQExpBuffer(&buf);
printfPQExpBuffer(&buf, "ALTER USER %s PASSWORD ",
fmtId(user));
appendStringLiteralConn(&buf, encrypted_password, pset.db);
res = PSQLexec(buf.data, false);
termPQExpBuffer(&buf);
if (!res)
success = false;
else
PQclear(res);
PQfreemem(encrypted_password);
}
}
free(pw1);
free(pw2);
}
/* \prompt -- prompt and set variable */
else if (strcmp(cmd, "prompt") == 0)
{
char *opt,
*prompt_text = NULL;
char *arg1,
*arg2;
arg1 = psql_scan_slash_option(scan_state, OT_NORMAL, NULL, false);
arg2 = psql_scan_slash_option(scan_state, OT_NORMAL, NULL, false);
if (!arg1)
{
psql_error("\\%s: missing required argument\n", cmd);
success = false;
}
else
{
char *result;
if (arg2)
{
prompt_text = arg1;
opt = arg2;
}
else
opt = arg1;
if (!pset.inputfile)
result = simple_prompt(prompt_text, 4096, true);
else
{
if (prompt_text)
{
fputs(prompt_text, stdout);
fflush(stdout);
}
result = gets_fromFile(stdin);
}
if (!SetVariable(pset.vars, opt, result))
{
psql_error("\\%s: error\n", cmd);
success = false;
}
free(result);
if (prompt_text)
free(prompt_text);
free(opt);
}
}
/* \pset -- set printing parameters */
else if (strcmp(cmd, "pset") == 0)
{
char *opt0 = psql_scan_slash_option(scan_state,
OT_NORMAL, NULL, false);
char *opt1 = psql_scan_slash_option(scan_state,
OT_NORMAL, NULL, false);
if (!opt0)
{
psql_error("\\%s: missing required argument\n", cmd);
success = false;
}
else
success = do_pset(opt0, opt1, &pset.popt, pset.quiet);
free(opt0);
free(opt1);
}
/* \q or \quit */
else if (strcmp(cmd, "q") == 0 || strcmp(cmd, "quit") == 0)
status = PSQL_CMD_TERMINATE;
/* reset(clear) the buffer */
else if (strcmp(cmd, "r") == 0 || strcmp(cmd, "reset") == 0)
{
resetPQExpBuffer(query_buf);
psql_scan_reset(scan_state);
if (!pset.quiet)
puts(_("Query buffer reset (cleared)."));
}
/* \s save history in a file or show it on the screen */
else if (strcmp(cmd, "s") == 0)
{
char *fname = psql_scan_slash_option(scan_state,
OT_NORMAL, NULL, true);
#if defined(WIN32) && !defined(__CYGWIN__)
/*
* XXX This does not work for all terminal environments or for output
* containing non-ASCII characters; see comments in simple_prompt().
*/
#define DEVTTY "con"
#else
#define DEVTTY "/dev/tty"
#endif
expand_tilde(&fname);
/* This scrolls off the screen when using /dev/tty */
success = saveHistory(fname ? fname : DEVTTY, -1, false, false);
if (success && !pset.quiet && fname)
printf(gettext("Wrote history to file \"%s/%s\".\n"),
pset.dirname ? pset.dirname : ".", fname);
if (!fname)
putchar('\n');
free(fname);
}
/* \set -- generalized set variable/option command */
else if (strcmp(cmd, "set") == 0)
{
char *opt0 = psql_scan_slash_option(scan_state,
OT_NORMAL, NULL, false);
if (!opt0)
{
/* list all variables */
PrintVariables(pset.vars);
success = true;
}
else
{
/*
* Set variable to the concatenation of the arguments.
*/
char *newval;
char *opt;
opt = psql_scan_slash_option(scan_state,
OT_NORMAL, NULL, false);
newval = pg_strdup(opt ? opt : "");
free(opt);
while ((opt = psql_scan_slash_option(scan_state,
OT_NORMAL, NULL, false)))
{
newval = realloc(newval, strlen(newval) + strlen(opt) + 1);
if (!newval)
{
psql_error("out of memory\n");
exit(EXIT_FAILURE);
}
strcat(newval, opt);
free(opt);
}
if (!SetVariable(pset.vars, opt0, newval))
{
psql_error("\\%s: error\n", cmd);
success = false;
}
free(newval);
}
free(opt0);
}
/* \t -- turn off headers and row count */
else if (strcmp(cmd, "t") == 0)
{
char *opt = psql_scan_slash_option(scan_state,
OT_NORMAL, NULL, true);
success = do_pset("tuples_only", opt, &pset.popt, pset.quiet);
free(opt);
}
/* \T -- define html <table ...> attributes */
else if (strcmp(cmd, "T") == 0)
{
char *value = psql_scan_slash_option(scan_state,
OT_NORMAL, NULL, false);
success = do_pset("tableattr", value, &pset.popt, pset.quiet);
free(value);
}
/* \timing -- toggle timing of queries */
else if (strcmp(cmd, "timing") == 0)
{
char *opt = psql_scan_slash_option(scan_state,
OT_NORMAL, NULL, false);
if (opt)
pset.timing = ParseVariableBool(opt);
else
pset.timing = !pset.timing;
if (!pset.quiet)
{
if (pset.timing)
puts(_("Timing is on."));
else
puts(_("Timing is off."));
}
free(opt);
}
/* \unset */
else if (strcmp(cmd, "unset") == 0)
{
char *opt = psql_scan_slash_option(scan_state,
OT_NORMAL, NULL, false);
if (!opt)
{
psql_error("\\%s: missing required argument\n", cmd);
success = false;
}
else if (!SetVariable(pset.vars, opt, NULL))
{
psql_error("\\%s: error\n", cmd);
success = false;
}
free(opt);
}
/* \w -- write query buffer to file */
else if (strcmp(cmd, "w") == 0 || strcmp(cmd, "write") == 0)
{
FILE *fd = NULL;
bool is_pipe = false;
char *fname = NULL;
if (!query_buf)
{
psql_error("no query buffer\n");
status = PSQL_CMD_ERROR;
}
else
{
fname = psql_scan_slash_option(scan_state,
OT_FILEPIPE, NULL, true);
expand_tilde(&fname);
if (!fname)
{
psql_error("\\%s: missing required argument\n", cmd);
success = false;
}
else
{
if (fname[0] == '|')
{
is_pipe = true;
fd = popen(&fname[1], "w");
}
else
{
canonicalize_path(fname);
fd = fopen(fname, "w");
}
if (!fd)
{
psql_error("%s: %s\n", fname, strerror(errno));
success = false;
}
}
}
if (fd)
{
int result;
if (query_buf && query_buf->len > 0)
fprintf(fd, "%s\n", query_buf->data);
if (is_pipe)
result = pclose(fd);
else
result = fclose(fd);
if (result == EOF)
{
psql_error("%s: %s\n", fname, strerror(errno));
success = false;
}
}
free(fname);
}
/* \x -- toggle expanded table representation */
else if (strcmp(cmd, "x") == 0)
{
char *opt = psql_scan_slash_option(scan_state,
OT_NORMAL, NULL, true);
success = do_pset("expanded", opt, &pset.popt, pset.quiet);
free(opt);
}
/* \z -- list table rights (equivalent to \dp) */
else if (strcmp(cmd, "z") == 0)
{
char *pattern = psql_scan_slash_option(scan_state,
OT_NORMAL, NULL, true);
success = permissionsList(pattern);
if (pattern)
free(pattern);
}
/* \! -- shell escape */
else if (strcmp(cmd, "!") == 0)
{
char *opt = psql_scan_slash_option(scan_state,
OT_WHOLE_LINE, NULL, false);
success = do_shell(opt);
free(opt);
}
/* \? -- slash command help */
else if (strcmp(cmd, "?") == 0)
slashUsage(pset.popt.topt.pager);
#if 0
/*
* These commands don't do anything. I just use them to test the parser.
*/
else if (strcmp(cmd, "void") == 0 || strcmp(cmd, "#") == 0)
{
int i = 0;
char *value;
while ((value = psql_scan_slash_option(scan_state,
OT_NORMAL, NULL, true)))
{
fprintf(stderr, "+ opt(%d) = |%s|\n", i++, value);
free(value);
}
}
#endif
else
status = PSQL_CMD_UNKNOWN;
if (!success)
status = PSQL_CMD_ERROR;
return status;
}
/*
* vacuum_one_database
*
* Process tables in the given database. If the 'tables' list is empty,
* process all tables in the database.
*
* Note that this function is only concerned with running exactly one stage
* when in analyze-in-stages mode; caller must iterate on us if necessary.
*
* If concurrentCons is > 1, multiple connections are used to vacuum tables
* in parallel. In this case and if the table list is empty, we first obtain
* a list of tables from the database.
*/
static void
vacuum_one_database(const char *dbname, vacuumingOptions *vacopts,
int stage,
SimpleStringList *tables,
const char *host, const char *port,
const char *username, enum trivalue prompt_password,
int concurrentCons,
const char *progname, bool echo, bool quiet)
{
PQExpBufferData sql;
PGconn *conn;
SimpleStringListCell *cell;
ParallelSlot *slots;
SimpleStringList dbtables = {NULL, NULL};
int i;
bool failed = false;
bool parallel = concurrentCons > 1;
const char *stage_commands[] = {
"SET default_statistics_target=1; SET vacuum_cost_delay=0;",
"SET default_statistics_target=10; RESET vacuum_cost_delay;",
"RESET default_statistics_target;"
};
const char *stage_messages[] = {
gettext_noop("Generating minimal optimizer statistics (1 target)"),
gettext_noop("Generating medium optimizer statistics (10 targets)"),
gettext_noop("Generating default (full) optimizer statistics")
};
Assert(stage == ANALYZE_NO_STAGE ||
(stage >= 0 && stage < ANALYZE_NUM_STAGES));
conn = connectDatabase(dbname, host, port, username, prompt_password,
progname, echo, false, true);
if (!quiet)
{
if (stage != ANALYZE_NO_STAGE)
printf(_("%s: processing database \"%s\": %s\n"),
progname, PQdb(conn), stage_messages[stage]);
else
printf(_("%s: vacuuming database \"%s\"\n"),
progname, PQdb(conn));
fflush(stdout);
}
initPQExpBuffer(&sql);
/*
* If a table list is not provided and we're using multiple connections,
* prepare the list of tables by querying the catalogs.
*/
if (parallel && (!tables || !tables->head))
{
PQExpBufferData buf;
PGresult *res;
int ntups;
initPQExpBuffer(&buf);
res = executeQuery(conn,
"SELECT c.relname, ns.nspname"
" FROM pg_class c, pg_namespace ns\n"
" WHERE relkind IN ("
CppAsString2(RELKIND_RELATION) ", "
CppAsString2(RELKIND_MATVIEW) ")"
" AND c.relnamespace = ns.oid\n"
" ORDER BY c.relpages DESC;",
progname, echo);
ntups = PQntuples(res);
for (i = 0; i < ntups; i++)
{
appendPQExpBufferStr(&buf,
fmtQualifiedId(PQserverVersion(conn),
PQgetvalue(res, i, 1),
PQgetvalue(res, i, 0)));
simple_string_list_append(&dbtables, buf.data);
resetPQExpBuffer(&buf);
}
termPQExpBuffer(&buf);
tables = &dbtables;
/*
* If there are more connections than vacuumable relations, we don't
* need to use them all.
*/
if (concurrentCons > ntups)
concurrentCons = ntups;
if (concurrentCons <= 1)
parallel = false;
PQclear(res);
}
/*
* Setup the database connections. We reuse the connection we already have
* for the first slot. If not in parallel mode, the first slot in the
* array contains the connection.
*/
if (concurrentCons <= 0)
concurrentCons = 1;
slots = (ParallelSlot *) pg_malloc(sizeof(ParallelSlot) * concurrentCons);
init_slot(slots, conn);
if (parallel)
{
for (i = 1; i < concurrentCons; i++)
{
conn = connectDatabase(dbname, host, port, username, prompt_password,
progname, echo, false, true);
init_slot(slots + i, conn);
}
}
/*
* Prepare all the connections to run the appropriate analyze stage, if
* caller requested that mode.
*/
if (stage != ANALYZE_NO_STAGE)
{
int j;
/* We already emitted the message above */
for (j = 0; j < concurrentCons; j++)
executeCommand((slots + j)->connection,
stage_commands[stage], progname, echo);
}
cell = tables ? tables->head : NULL;
do
{
const char *tabname = cell ? cell->val : NULL;
ParallelSlot *free_slot;
if (CancelRequested)
{
failed = true;
goto finish;
}
/*
* Get the connection slot to use. If in parallel mode, here we wait
* for one connection to become available if none already is. In
* non-parallel mode we simply use the only slot we have, which we
* know to be free.
*/
if (parallel)
{
/*
* Get a free slot, waiting until one becomes free if none
* currently is.
*/
free_slot = GetIdleSlot(slots, concurrentCons, progname);
if (!free_slot)
{
failed = true;
goto finish;
}
free_slot->isFree = false;
}
else
free_slot = slots;
/*
* Prepare the vacuum command. Note that in some cases this requires
* query execution, so be sure to use the free connection.
*/
prepare_vacuum_command(&sql, free_slot->connection, vacopts, tabname,
tables == &dbtables, progname, echo);
/*
* Execute the vacuum. If not in parallel mode, this terminates the
* program in case of an error. (The parallel case handles query
* errors in ProcessQueryResult through GetIdleSlot.)
*/
run_vacuum_command(free_slot->connection, sql.data,
echo, tabname, progname, parallel);
if (cell)
cell = cell->next;
} while (cell != NULL);
if (parallel)
{
int j;
/* wait for all connections to finish */
for (j = 0; j < concurrentCons; j++)
{
if (!GetQueryResult((slots + j)->connection, progname))
goto finish;
}
}
finish:
for (i = 0; i < concurrentCons; i++)
DisconnectDatabase(slots + i);
pfree(slots);
termPQExpBuffer(&sql);
if (failed)
exit(1);
}