memset(pad, '-', l);
pad[l] = '\0';
fprintf(stdout, "%s\n", pad);
- free(pad);
+ pg_free(pad);
}
/* for each row, dump the information */
/* cleanup */
PQclear(res);
- free(length);
+ pg_free(length);
return 0;
}
opts->extended ? addfields : "",
qualifiers);
- free(qualifiers);
+ pg_free(qualifiers);
sql_exec(conn, todo, opts->quiet);
}
{
if (pg_strcasecmp(tsearch_config_languages[i].langname, langname) == 0)
{
- free(langname);
+ pg_free(langname);
return tsearch_config_languages[i].tsconfname;
}
}
- free(langname);
+ pg_free(langname);
return NULL;
}
if (fprintf(version_file, "%s\n", PG_MAJORVERSION) < 0 ||
fclose(version_file))
pg_fatal("could not write file \"%s\": %m", path);
- free(path);
+ pfree(path);
}
/*
pg_fatal("could not open file \"%s\" for writing: %m", path);
if (fclose(conf_file))
pg_fatal("could not write file \"%s\": %m", path);
- free(path);
+ pfree(path);
}
/*
subdirloc);
}
- free(subdirloc);
+ pfree(subdirloc);
}
if (mkdir(path, pg_dir_create_mode) < 0)
pg_fatal("could not create directory \"%s\": %m", path);
- free(path);
+ pfree(path);
}
check_ok();
*equals++ = '\0'; /* terminate variable name */
add_stringlist_item(&extra_guc_names, buf);
add_stringlist_item(&extra_guc_values, equals);
- pfree(buf);
+ pg_free(buf);
}
break;
case 'D':
/* We needn't maintain this variable if not doing verbose reports. */
if (showprogress && verbose)
{
- free(progress_filename);
+ pg_free(progress_filename);
if (filename)
progress_filename = pg_strdup(filename);
else
if (symlink(xlog_dir, linkloc) != 0)
pg_fatal("could not create symbolic link \"%s\": %m", linkloc);
- free(linkloc);
+ pfree(linkloc);
}
BaseBackup(compression_algorithm, compression_detail, compressloc,
cmd_str = psprintf("\"%s\" -D \"%s\" >> \"%s\"", pg_resetwal_path,
subscriber_dir, out_file);
if (opt->log_dir)
- pg_free(out_file);
+ pfree(out_file);
pg_log_debug("pg_resetwal command is: %s", cmd_str);
pg_fatal("could not reset WAL on subscriber: %s", wait_result_to_str(rc));
}
- pg_free(cf);
- pg_free(cmd_str);
+ pfree(cf);
+ pfree(cmd_str);
}
/*
PQfreemem(subname);
PQfreemem(dbname);
- pg_free(originname);
- pg_free(lsnstr);
+ pfree(originname);
+ pfree(lsnstr);
destroyPQExpBuffer(str);
}
if (!internal_log_file_fp)
pg_fatal("could not open log file \"%s\": %m", internal_log_file);
- pg_free(internal_log_file);
+ pfree(internal_log_file);
pg_logging_set_logfile(internal_log_file_fp);
}
{
pg_log_error("%s", PQerrorMessage(tmpconn));
PQfinish(tmpconn);
- free(values);
- free(keywords);
+ pg_free(values);
+ pg_free(keywords);
PQconninfoFree(conn_opts);
return NULL;
}
/* Connection ok! */
- free(values);
- free(keywords);
+ pg_free(values);
+ pg_free(keywords);
PQconninfoFree(conn_opts);
/*
}
/* All done. */
- pfree(buffer);
+ pg_free(buffer);
return result;
}
/* Avoid leaking memory. */
if (checksum_payload != NULL)
- pfree(checksum_payload);
+ pg_free(checksum_payload);
}
closedir(dir);
pg_free(s->filename);
pg_free(s);
}
- pfree(sourcemap);
- pfree(offsetmap);
- pfree(source);
+ pg_free(sourcemap);
+ pg_free(offsetmap);
+ pg_free(source);
}
/*
{
if (missing_ok && errno == ENOENT)
{
- pg_free(rf->filename);
+ pfree(rf->filename);
pg_free(rf);
return NULL;
}
if (len != statbuf.st_size)
{
/* oops, the file size changed between fstat and read */
- free(buffer);
+ pg_free(buffer);
return NULL;
}
}
result[n] = NULL;
- free(buffer);
+ pg_free(buffer);
return result;
}
write_stderr(_("%s: could not determine the data directory using command \"%s\"\n"), progname, cmd);
exit(1);
}
- free(my_exec_path);
+ pg_free(my_exec_path);
/* strip trailing newline and carriage return */
(void) pg_strip_crlf(filename);
- free(pg_data);
+ pg_free(pg_data);
pg_data = pg_strdup(filename);
canonicalize_path(pg_data);
}
* but we do -D too for clearer postmaster 'ps' display
*/
pgdata_opt = psprintf("-D \"%s\" ", pgdata_D);
- free(pgdata_D);
+ pg_free(pgdata_D);
break;
}
case 'e':
if (inflateEnd(zp) != Z_OK)
pg_fatal("could not close compression library: %s", zp->msg);
- free(buf);
- free(out);
- free(zp);
+ pg_free(buf);
+ pg_free(out);
+ pg_free(zp);
}
/* Public routines that support gzip compressed data I/O */
ret = CFH->open_func(fname, -1, mode, CFH);
save_errno = errno;
- pg_free(fname);
+ pfree(fname);
errno = save_errno;
return ret;
ret = CFH->open_func(fname, -1, mode, CFH);
save_errno = errno;
- pg_free(fname);
+ pfree(fname);
errno = save_errno;
return ret;
ahwrite(buf, 1, cnt, AH);
}
- free(buf);
+ pg_free(buf);
}
char *err_msg = NULL;
int i = 0;
- free(keywords);
- free(values);
+ pg_free(keywords);
+ pg_free(values);
PQconninfoFree(conn_opts);
/*
{
PQfinish(conn);
- free(keywords);
- free(values);
+ pg_free(keywords);
+ pg_free(values);
PQconninfoFree(conn_opts);
return NULL;
if (connstr)
*connstr = constructConnStr(keywords, values);
- free(keywords);
- free(values);
+ pg_free(keywords);
+ pg_free(values);
PQconninfoFree(conn_opts);
/* Check version */
free(aclitems);
free(baseitems);
- free(grantitems);
- free(revokeitems);
+ pg_free(grantitems);
+ pg_free(revokeitems);
return ok;
}
ret = WaitForMultipleObjects(nrun, lpHandles, false, INFINITE);
Assert(ret != WAIT_FAILED);
hThread = (uintptr_t) lpHandles[ret - WAIT_OBJECT_0];
- free(lpHandles);
+ pg_free(lpHandles);
/* Find dead worker's slot, and clear the hThread field */
for (j = 0; j < pstate->numWorkers; j++)
break; /* success */
/* Release buffer and loop around to try again with larger len. */
- free(p);
+ pg_free(p);
len = cnt;
}
WriteData(AH, p, cnt);
- free(p);
+ pg_free(p);
return (int) cnt;
}
break; /* success */
/* Release buffer and loop around to try again with larger len. */
- free(p);
+ pg_free(p);
len = cnt;
}
ahwrite(p, 1, cnt, AH);
- free(p);
+ pg_free(p);
return (int) cnt;
}
pg_log_debug("attempting to ascertain archive format");
- free(AH->lookahead);
+ pg_free(AH->lookahead);
AH->readHeader = 0;
AH->lookaheadSize = 512;
}
else
{
- free(deps);
+ pg_free(deps);
te->dependencies = NULL;
te->nDeps = 0;
}
pg_fatal("invalid ENCODING item: %s",
te->defn);
- free(defn);
+ pg_free(defn);
}
static void
* NOTE: currUser keeps track of what the imaginary session user in our
* script is
*/
- free(AH->currUser);
+ pg_free(AH->currUser);
AH->currUser = pg_strdup(user);
}
else
ahprintf(AH, "%s;\n\n", qry->data);
- free(AH->currSchema);
+ pg_free(AH->currSchema);
AH->currSchema = pg_strdup(schemaName);
destroyPQExpBuffer(qry);
else
ahprintf(AH, "%s;\n\n", qry->data);
- free(AH->currTablespace);
+ pg_free(AH->currTablespace);
AH->currTablespace = pg_strdup(want);
destroyPQExpBuffer(qry);
destroyPQExpBuffer(cmd);
- free(AH->currTableAm);
+ pg_free(AH->currTableAm);
AH->currTableAm = pg_strdup(want);
}
appendPQExpBufferStr(buf, first);
- free(first);
+ pg_free(first);
return;
}
/* these object types don't have separate owners */
char *cmdEnd = psprintf(" OWNER TO %s", fmtId(te->owner));
IssueCommandPerBlob(AH, te, "ALTER LARGE OBJECT ", cmdEnd);
- pg_free(cmdEnd);
+ pfree(cmdEnd);
}
else
{
if (nlockids == 0)
{
- free(lockids);
+ pg_free(lockids);
return;
}
{
if (blkLen > buflen)
{
- free(buf);
+ pg_free(buf);
buflen = Max(blkLen, 4 * 1024);
buf = (char *) pg_malloc(buflen);
}
blkLen = ReadInt(AH);
}
- free(buf);
+ pg_free(buf);
}
/*
*/
if (PQconnectionUsedPassword(AH->connection))
{
- free(AH->savedPassword);
+ pg_free(AH->savedPassword);
AH->savedPassword = pg_strdup(PQpass(AH->connection));
}
memcpy(str, buf, bufLen);
str[bufLen] = '\0';
ExecuteSqlCommand(AH, str, "could not execute query");
- free(str);
+ pg_free(str);
}
}
ahwrite(buf, 1, cnt, AH);
}
- free(buf);
+ pg_free(buf);
if (!EndCompressFileHandle(CFH))
pg_fatal("could not close data file \"%s\": %m", filename);
}
break; /* success */
/* Release buffer and loop around to try again with larger len. */
- free(p);
+ pg_free(p);
len = cnt;
}
cnt = tarWrite(p, cnt, th);
- free(p);
+ pg_free(p);
return (int) cnt;
}
* We're just scanning the archive for the next file, so return
* null
*/
- free(th);
+ pg_free(th);
return NULL;
}
}
destroyPQExpBuffer(q);
if (insertStmt != NULL)
destroyPQExpBuffer(insertStmt);
- free(attgenerated);
+ pg_free(attgenerated);
/* Revert back the setting */
if (tbinfo->relkind == RELKIND_FOREIGN_TABLE)
PQclear(res);
- free(qdatname);
+ pg_free(qdatname);
destroyPQExpBuffer(dbQry);
destroyPQExpBuffer(delQry);
destroyPQExpBuffer(creaQry);
tbinfo->dobj.namespace->dobj.name, tbinfo->rolname,
polinfo->dobj.catId, 0, polinfo->dobj.dumpId);
- free(tag);
+ pfree(tag);
destroyPQExpBuffer(query);
destroyPQExpBuffer(delqry);
destroyPQExpBuffer(polprefix);
- free(qtabname);
+ pg_free(qtabname);
}
/*
destroyPQExpBuffer(delq);
destroyPQExpBuffer(query);
- free(qpubname);
+ pg_free(qpubname);
}
/*
/* These objects can't currently have comments or seclabels */
- free(tag);
+ pfree(tag);
destroyPQExpBuffer(query);
}
/* These objects can't currently have comments or seclabels */
- free(tag);
+ pfree(tag);
destroyPQExpBuffer(query);
}
/* These objects can't currently have comments or seclabels */
- free(tag);
+ pfree(tag);
destroyPQExpBuffer(query);
}
destroyPQExpBuffer(delq);
destroyPQExpBuffer(query);
- free(qsubname);
+ pg_free(qsubname);
}
/*
tbinfo->notnull_constrs[j] =
pstrdup(PQgetvalue(res, r, i_notnull_name));
}
- free(default_name);
+ pfree(default_name);
}
}
}
qnspname, NULL, NULL,
NULL, nspinfo->rolname, &nspinfo->dacl);
- free(qnspname);
+ pg_free(qnspname);
destroyPQExpBuffer(q);
destroyPQExpBuffer(delq);
NULL, "",
extinfo->dobj.catId, 0, extinfo->dobj.dumpId);
- free(qextname);
+ pg_free(qextname);
destroyPQExpBuffer(q);
destroyPQExpBuffer(delq);
destroyPQExpBuffer(q);
destroyPQExpBuffer(delq);
destroyPQExpBuffer(query);
- free(qtypname);
- free(qualtypname);
+ pg_free(qtypname);
+ pg_free(qualtypname);
}
/*
destroyPQExpBuffer(q);
destroyPQExpBuffer(delq);
destroyPQExpBuffer(query);
- free(qtypname);
- free(qualtypname);
+ pg_free(qtypname);
+ pg_free(qualtypname);
}
/*
destroyPQExpBuffer(q);
destroyPQExpBuffer(delq);
- free(qtypname);
- free(qualtypname);
+ pg_free(qtypname);
+ pg_free(qualtypname);
}
/*
destroyPQExpBuffer(q);
destroyPQExpBuffer(delq);
destroyPQExpBuffer(query);
- free(qtypname);
- free(qualtypname);
+ pg_free(qtypname);
+ pg_free(qualtypname);
}
/*
else
appendPQExpBuffer(q, " CONSTRAINT %s %s",
fmtId(notnull->dobj.name), notnull->condef);
- free(default_name);
+ pfree(default_name);
}
}
}
destroyPQExpBuffer(q);
destroyPQExpBuffer(delq);
destroyPQExpBuffer(query);
- free(qtypname);
- free(qualtypname);
+ pg_free(qtypname);
+ pg_free(qualtypname);
}
/*
destroyPQExpBuffer(dropped);
destroyPQExpBuffer(delq);
destroyPQExpBuffer(query);
- free(qtypname);
- free(qualtypname);
+ pg_free(qtypname);
+ pg_free(qualtypname);
}
/*
qlanname, NULL, NULL,
NULL, plang->lanowner, &plang->dacl);
- free(qlanname);
+ pg_free(qlanname);
destroyPQExpBuffer(defqry);
destroyPQExpBuffer(delqry);
getFormattedTypeName(fout, typeids[i], zeroAsNone));
}
- free(typeids);
+ pg_free(typeids);
}
if (prokind[0] == PROKIND_WINDOW)
free(funcsig);
free(funcfullsig);
free(funcsig_tag);
- free(qual_funcsig);
+ pfree(qual_funcsig);
free(configitems);
}
aminfo->amtype, qamname);
destroyPQExpBuffer(q);
destroyPQExpBuffer(delq);
- free(qamname);
+ pg_free(qamname);
return;
}
destroyPQExpBuffer(q);
destroyPQExpBuffer(delq);
- free(qamname);
+ pg_free(qamname);
}
/*
opcinfo->dobj.namespace->dobj.name, opcinfo->rolname,
opcinfo->dobj.catId, 0, opcinfo->dobj.dumpId);
- free(opcintype);
- free(opcfamily);
- free(amname);
+ pg_free(opcintype);
+ pg_free(opcfamily);
+ pg_free(amname);
destroyPQExpBuffer(query);
destroyPQExpBuffer(q);
destroyPQExpBuffer(delq);
opfinfo->dobj.namespace->dobj.name, opfinfo->rolname,
opfinfo->dobj.catId, 0, opfinfo->dobj.dumpId);
- free(amname);
+ pg_free(amname);
PQclear(res_ops);
PQclear(res_procs);
destroyPQExpBuffer(query);
destroyPQExpBuffer(query);
destroyPQExpBuffer(q);
destroyPQExpBuffer(delq);
- free(qcollname);
+ pg_free(qcollname);
}
/*
destroyPQExpBuffer(query);
destroyPQExpBuffer(q);
destroyPQExpBuffer(delq);
- free(qconvname);
+ pg_free(qconvname);
}
/*
destroyPQExpBuffer(q);
destroyPQExpBuffer(delq);
- free(qprsname);
+ pg_free(qprsname);
}
/*
destroyPQExpBuffer(q);
destroyPQExpBuffer(delq);
destroyPQExpBuffer(query);
- free(qdictname);
+ pg_free(qdictname);
}
/*
destroyPQExpBuffer(q);
destroyPQExpBuffer(delq);
- free(qtmplname);
+ pg_free(qtmplname);
}
/*
destroyPQExpBuffer(q);
destroyPQExpBuffer(delq);
destroyPQExpBuffer(query);
- free(qcfgname);
+ pg_free(qcfgname);
}
/*
"FOREIGN DATA WRAPPER", qfdwname, NULL, NULL,
NULL, fdwinfo->rolname, &fdwinfo->dacl);
- free(qfdwname);
+ pg_free(qfdwname);
destroyPQExpBuffer(q);
destroyPQExpBuffer(delq);
PQclear(res);
- free(qsrvname);
+ pg_free(qsrvname);
destroyPQExpBuffer(q);
destroyPQExpBuffer(delq);
"TABLE", namecopy, attnamecopy,
tbinfo->dobj.namespace->dobj.name,
NULL, tbinfo->rolname, &coldacl);
- free(attnamecopy);
+ pg_free(attnamecopy);
}
PQclear(res);
destroyPQExpBuffer(query);
}
- free(namecopy);
+ pg_free(namecopy);
}
/*
tbinfo->attfdwoptions[j]);
} /* end loop over columns */
- free(partkeydef);
- free(ftoptions);
- free(srvname);
+ pg_free(partkeydef);
+ pg_free(ftoptions);
+ pg_free(srvname);
}
/*
destroyPQExpBuffer(q);
destroyPQExpBuffer(delq);
destroyPQExpBuffer(extra);
- free(qrelname);
- free(qualrelname);
+ pg_free(qrelname);
+ pg_free(qualrelname);
}
/*
.createStmt = q->data,
.dropStmt = delq->data));
- free(tag);
+ pfree(tag);
destroyPQExpBuffer(q);
destroyPQExpBuffer(delq);
- free(qualrelname);
+ pg_free(qualrelname);
}
/*
destroyPQExpBuffer(q);
destroyPQExpBuffer(delq);
- free(qindxname);
- free(qqindxname);
+ pg_free(qindxname);
+ pg_free(qqindxname);
}
/*
destroyPQExpBuffer(q);
destroyPQExpBuffer(delq);
destroyPQExpBuffer(query);
- free(qstatsextname);
+ pg_free(qstatsextname);
}
/*
tyinfo->rolname,
coninfo->dobj.catId, 0, coninfo->dobj.dumpId);
destroyPQExpBuffer(conprefix);
- free(qtypname);
+ pg_free(qtypname);
}
}
}
coninfo->dobj.dump & DUMP_COMPONENT_COMMENT)
dumpTableConstraintComment(fout, coninfo);
- free(tag);
+ pfree(tag);
destroyPQExpBuffer(q);
destroyPQExpBuffer(delq);
}
coninfo->separate ? coninfo->dobj.dumpId : tbinfo->dobj.dumpId);
destroyPQExpBuffer(conprefix);
- free(qtabname);
+ pg_free(qtabname);
}
static inline SeqType
pg_free(seq);
destroyPQExpBuffer(query);
destroyPQExpBuffer(delqry);
- free(qseqname);
+ pg_free(qseqname);
}
/*
tbinfo->dobj.namespace->dobj.name, tbinfo->rolname,
tginfo->dobj.catId, 0, tginfo->dobj.dumpId);
- free(tag);
+ pfree(tag);
destroyPQExpBuffer(query);
destroyPQExpBuffer(delqry);
destroyPQExpBuffer(trigprefix);
destroyPQExpBuffer(trigidentity);
- free(qtabname);
+ pg_free(qtabname);
}
/*
destroyPQExpBuffer(query);
destroyPQExpBuffer(delqry);
- free(qevtname);
+ pg_free(qevtname);
}
/*
tbinfo->rolname,
rinfo->dobj.catId, 0, rinfo->dobj.dumpId);
- free(tag);
+ pfree(tag);
destroyPQExpBuffer(query);
destroyPQExpBuffer(cmd);
destroyPQExpBuffer(delcmd);
destroyPQExpBuffer(ruleprefix);
- free(qtabname);
+ pg_free(qtabname);
}
/*
te->nDeps = nDeps;
}
else
- free(dependencies);
+ pg_free(dependencies);
}
}
memcpy(objs, ordering, numObjs * sizeof(DumpableObject *));
- free(ordering);
+ pg_free(ordering);
}
/*
/* Done */
binaryheap_free(pendingHeap);
- free(beforeConstraints);
- free(idMap);
+ pg_free(beforeConstraints);
+ pg_free(idMap);
return (i == 0);
}
if (!fixedloop)
pg_fatal("could not identify dependency loop");
- free(workspace);
- free(searchFailed);
- free(processed);
+ pg_free(workspace);
+ pg_free(searchFailed);
+ pg_free(processed);
}
/*
fprintf(OPF, "%s", buf->data);
- free(fparname);
+ pg_free(fparname);
destroyPQExpBuffer(buf);
}
fprintf(OPF, "%s", buf->data);
- free(fspcname);
+ pg_free(fspcname);
destroyPQExpBuffer(buf);
}
/* Unlink file in case it is left over from a previous run. */
unlink(*deletion_script_file_name);
- pg_free(*deletion_script_file_name);
+ pfree(*deletion_script_file_name);
*deletion_script_file_name = NULL;
return;
}
/* Unlink file in case it is left over from a previous run. */
unlink(*deletion_script_file_name);
- pg_free(*deletion_script_file_name);
+ pfree(*deletion_script_file_name);
*deletion_script_file_name = NULL;
return;
}
fprintf(script, RMDIR_CMD " %c%s%s%c\n", PATH_QUOTE,
fix_path_separator(old_cluster.tablespaces[tblnum]),
old_tblspc_suffix, PATH_QUOTE);
- pfree(old_tblspc_suffix);
+ pg_free(old_tblspc_suffix);
fclose(script);
check_ok();
termPQExpBuffer(&old_polymorphics);
- pg_free(query);
+ pfree(query);
}
/*
}
pg_free(state.ress);
- pg_free(query);
+ pfree(query);
os_info.num_libraries = totaltups;
}
}
/* Done with the buffer. */
- pfree(buffer);
+ pg_free(buffer);
return result;
}
}
}
- pfree(buffer);
+ pg_free(buffer);
progress_report(true);
}
pg_log_debug("client %d sending %s", st->id, sql);
r = PQsendQuery(st->con, sql);
- free(sql);
+ pg_free(sql);
}
else if (querymode == QUERY_EXTENDED)
{
}
if (*varprefix != '\0')
- pg_free(varname);
+ pfree(varname);
}
}
/* otherwise the result is simply thrown away by PQclear below */
PQclear(res);
}
- free(user);
+ pg_free(user);
free(pw1);
free(pw2);
termPQExpBuffer(&buf);
if (!SetVariable(pset.vars, opt0, newval))
success = false;
- free(newval);
+ pg_free(newval);
}
free(opt0);
}
prompt_text = psprintf(_("Password for user %s: "), username);
result = simple_prompt_extended(prompt_text, false, &prompt_ctx);
- free(prompt_text);
+ pfree(prompt_text);
}
if (canceled)
pg_log_error("could not start editor \"%s\"", editorName);
else if (result == 127)
pg_log_error("could not start /bin/sh");
- free(sys);
+ pfree(sys);
return result == 0;
}
sys = psprintf("\"%s\"", shellName);
#endif
result = system(sys);
- free(sys);
+ pfree(sys);
}
else
result = system(command);
if (!SetVariable(pset.vars, varname, value))
{
- free(varname);
+ pfree(varname);
success = false;
break;
}
- free(varname);
+ pfree(varname);
}
}
printQuery(res, &myopt, pset.queryFout, false, pset.logfile);
- free(footers[0]);
- free(footers[1]);
+ pg_free(footers[0]);
+ pg_free(footers[1]);
retval = true;
goto error_return; /* not an error, just return early */
printQuery(res, &popt, pset.queryFout, false, pset.logfile);
- free(footers[0]);
- free(footers[1]);
+ pg_free(footers[0]);
+ pg_free(footers[1]);
retval = true;
goto error_return; /* not an error, just return early */
termPQExpBuffer(&title);
termPQExpBuffer(&tmpbuf);
- free(view_def);
+ pg_free(view_def);
PQclear(res);
printTableCleanup(&cont);
for (i = 0; i < nrows; i++)
- free(attr[i]);
- free(attr);
+ pg_free(attr[i]);
+ pg_free(attr);
PQclear(res);
return true;
_(QL_HELP[i].help),
buffer.data,
url);
- free(url);
+ pfree(url);
termPQExpBuffer(&buffer);
/* If we have an exact match, exit. Fixes \h SELECT */
else
{
/* Save each previous line for ignoredups processing */
- free(prev_hist);
+ pg_free(prev_hist);
prev_hist = pg_strdup(s);
/* And send it to readline */
add_history(s);
if (!(res = PSQLexec(cmdbuf)))
{
- free(cmdbuf);
+ pg_free(cmdbuf);
return fail_lo_xact("\\lo_import", own_transaction);
}
PQclear(res);
- free(cmdbuf);
+ pg_free(cmdbuf);
}
if (!finish_lo_xact("\\lo_import", own_transaction))
if (pset.lineno == 1 && !pset.cur_cmd_interactive &&
strncmp(line, "PGDMP", 5) == 0)
{
- free(line);
+ pg_free(line);
puts(_("The input is a PostgreSQL custom-format dump.\n"
"Use the pg_restore command-line client to restore this dump to a database.\n"));
fflush(stdout);
/* no further processing of empty lines, unless within a literal */
if (line[0] == '\0' && !psql_scan_in_quote(scan_state))
{
- free(line);
+ pg_free(line);
continue;
}
" \\? for help with psql commands\n"
" \\g or terminate with semicolon to execute query\n"
" \\q to quit\n"));
- free(line);
+ pg_free(line);
fflush(stdout);
continue;
}
else
{
/* exit app */
- free(line);
+ pg_free(line);
fflush(stdout);
successResult = EXIT_SUCCESS;
break;
appendPQExpBufferChar(query_buf, '\n');
/* rescan query_buf as new input */
psql_scan_finish(scan_state);
- free(line);
+ pg_free(line);
line = pg_strdup(query_buf->data);
resetPQExpBuffer(query_buf);
/* reset parsing state since we are rescanning whole line */
}
psql_scan_finish(scan_state);
- free(line);
+ pg_free(line);
if (slashCmdStatus == PSQL_CMD_TERMINATE)
{
/* strip trailing newline and carriage return */
(void) pg_strip_crlf(buf);
- free(file);
+ pfree(file);
p += cmdend + 1;
break;
}
val = GetVariable(pset.vars, name);
if (val)
strlcpy(buf, val, sizeof(buf));
- free(name);
+ pfree(name);
p += nameend + 1;
break;
}
new_pass = false;
pset.db = PQconnectdbParams(keywords, values, true);
- free(keywords);
- free(values);
+ pg_free(keywords);
+ pg_free(values);
if (PQstatus(pset.db) == CONNECTION_BAD &&
PQconnectionNeedsPassword(pset.db) &&
PQfinish(pset.db);
password = simple_prompt(password_prompt, false);
- free(password_prompt);
+ pfree(password_prompt);
new_pass = true;
}
} while (new_pass);
if (!result)
pg_fatal("could not set printing parameter \"%s\"", value);
- free(value);
+ pg_free(value);
break;
}
case 'q':
exit(EXIT_FAILURE); /* error already printed */
}
- free(value);
+ pg_free(value);
break;
}
case 'V':
else if (access(filename, R_OK) == 0)
(void) process_file(filename, false);
- free(psqlrc_minor);
- free(psqlrc_major);
+ pfree(psqlrc_minor);
+ pfree(psqlrc_major);
}
if (s)
{
- free(storage);
+ pg_free(storage);
/*
* We may need extra space to insert delimiter nulls for adjacent
if (*start == '\0')
{
/* technically we don't need to free here, but we're nice */
- free(storage);
+ pg_free(storage);
storage = NULL;
string = NULL;
return NULL;
if (!need_quotes)
{
- free(ret);
+ pg_free(ret);
ret = NULL;
}
}
/* free storage */
- free(previous_words);
- free(words_buffer);
- free(text_copy);
- free(completion_ref_object);
+ pg_free(previous_words);
+ pg_free(words_buffer);
+ pfree(text_copy);
+ pg_free(completion_ref_object);
completion_ref_object = NULL;
- free(completion_ref_schema);
+ pg_free(completion_ref_schema);
completion_ref_schema = NULL;
/* Return our Grand List O' Matches */
/* Clean up */
termPQExpBuffer(&query_buffer);
- free(schemaname);
- free(objectname);
- free(e_object_like);
- free(e_schemaname);
- free(e_ref_object);
- free(e_ref_schema);
+ pg_free(schemaname);
+ pg_free(objectname);
+ pg_free(e_object_like);
+ pg_free(e_schemaname);
+ pg_free(e_ref_object);
+ pg_free(e_ref_schema);
}
/* Return the next result, if any, but not if the query failed */
COMPLETE_WITH_LIST_CS((const char *const *) varnames);
for (i = 0; i < nvars; i++)
- free(varnames[i]);
- free(varnames);
+ pg_free(varnames[i]);
+ pg_free(varnames);
return matches;
}
*bptr = '\0';
result = escape_string(buffer);
- free(buffer);
+ pg_free(buffer);
return result;
}
/* Release parsing input workspace, if we made one above */
if (buf != rl_line_buffer)
- free(buf);
+ pg_free(buf);
*nwords = words_found;
return previous_words;
strcpy(workspace + 1, fname);
unquoted_fname = strtokx(workspace, "", NULL, "'", *completion_charp,
false, true, pset.encoding);
- free(workspace);
+ pg_free(workspace);
}
else
unquoted_fname = strtokx(fname, "", NULL, "'", *completion_charp,
{
for (int i = 0; i < numdbs; i++)
free_retrieved_objects(found_objs[i]);
- pg_free(found_objs);
+ pfree(found_objs);
}
}
else
fflush(log_logfile);
}
- free(buf);
+ pg_free(buf);
}
/* clean up */
for (i = 0; i < col_count; i++)
{
- free(col_lineptrs[i]);
- free(format_buf[i]);
- }
- free(width_header);
- free(width_average);
- free(max_width);
- free(width_wrap);
- free(max_nl_lines);
- free(curr_nl_line);
- free(col_lineptrs);
- free(max_bytes);
- free(format_buf);
- free(header_done);
- free(bytes_output);
- free(wrap);
+ pg_free(col_lineptrs[i]);
+ pg_free(format_buf[i]);
+ }
+ pg_free(width_header);
+ pg_free(width_average);
+ pg_free(max_width);
+ pg_free(width_wrap);
+ pg_free(max_nl_lines);
+ pg_free(curr_nl_line);
+ pg_free(col_lineptrs);
+ pg_free(max_bytes);
+ pg_free(format_buf);
+ pg_free(header_done);
+ pg_free(bytes_output);
+ pg_free(wrap);
if (is_local_pager)
ClosePager(fout);
fputc('\n', fout);
}
- free(hlineptr->ptr);
- free(dlineptr->ptr);
- free(hlineptr);
- free(dlineptr);
+ pg_free(hlineptr->ptr);
+ pg_free(dlineptr->ptr);
+ pg_free(hlineptr);
+ pg_free(dlineptr);
if (is_local_pager)
ClosePager(fout);
}
}
- free(header_height);
+ pg_free(header_height);
return lines;
}
appnameenv = psprintf("ecpg/%s", testname_dash.data);
setenv("PGAPPNAME", appnameenv, 1);
- free(appnameenv);
+ pfree(appnameenv);
pid = spawn_process(cmd);
appnameenv = psprintf("isolation/%s", testname);
setenv("PGAPPNAME", appnameenv, 1);
- free(appnameenv);
+ pfree(appnameenv);
pid = spawn_process(psql_cmd.data);
}
}
- free(allsteps);
+ pg_free(allsteps);
}
/*
run_all_permutations_recurse(testspec, piles, 0, stepptrs);
- free(steps);
- free(stepptrs);
- free(piles);
+ pg_free(steps);
+ pg_free(stepptrs);
+ pg_free(piles);
}
static void
PQclear(res);
}
- free(waiting);
+ pg_free(waiting);
}
/*
pg_fatal("Connection to database failed: %s",
PQerrorMessage(copyConn));
- pfree(keywords);
- pfree(vals);
+ pg_free(keywords);
+ pg_free(vals);
PQconninfoFree(opts);
return copyConn;
PQfinish(conn);
- pfree(keywords);
- pfree(vals);
+ pg_free(keywords);
+ pg_free(vals);
PQconninfoFree(opts);
}
new_pgoptions = psprintf("%s %s",
old_pgoptions, my_pgoptions);
setenv("PGOPTIONS", new_pgoptions, 1);
- free(new_pgoptions);
+ pfree(new_pgoptions);
}
if (temp_instance)
GetLastError());
}
- free(tokenuser);
+ pg_free(tokenuser);
*acct = accountname;
*dom = domainname;
}
#ifdef WIN32
- free(active_pids);
+ pg_free(active_pids);
#endif
}
appnameenv = psprintf("pg_regress/%s", testname);
setenv("PGAPPNAME", appnameenv, 1);
- free(appnameenv);
+ pfree(appnameenv);
pid = spawn_process(psql_cmd.data);
projects / thirdparty / postgresql.git / commitdiff
