1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
|
/*-------------------------------------------------------------------------
*
* fileset.c
* Management of named temporary files.
*
* Portions Copyright (c) 1996-2023, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
* src/backend/storage/file/fileset.c
*
* FileSets provide a temporary namespace (think directory) so that files can
* be discovered by name.
*
* FileSets can be used by backends when the temporary files need to be
* opened/closed multiple times and the underlying files need to survive across
* transactions.
*
*-------------------------------------------------------------------------
*/
#include "postgres.h"
#include <limits.h>
#include "catalog/pg_tablespace.h"
#include "commands/tablespace.h"
#include "common/hashfn.h"
#include "miscadmin.h"
#include "storage/ipc.h"
#include "storage/fileset.h"
#include "utils/builtins.h"
static void FileSetPath(char *path, FileSet *fileset, Oid tablespace);
static void FilePath(char *path, FileSet *fileset, const char *name);
static Oid ChooseTablespace(const FileSet *fileset, const char *name);
/*
* Initialize a space for temporary files. This API can be used by shared
* fileset as well as if the temporary files are used only by single backend
* but the files need to be opened and closed multiple times and also the
* underlying files need to survive across transactions.
*
* The callers are expected to explicitly remove such files by using
* FileSetDelete/FileSetDeleteAll.
*
* Files will be distributed over the tablespaces configured in
* temp_tablespaces.
*
* Under the covers the set is one or more directories which will eventually
* be deleted.
*/
void
FileSetInit(FileSet *fileset)
{
static __thread uint32 counter = 0;
fileset->creator_pid = MyProcPid;
fileset->number = counter;
counter = (counter + 1) % INT_MAX;
/* Capture the tablespace OIDs so that all backends agree on them. */
PrepareTempTablespaces();
fileset->ntablespaces =
GetTempTablespaces(&fileset->tablespaces[0],
lengthof(fileset->tablespaces));
if (fileset->ntablespaces == 0)
{
/* If the GUC is empty, use current database's default tablespace */
fileset->tablespaces[0] = MyDatabaseTableSpace;
fileset->ntablespaces = 1;
}
else
{
int i;
/*
* An entry of InvalidOid means use the default tablespace for the
* current database. Replace that now, to be sure that all users of
* the FileSet agree on what to do.
*/
for (i = 0; i < fileset->ntablespaces; i++)
{
if (fileset->tablespaces[i] == InvalidOid)
fileset->tablespaces[i] = MyDatabaseTableSpace;
}
}
}
/*
* Create a new file in the given set.
*/
File
FileSetCreate(FileSet *fileset, const char *name)
{
char path[MAXPGPATH];
File file;
FilePath(path, fileset, name);
file = PathNameCreateTemporaryFile(path, false);
/* If we failed, see if we need to create the directory on demand. */
if (file <= 0)
{
char tempdirpath[MAXPGPATH];
char filesetpath[MAXPGPATH];
Oid tablespace = ChooseTablespace(fileset, name);
TempTablespacePath(tempdirpath, tablespace);
FileSetPath(filesetpath, fileset, tablespace);
PathNameCreateTemporaryDir(tempdirpath, filesetpath);
file = PathNameCreateTemporaryFile(path, true);
}
return file;
}
/*
* Open a file that was created with FileSetCreate() */
File
FileSetOpen(FileSet *fileset, const char *name, int mode)
{
char path[MAXPGPATH];
File file;
FilePath(path, fileset, name);
file = PathNameOpenTemporaryFile(path, mode);
return file;
}
/*
* Delete a file that was created with FileSetCreate().
*
* Return true if the file existed, false if didn't.
*/
bool
FileSetDelete(FileSet *fileset, const char *name,
bool error_on_failure)
{
char path[MAXPGPATH];
FilePath(path, fileset, name);
return PathNameDeleteTemporaryFile(path, error_on_failure);
}
/*
* Delete all files in the set.
*/
void
FileSetDeleteAll(FileSet *fileset)
{
char dirpath[MAXPGPATH];
int i;
/*
* Delete the directory we created in each tablespace. Doesn't fail
* because we use this in error cleanup paths, but can generate LOG
* message on IO error.
*/
for (i = 0; i < fileset->ntablespaces; ++i)
{
FileSetPath(dirpath, fileset, fileset->tablespaces[i]);
PathNameDeleteTemporaryDir(dirpath);
}
}
/*
* Build the path for the directory holding the files backing a FileSet in a
* given tablespace.
*/
static void
FileSetPath(char *path, FileSet *fileset, Oid tablespace)
{
char tempdirpath[MAXPGPATH];
TempTablespacePath(tempdirpath, tablespace);
snprintf(path, MAXPGPATH, "%s/%s%lu.%u.fileset",
tempdirpath, PG_TEMP_FILE_PREFIX,
(unsigned long) fileset->creator_pid, fileset->number);
}
/*
* Sorting has to determine which tablespace a given temporary file belongs in.
*/
static Oid
ChooseTablespace(const FileSet *fileset, const char *name)
{
uint32 hash = hash_any((const unsigned char *) name, strlen(name));
return fileset->tablespaces[hash % fileset->ntablespaces];
}
/*
* Compute the full path of a file in a FileSet.
*/
static void
FilePath(char *path, FileSet *fileset, const char *name)
{
char dirpath[MAXPGPATH];
FileSetPath(dirpath, fileset, ChooseTablespace(fileset, name));
snprintf(path, MAXPGPATH, "%s/%s", dirpath, name);
}
|
