Line data Source code
1 : /*-------------------------------------------------------------------------
2 : *
3 : * pg_collation.c
4 : * routines to support manipulation of the pg_collation relation
5 : *
6 : * Portions Copyright (c) 1996-2017, PostgreSQL Global Development Group
7 : * Portions Copyright (c) 1994, Regents of the University of California
8 : *
9 : *
10 : * IDENTIFICATION
11 : * src/backend/catalog/pg_collation.c
12 : *
13 : *-------------------------------------------------------------------------
14 : */
15 : #include "postgres.h"
16 :
17 : #include "access/genam.h"
18 : #include "access/heapam.h"
19 : #include "access/htup_details.h"
20 : #include "access/sysattr.h"
21 : #include "catalog/dependency.h"
22 : #include "catalog/indexing.h"
23 : #include "catalog/objectaccess.h"
24 : #include "catalog/pg_collation.h"
25 : #include "catalog/pg_collation_fn.h"
26 : #include "catalog/pg_namespace.h"
27 : #include "mb/pg_wchar.h"
28 : #include "utils/builtins.h"
29 : #include "utils/fmgroids.h"
30 : #include "utils/pg_locale.h"
31 : #include "utils/rel.h"
32 : #include "utils/syscache.h"
33 : #include "utils/tqual.h"
34 :
35 :
36 : /*
37 : * CollationCreate
38 : *
39 : * Add a new tuple to pg_collation.
40 : *
41 : * if_not_exists: if true, don't fail on duplicate name, just print a notice
42 : * and return InvalidOid.
43 : * quiet: if true, don't fail on duplicate name, just silently return
44 : * InvalidOid (overrides if_not_exists).
45 : */
46 : Oid
47 6 : CollationCreate(const char *collname, Oid collnamespace,
48 : Oid collowner,
49 : char collprovider,
50 : int32 collencoding,
51 : const char *collcollate, const char *collctype,
52 : const char *collversion,
53 : bool if_not_exists,
54 : bool quiet)
55 : {
56 : Relation rel;
57 : TupleDesc tupDesc;
58 : HeapTuple tup;
59 : Datum values[Natts_pg_collation];
60 : bool nulls[Natts_pg_collation];
61 : NameData name_name,
62 : name_collate,
63 : name_ctype;
64 : Oid oid;
65 : ObjectAddress myself,
66 : referenced;
67 :
68 6 : AssertArg(collname);
69 6 : AssertArg(collnamespace);
70 6 : AssertArg(collowner);
71 6 : AssertArg(collcollate);
72 6 : AssertArg(collctype);
73 :
74 : /*
75 : * Make sure there is no existing collation of same name & encoding.
76 : *
77 : * This would be caught by the unique index anyway; we're just giving a
78 : * friendlier error message. The unique index provides a backstop against
79 : * race conditions.
80 : */
81 6 : if (SearchSysCacheExists3(COLLNAMEENCNSP,
82 : PointerGetDatum(collname),
83 : Int32GetDatum(collencoding),
84 : ObjectIdGetDatum(collnamespace)))
85 : {
86 0 : if (quiet)
87 0 : return InvalidOid;
88 0 : else if (if_not_exists)
89 : {
90 0 : ereport(NOTICE,
91 : (errcode(ERRCODE_DUPLICATE_OBJECT),
92 : collencoding == -1
93 : ? errmsg("collation \"%s\" already exists, skipping",
94 : collname)
95 : : errmsg("collation \"%s\" for encoding \"%s\" already exists, skipping",
96 : collname, pg_encoding_to_char(collencoding))));
97 0 : return InvalidOid;
98 : }
99 : else
100 0 : ereport(ERROR,
101 : (errcode(ERRCODE_DUPLICATE_OBJECT),
102 : collencoding == -1
103 : ? errmsg("collation \"%s\" already exists",
104 : collname)
105 : : errmsg("collation \"%s\" for encoding \"%s\" already exists",
106 : collname, pg_encoding_to_char(collencoding))));
107 : }
108 :
109 : /* open pg_collation; see below about the lock level */
110 6 : rel = heap_open(CollationRelationId, ShareRowExclusiveLock);
111 :
112 : /*
113 : * Also forbid a specific-encoding collation shadowing an any-encoding
114 : * collation, or an any-encoding collation being shadowed (see
115 : * get_collation_name()). This test is not backed up by the unique index,
116 : * so we take a ShareRowExclusiveLock earlier, to protect against
117 : * concurrent changes fooling this check.
118 : */
119 7 : if ((collencoding == -1 &&
120 1 : SearchSysCacheExists3(COLLNAMEENCNSP,
121 : PointerGetDatum(collname),
122 : Int32GetDatum(GetDatabaseEncoding()),
123 6 : ObjectIdGetDatum(collnamespace))) ||
124 5 : (collencoding != -1 &&
125 5 : SearchSysCacheExists3(COLLNAMEENCNSP,
126 : PointerGetDatum(collname),
127 : Int32GetDatum(-1),
128 : ObjectIdGetDatum(collnamespace))))
129 : {
130 1 : if (quiet)
131 : {
132 1 : heap_close(rel, NoLock);
133 1 : return InvalidOid;
134 : }
135 0 : else if (if_not_exists)
136 : {
137 0 : heap_close(rel, NoLock);
138 0 : ereport(NOTICE,
139 : (errcode(ERRCODE_DUPLICATE_OBJECT),
140 : errmsg("collation \"%s\" already exists, skipping",
141 : collname)));
142 0 : return InvalidOid;
143 : }
144 : else
145 0 : ereport(ERROR,
146 : (errcode(ERRCODE_DUPLICATE_OBJECT),
147 : errmsg("collation \"%s\" already exists",
148 : collname)));
149 : }
150 :
151 5 : tupDesc = RelationGetDescr(rel);
152 :
153 : /* form a tuple */
154 5 : memset(nulls, 0, sizeof(nulls));
155 :
156 5 : namestrcpy(&name_name, collname);
157 5 : values[Anum_pg_collation_collname - 1] = NameGetDatum(&name_name);
158 5 : values[Anum_pg_collation_collnamespace - 1] = ObjectIdGetDatum(collnamespace);
159 5 : values[Anum_pg_collation_collowner - 1] = ObjectIdGetDatum(collowner);
160 5 : values[Anum_pg_collation_collprovider - 1] = CharGetDatum(collprovider);
161 5 : values[Anum_pg_collation_collencoding - 1] = Int32GetDatum(collencoding);
162 5 : namestrcpy(&name_collate, collcollate);
163 5 : values[Anum_pg_collation_collcollate - 1] = NameGetDatum(&name_collate);
164 5 : namestrcpy(&name_ctype, collctype);
165 5 : values[Anum_pg_collation_collctype - 1] = NameGetDatum(&name_ctype);
166 5 : if (collversion)
167 0 : values[Anum_pg_collation_collversion - 1] = CStringGetTextDatum(collversion);
168 : else
169 5 : nulls[Anum_pg_collation_collversion - 1] = true;
170 :
171 5 : tup = heap_form_tuple(tupDesc, values, nulls);
172 :
173 : /* insert a new tuple */
174 5 : oid = CatalogTupleInsert(rel, tup);
175 5 : Assert(OidIsValid(oid));
176 :
177 : /* set up dependencies for the new collation */
178 5 : myself.classId = CollationRelationId;
179 5 : myself.objectId = oid;
180 5 : myself.objectSubId = 0;
181 :
182 : /* create dependency on namespace */
183 5 : referenced.classId = NamespaceRelationId;
184 5 : referenced.objectId = collnamespace;
185 5 : referenced.objectSubId = 0;
186 5 : recordDependencyOn(&myself, &referenced, DEPENDENCY_NORMAL);
187 :
188 : /* create dependency on owner */
189 5 : recordDependencyOnOwner(CollationRelationId, HeapTupleGetOid(tup),
190 : collowner);
191 :
192 : /* dependency on extension */
193 5 : recordDependencyOnCurrentExtension(&myself, false);
194 :
195 : /* Post creation hook for new collation */
196 5 : InvokeObjectPostCreateHook(CollationRelationId, oid, 0);
197 :
198 5 : heap_freetuple(tup);
199 5 : heap_close(rel, NoLock);
200 :
201 5 : return oid;
202 : }
203 :
204 : /*
205 : * RemoveCollationById
206 : *
207 : * Remove a tuple from pg_collation by Oid. This function is solely
208 : * called inside catalog/dependency.c
209 : */
210 : void
211 2 : RemoveCollationById(Oid collationOid)
212 : {
213 : Relation rel;
214 : ScanKeyData scanKeyData;
215 : SysScanDesc scandesc;
216 : HeapTuple tuple;
217 :
218 2 : rel = heap_open(CollationRelationId, RowExclusiveLock);
219 :
220 2 : ScanKeyInit(&scanKeyData,
221 : ObjectIdAttributeNumber,
222 : BTEqualStrategyNumber, F_OIDEQ,
223 : ObjectIdGetDatum(collationOid));
224 :
225 2 : scandesc = systable_beginscan(rel, CollationOidIndexId, true,
226 : NULL, 1, &scanKeyData);
227 :
228 2 : tuple = systable_getnext(scandesc);
229 :
230 2 : if (HeapTupleIsValid(tuple))
231 2 : CatalogTupleDelete(rel, &tuple->t_self);
232 : else
233 0 : elog(ERROR, "could not find tuple for collation %u", collationOid);
234 :
235 2 : systable_endscan(scandesc);
236 :
237 2 : heap_close(rel, RowExclusiveLock);
238 2 : }
|
