agora inbox for [email protected]
help / color / mirror / Atom feedFrom: Pierre Ducroquet <[email protected]>
Subject: [PATCH 4/4] move static strings to arrays at beginning
Date: Wed, 26 Jul 2023 22:18:54 +0200
Since namespace, access method, tablespace and owners are unlikely to
be different for each toc entry, it is more efficient to store them as
references to an array at the beginning of the toc.dat file.
---
src/bin/pg_dump/pg_backup_archiver.c | 291 ++++++++++++++++++++++++++-
src/bin/pg_dump/pg_backup_archiver.h | 6 +-
2 files changed, 285 insertions(+), 12 deletions(-)
diff --git a/src/bin/pg_dump/pg_backup_archiver.c b/src/bin/pg_dump/pg_backup_archiver.c
index b33cf60546..e03603011d 100644
--- a/src/bin/pg_dump/pg_backup_archiver.c
+++ b/src/bin/pg_dump/pg_backup_archiver.c
@@ -2468,16 +2468,156 @@ WriteToc(ArchiveHandle *AH)
TocEntry *te;
int tocCount;
int i;
-
- /* count entries that will actually be dumped */
+ int tableam_count;
+ char **tableams;
+ int namespace_count;
+ char **namespaces;
+ int owner_count;
+ char **owners;
+ int tablespace_count;
+ char **tablespaces;
+
+ /* prepare dynamic arrays */
+ tableams = palloc(sizeof(char*) * 1);
+ tableams[0] = NULL;
+ tableam_count = 0;
+ namespaces = palloc(sizeof(char*) * 1);
+ namespaces[0] = NULL;
+ namespace_count = 0;
+ owners = palloc(sizeof(char*) * 1);
+ owners[0] = NULL;
+ owner_count = 0;
+ tablespaces = palloc(sizeof(char*) * 1);
+ tablespaces[0] = NULL;
+ tablespace_count = 0;
+
+ /* count entries that will actually be dumped
+ * and build the dictionnary */
tocCount = 0;
for (te = AH->toc->next; te != AH->toc; te = te->next)
{
if ((te->reqs & (REQ_SCHEMA | REQ_DATA | REQ_SPECIAL)) != 0)
tocCount++;
+ te->tableam_idx = -1;
+ if (te->tableam)
+ {
+ for (i = 0 ; i < tableam_count ; i++)
+ {
+ if (strcmp(tableams[i], te->tableam) == 0)
+ {
+ te->tableam_idx = i;
+ break;
+ }
+ }
+ if (te->tableam_idx == -1)
+ {
+ /* append tableam to array */
+ tableams[tableam_count] = te->tableam;
+ te->tableam_idx = tableam_count;
+ tableam_count++;
+ tableams = pg_realloc(tableams, sizeof(char*) * (tableam_count + 1));
+ }
+ }
+
+ te->namespace_idx = -1;
+ if (te->namespace)
+ {
+ /* reverse iterate for increased perfs, ToC entries can be ordered by namespace */
+ for (i = namespace_count - 1 ; i >= 0 ; i--)
+ {
+ if (strcmp(namespaces[i], te->namespace) == 0)
+ {
+ te->namespace_idx = i;
+ break;
+ }
+ }
+ if (te->namespace_idx == -1)
+ {
+ namespaces[namespace_count] = te->namespace;
+ te->namespace_idx = namespace_count;
+ namespace_count++;
+ namespaces = pg_realloc(namespaces, sizeof(char*) * (namespace_count + 1));
+ }
+ }
+
+ te->owner_idx = -1;
+ if (te->owner)
+ {
+ for (i = 0 ; i < owner_count ; i++)
+ {
+ if (strcmp(owners[i], te->owner) == 0)
+ {
+ te->owner_idx = i;
+ break;
+ }
+ }
+ if (te->owner_idx == -1)
+ {
+ owners[owner_count] = te->owner;
+ te->owner_idx = owner_count;
+ owner_count++;
+ owners = pg_realloc(owners, sizeof(char*) * (owner_count + 1));
+ }
+ }
+
+ te->tablespace_idx = -1;
+ if (te->tablespace)
+ {
+ for (i = 0 ; i < tablespace_count ; i++)
+ {
+ if (strcmp(tablespaces[i], te->tablespace) == 0)
+ {
+ te->tablespace_idx = i;
+ break;
+ }
+ }
+ if (te->tablespace_idx == -1)
+ {
+ tablespaces[tablespace_count] = te->tablespace;
+ te->tablespace_idx = tablespace_count;
+ tablespace_count++;
+ tablespaces = pg_realloc(tablespaces, sizeof(char*) * (tablespace_count + 1));
+ }
+ }
+ }
+
+ /* write the list of am */
+ printf("%d tableams to save\n", tableam_count);
+ WriteInt(AH, tableam_count);
+ for (i = 0 ; i < tableam_count ; i++)
+ {
+ printf("%d is %s\n", i, tableams[i]);
+ WriteStr(AH, tableams[i]);
+ }
+
+ /* write the list of namespaces */
+ printf("%d namespaces to save\n", namespace_count);
+ WriteInt(AH, namespace_count);
+ for (i = 0 ; i < namespace_count ; i++)
+ {
+ printf("%d is %s\n", i, namespaces[i]);
+ WriteStr(AH, namespaces[i]);
+ }
+
+ /* write the list of owners */
+ printf("%d owners to save\n", owner_count);
+ WriteInt(AH, owner_count);
+ for (i = 0 ; i < owner_count ; i++)
+ {
+ printf("%d is %s\n", i, owners[i]);
+ WriteStr(AH, owners[i]);
+ }
+
+ /* write the list of tablespaces */
+ printf("%d tablespaces to save\n", tablespace_count);
+ WriteInt(AH, tablespace_count);
+ for (i = 0 ; i < tablespace_count ; i++)
+ {
+ printf("%d is %s\n", i, tablespaces[i]);
+ WriteStr(AH, tablespaces[i]);
}
- /* printf("%d TOC Entries to save\n", tocCount); */
+ printf("%d TOC Entries to save\n", tocCount);
WriteInt(AH, tocCount);
@@ -2498,10 +2638,22 @@ WriteToc(ArchiveHandle *AH)
WriteStr(AH, te->defn);
WriteStr(AH, te->dropStmt);
WriteStr(AH, te->copyStmt);
- WriteStr(AH, te->namespace);
- WriteStr(AH, te->tablespace);
- WriteStr(AH, te->tableam);
- WriteStr(AH, te->owner);
+ if (namespace_count < 128)
+ AH->WriteBytePtr(AH, te->namespace_idx);
+ else
+ WriteInt(AH, te->namespace_idx);
+ if (tablespace_count < 128)
+ AH->WriteBytePtr(AH, te->tablespace_idx);
+ else
+ WriteInt(AH, te->tablespace_idx);
+ if (tableam_count < 128)
+ AH->WriteBytePtr(AH, te->tableam_idx);
+ else
+ WriteInt(AH, te->tableam_idx);
+ if (owner_count < 128)
+ AH->WriteBytePtr(AH, te->owner_idx);
+ else
+ WriteInt(AH, te->owner_idx);
/* Dump list of dependencies */
for (i = 0; i < te->nDeps; i++)
@@ -2526,6 +2678,53 @@ ReadToc(ArchiveHandle *AH)
int depSize;
TocEntry *te;
bool is_supported;
+ int tableam_count;
+ char **tableams;
+ int namespace_count;
+ char **namespaces;
+ int owner_count;
+ char **owners;
+ int tablespace_count;
+ char **tablespaces;
+ int invalid_entry;
+
+ if (AH->version < K_VERS_1_16)
+ {
+ tableam_count = 0;
+ tableams = NULL;
+ namespace_count = 0;
+ namespaces = NULL;
+ owner_count = 0;
+ owners = NULL;
+ tablespace_count = 0;
+ tablespaces = NULL;
+ }
+ else
+ {
+ tableam_count = ReadInt(AH);
+ tableams = pg_malloc0(sizeof(char*) * tableam_count);
+
+ for (i = 0 ; i < tableam_count ; i++)
+ tableams[i] = ReadStr(AH);
+
+ namespace_count = ReadInt(AH);
+ namespaces = pg_malloc0(sizeof(char*) * namespace_count);
+
+ for (i = 0 ; i < namespace_count ; i++)
+ namespaces[i] = ReadStr(AH);
+
+ owner_count = ReadInt(AH);
+ owners = pg_malloc0(sizeof(char*) * owner_count);
+
+ for (i = 0 ; i < owner_count ; i++)
+ owners[i] = ReadStr(AH);
+
+ tablespace_count = ReadInt(AH);
+ tablespaces = pg_malloc0(sizeof(char*) * tablespace_count);
+
+ for (i = 0 ; i < tablespace_count ; i++)
+ tablespaces[i] = ReadStr(AH);
+ }
AH->tocCount = ReadInt(AH);
AH->maxDumpId = 0;
@@ -2606,16 +2805,86 @@ ReadToc(ArchiveHandle *AH)
if (AH->version >= K_VERS_1_3)
te->copyStmt = ReadStr(AH);
- if (AH->version >= K_VERS_1_6)
+ if (AH->version >= K_VERS_1_6 && AH->version < K_VERS_1_16)
te->namespace = ReadStr(AH);
+ else
+ {
+ if (namespace_count < 128)
+ {
+ te->namespace_idx = AH->ReadBytePtr(AH);
+ invalid_entry = 255;
+ }
+ else
+ {
+ te->namespace_idx = ReadInt(AH);
+ invalid_entry = -1;
+ }
+ if (te->namespace_idx == invalid_entry)
+ te->namespace = "";
+ else
+ te->namespace = namespaces[te->namespace_idx];
+ }
- if (AH->version >= K_VERS_1_10)
+ if (AH->version >= K_VERS_1_10 && AH->version < K_VERS_1_16)
te->tablespace = ReadStr(AH);
+ else
+ {
+ if (tablespace_count < 128)
+ {
+ te->tablespace_idx = AH->ReadBytePtr(AH);
+ invalid_entry = 255;
+ }
+ else
+ {
+ te->tablespace_idx = ReadInt(AH);
+ invalid_entry = -1;
+ }
+ if (te->tablespace_idx == invalid_entry)
+ te->tablespace = NULL;
+ else
+ te->tablespace = tablespaces[te->tablespace_idx];
+ }
- if (AH->version >= K_VERS_1_14)
+ if (AH->version >= K_VERS_1_14 && AH->version < K_VERS_1_16)
te->tableam = ReadStr(AH);
+ else if (AH->version >= K_VERS_1_16)
+ {
+ if (tableam_count < 128)
+ {
+ te->tableam_idx = AH->ReadBytePtr(AH);
+ invalid_entry = 255;
+ }
+ else
+ {
+ te->tableam_idx = ReadInt(AH);
+ invalid_entry = -1;
+ }
+ if (te->tableam_idx == invalid_entry)
+ te->tableam = "";
+ else
+ te->tableam = tableams[te->tableam_idx];
+ }
+
+ if (AH->version < K_VERS_1_16)
+ te->owner = ReadStr(AH);
+ else
+ {
+ if (owner_count < 128)
+ {
+ te->owner_idx = AH->ReadBytePtr(AH);
+ invalid_entry = 255;
+ }
+ else
+ {
+ te->owner_idx = ReadInt(AH);
+ invalid_entry = -1;
+ }
+ if (te->owner_idx == invalid_entry)
+ te->owner = "";
+ else
+ te->owner = owners[te->owner_idx];
+ }
- te->owner = ReadStr(AH);
is_supported = true;
if (AH->version < K_VERS_1_9)
is_supported = false;
diff --git a/src/bin/pg_dump/pg_backup_archiver.h b/src/bin/pg_dump/pg_backup_archiver.h
index 930141a506..0eb170b709 100644
--- a/src/bin/pg_dump/pg_backup_archiver.h
+++ b/src/bin/pg_dump/pg_backup_archiver.h
@@ -68,7 +68,7 @@
#define K_VERS_1_15 MAKE_ARCHIVE_VERSION(1, 15, 0) /* add
* compression_algorithm
* in header */
-#define K_VERS_1_16 MAKE_ARCHIVE_VERSION(1, 16, 0) /* optimize dump format */
+#define K_VERS_1_16 MAKE_ARCHIVE_VERSION(1, 16, 0) /* optimize dump format, add dictionnaries for common strings */
/* Current archive version number (the format we can output) */
#define K_VERS_MAJOR 1
@@ -345,10 +345,14 @@ struct _tocEntry
* in restore) */
char *tag; /* index tag */
char *namespace; /* null or empty string if not in a schema */
+ int namespace_idx; /* schema idx in dictionnary */
char *tablespace; /* null if not in a tablespace; empty string
* means use database default */
+ int tablespace_idx; /* tablespace idx in dictionnary */
char *tableam; /* table access method, only for TABLE tags */
+ int tableam_idx; /* table access method idx in dictionnary, only for TABLE tags */
char *owner;
+ int owner_idx;
char *desc;
char *defn;
char *dropStmt;
--
2.41.0
--nextPart3265648.VqM8IeB0Os--
view thread (7+ messages)
reply
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Reply to all the recipients using the --to and --cc options:
reply via email
To: [email protected]
Cc: [email protected]
Subject: Re: [PATCH 4/4] move static strings to arrays at beginning
In-Reply-To: <no-message-id-1856888@localhost>
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
This inbox is served by agora; see mirroring instructions
for how to clone and mirror all data and code used for this inbox