int
main(int argc, char *argv[])
{
int i;
i = pgut_getopt(argc, argv, options);
if (i == argc - 1)
dbname = argv[i];
else if (i < argc)
ereport(ERROR,
(errcode(EINVAL),
errmsg("too many arguments")));
if (noorder)
orderby = "";
if (alldb)
{
if (table)
ereport(ERROR,
(errcode(EINVAL),
errmsg("cannot reorg a specific table in all databases")));
reorg_all_databases(orderby);
}
else
{
if (!reorg_one_database(orderby, table))
ereport(ERROR,
(errcode(ENOENT),
errmsg("%s is not installed", PROGRAM_NAME)));
}
return 0;
}
int
main(int argc, char *argv[])
{
PGconn *conn;
StringInfoData conn_info;
int num_options;
num_options = pgut_getopt(argc, argv, options);
/* command-line arguments is not necessary */
if (num_options != argc)
ereport(ERROR,
(errcode(EINVAL),
errmsg("too many argumetns")));
/* can't specified the mode two or more */
if ((mode_list && (mode_size || mode_report || mode_snapshot || mode_delete)) ||
(mode_size && (mode_report || mode_snapshot || mode_delete)) ||
(mode_report && (mode_snapshot || mode_delete)) ||
(mode_snapshot && mode_delete))
ereport(ERROR,
(errcode(EINVAL),
errmsg("can't specify two or more mode")));
/* connect to database */
initStringInfo(&conn_info);
if (dbname && dbname[0])
appendStringInfo(&conn_info, "dbname=%s ", dbname);
if (host && host[0])
appendStringInfo(&conn_info, "host=%s ", host);
if (port && port[0])
appendStringInfo(&conn_info, "port=%s ", port);
if (username && username[0])
appendStringInfo(&conn_info, "user=%s ", username);
conn = pgut_connect(conn_info.data, prompt_password, ERROR);
termStringInfo(&conn_info);
/* execute a specified operation */
if (mode_list)
do_list(conn, instid);
else if (mode_size)
do_size(conn);
else if (mode_report)
do_report(conn, mode_report,
instid, beginid, endid, begindate, enddate, output);
else if (mode_snapshot)
do_snapshot(conn, mode_snapshot);
else if (mode_delete)
do_delete(conn, mode_delete);
else
ereport(ERROR,
(errcode(EINVAL),
errmsg("please specify operation option (-l, -s, -r, -S, -D)")));
pgut_disconnect(conn);
return 0;
}
/**
* @brief Entry point for pg_bulkload command.
*
* Flow:
* <ol>
* <li> Parses command arguments. </li>
* <li> Without -r option: Starts the loading. </li>
* <li> With -r option: Starts the recovery. </li>
* </ol>
*
* @param argc [in] Number of arguments.
* @param argv [in] Argument list.
* @return Returns zero if successful, 1 otherwise.
*/
int
main(int argc, char *argv[])
{
char cwd[MAXPGPATH];
char control_file[MAXPGPATH] = "";
int i;
pgut_init(argc, argv);
if (argc < 2)
{
help(false);
return E_PG_OTHER;
}
if (getcwd(cwd, MAXPGPATH) == NULL)
ereport(ERROR,
(errcode(EXIT_FAILURE),
errmsg("cannot read current directory: ")));
i = pgut_getopt(argc, argv, options);
for (; i < argc; i++)
{
if (control_file[0])
ereport(ERROR,
(errcode(EXIT_FAILURE),
errmsg("too many arguments")));
/* make absolute control file path */
if (is_absolute_path(argv[i]))
strlcpy(control_file, argv[i], MAXPGPATH);
else
join_path_components(control_file, cwd, argv[i]);
canonicalize_path(control_file);
}
/*
* Determines data loading or recovery.
*/
if (recovery)
{
/* verify arguments */
if (!DataDir && (DataDir = getenv("PGDATA")) == NULL)
elog(ERROR, "no $PGDATA specified");
if (strlen(DataDir) + MAX_LOADSTATUS_NAME >= MAXPGPATH)
elog(ERROR, "too long $PGDATA path length");
if (control_file[0] != '\0')
elog(ERROR, "invalid argument 'control file' for recovery");
return LoaderRecoveryMain();
}
else
{
/* verify arguments */
if (DataDir)
elog(ERROR, "invalid option '-D' for data load");
if (control_file[0])
bulkload_options = list_concat(
ParseControlFile(control_file), bulkload_options);
/* chdir control_file to the parent directory */
get_parent_directory(control_file);
/* add path options */
for (i = 0; i < NUM_PATH_OPTIONS; i++)
{
const pgut_option *opt = &options[i];
const char *path = *(const char **) opt->var;
char abspath[MAXPGPATH];
char item[MAXPGPATH + 32];
if (path == NULL)
continue;
if ((i == 0 || i == 1) &&
(pg_strcasecmp(path, "stdin") == 0 || type_function))
{
/* special case for stdin and input from function */
strlcpy(abspath, path, lengthof(abspath));
}
else if (is_absolute_path(path) || (i == 2 && !writer_binary))
{
/* absolute path */
strlcpy(abspath, path, lengthof(abspath));
}
else if (opt->source == SOURCE_FILE)
{
/* control file relative path */
join_path_components(abspath, control_file, path);
}
else
{
/* current working directory relative path */
join_path_components(abspath, cwd, path);
}
canonicalize_path(abspath);
snprintf(item, lengthof(item), "%s=%s", opt->lname, abspath);
bulkload_options = lappend(bulkload_options, pgut_strdup(item));
}
return LoaderLoadMain(bulkload_options);
}
}
/*
* Entry point of pg_arman command.
*/
int
main(int argc, char *argv[])
{
const char *cmd = NULL;
const char *range1 = NULL;
const char *range2 = NULL;
pgBackupRange range;
int i;
/* do not buffer progress messages */
setvbuf(stdout, 0, _IONBF, 0); /* TODO: remove this */
/* initialize configuration */
catalog_init_config(¤t);
/* overwrite configuration with command line arguments */
i = pgut_getopt(argc, argv, options);
for (; i < argc; i++)
{
if (cmd == NULL)
cmd = argv[i];
else if (range1 == NULL)
range1 = argv[i];
else if (range2 == NULL)
range2 = argv[i];
else
elog(ERROR, "too many arguments");
}
/* command argument (backup/restore/show/...) is required. */
if (cmd == NULL)
{
help(false);
return 1;
}
/* get object range argument if any */
if (range1 && range2)
parse_range(&range, range1, range2);
else if (range1)
parse_range(&range, range1, "");
else
range.begin = range.end = 0;
/* Read default configuration from file. */
if (backup_path)
{
char path[MAXPGPATH];
/* Check if backup_path is directory. */
struct stat stat_buf;
int rc = stat(backup_path, &stat_buf);
/* If rc == -1, there is no file or directory. So it's OK. */
if (rc != -1 && !S_ISDIR(stat_buf.st_mode))
elog(ERROR, "-B, --backup-path must be a path to directory");
join_path_components(path, backup_path, PG_RMAN_INI_FILE);
pgut_readopt(path, options, ERROR);
}
/* BACKUP_PATH is always required */
if (backup_path == NULL)
elog(ERROR, "required parameter not specified: BACKUP_PATH (-B, --backup-path)");
/* path must be absolute */
if (backup_path != NULL && !is_absolute_path(backup_path))
elog(ERROR, "-B, --backup-path must be an absolute path");
if (pgdata != NULL && !is_absolute_path(pgdata))
elog(ERROR, "-D, --pgdata must be an absolute path");
if (arclog_path != NULL && !is_absolute_path(arclog_path))
elog(ERROR, "-A, --arclog-path must be an absolute path");
/* Sanity checks with commands */
if (pg_strcasecmp(cmd, "delete") == 0 && arclog_path == NULL)
elog(ERROR, "delete command needs ARCLOG_PATH (-A, --arclog-path) to be set");
/* setup exclusion list for file search */
for (i = 0; pgdata_exclude[i]; i++) /* find first empty slot */
;
if (arclog_path)
pgdata_exclude[i++] = arclog_path;
/* do actual operation */
if (pg_strcasecmp(cmd, "init") == 0)
return do_init();
else if (pg_strcasecmp(cmd, "backup") == 0)
{
pgBackupOption bkupopt;
int res;
bkupopt.smooth_checkpoint = smooth_checkpoint;
bkupopt.keep_data_generations = keep_data_generations;
bkupopt.keep_data_days = keep_data_days;
/* Do the backup */
res = do_backup(bkupopt);
if (res != 0)
return res;
/* If validation has been requested, do it */
range.begin = current.start_time;
range.end = current.start_time + 1;
if (backup_validate)
do_validate(&range);
}
else if (pg_strcasecmp(cmd, "restore") == 0)
return do_restore(target_time, target_xid,
target_inclusive, target_tli);
else if (pg_strcasecmp(cmd, "show") == 0)
return do_show(&range, show_all);
else if (pg_strcasecmp(cmd, "validate") == 0)
return do_validate(&range);
else if (pg_strcasecmp(cmd, "delete") == 0)
return do_delete(&range);
else
elog(ERROR, "invalid command \"%s\"", cmd);
return 0;
}
