Package org.apache.openjpa.jdbc.identifier

Examples of org.apache.openjpa.jdbc.identifier.QualifiedDBIdentifier

253
254
255
256
257
258
259
260
261
262
263
264
        // we can create the table for each schema within the PU
        // in here.
       
        Schema[] schemas = group.getSchemas();
        for (int i = 0; i < schemas.length; i++) {
            QualifiedDBIdentifier path = QualifiedDBIdentifier.getPath(_table);
            DBIdentifier schemaName = path.getSchemaName();
            if (DBIdentifier.isEmpty(schemaName)) {
                schemaName = Schemas.getNewTableSchemaIdentifier(_conf);
            }
            if (DBIdentifier.isNull(schemaName)) {
                schemaName = schemas[i].getIdentifier();
View Full Code Here
381
382
383
384
385
386
387
388
389
390
391
392
393
394
     * Creates the object-level representation of the sequence table.
     */
    private void buildTable() {
        DBIdentifier tableName = DBIdentifier.NULL;
        DBIdentifier schemaName = DBIdentifier.NULL;
        QualifiedDBIdentifier path = QualifiedDBIdentifier.getPath(_table);
        if (!DBIdentifier.isEmpty(path.getSchemaName())) {
            schemaName = path.getSchemaName();
            tableName = path.getUnqualifiedName();
        }
        else {
            tableName = _table;
        }
       
View Full Code Here
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
public class TestDBIdentifiers extends TestCase {

    public void testSchemaOps() {
        // Use a schema name with punctuation.  It will get normalized with
        // delimiters.
        QualifiedDBIdentifier p1 = QualifiedDBIdentifier.newPath(DBIdentifier.newSchema("my.schema"));
        DBIdentifier s1 = DBIdentifier.newSchema("my.schema");
        assertTrue(QualifiedDBIdentifier.equal(p1, s1));
        assertEquals("\"my.schema\"", p1.getName());
        assertEquals("\"my.schema\"", s1.getName());
        assertEquals(p1.getType(), DBIdentifierType.SCHEMA);
        assertEquals(s1.getType(), DBIdentifierType.SCHEMA);
        assertFalse(s1 instanceof QualifiedDBIdentifier);

        QualifiedDBIdentifier p2 = QualifiedDBIdentifier.newPath(DBIdentifier.newSchema("SCHEMA"));
        DBIdentifier s2 = DBIdentifier.newSchema("SCHEMA2");
        assertFalse(QualifiedDBIdentifier.equal(p2, s2));
        assertEquals("SCHEMA", p2.getName());
        assertEquals("SCHEMA2", s2.getName());
        assertEquals(p2.getType(), DBIdentifierType.SCHEMA);
        assertEquals(s2.getType(), DBIdentifierType.SCHEMA);
        assertTrue(p2 instanceof QualifiedDBIdentifier);
        assertFalse(s2 instanceof QualifiedDBIdentifier);
    }
View Full Code Here
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
        assertTableEquals(names, "my_schema", "my_table");

        // Use Qualified Identifier to create a compound normalized schema and table name
        DBIdentifier tName = DBIdentifier.newTable("my table");
        DBIdentifier sName = DBIdentifier.newSchema("my schema");
        QualifiedDBIdentifier path = QualifiedDBIdentifier.newPath(sName, tName);
        assertEquals("\"my schema\".\"my table\"", path.getName());
        assertEquals(tName.getName(), path.getBaseName());
        assertEquals(sName.getName(), path.getSchemaName().getName());
       
        // Use Qualified Identifier to create a compound non-normalized schema and table name
        tName = DBIdentifier.newTable("my_table");
        sName = DBIdentifier.newSchema("my_schema");
        path = QualifiedDBIdentifier.newPath(sName, tName);
        assertEquals("my_schema.my_table", path.getName());
        assertEquals(tName.getName(), path.getBaseName());
        assertEquals(sName.getName(), path.getSchemaName().getName());
       
        QualifiedDBIdentifier p1 = QualifiedDBIdentifier.newPath(DBIdentifier.newSchema("schema"),
            DBIdentifier.newTable("my table"));
        QualifiedDBIdentifier p2 = QualifiedDBIdentifier.newPath(DBIdentifier.newSchema("schema"),
            DBIdentifier.newTable("\"my table\""));       
        QualifiedDBIdentifier p3 = QualifiedDBIdentifier.newPath(DBIdentifier.newSchema("schema"),
            DBIdentifier.newTable("my_table"));
        assertTrue(p1.equals(p2));
        assertFalse(p1.equals(p3));
        assertFalse(p2.equals(p3));
        assertFalse(p1.equals(null));
View Full Code Here
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
        assertEquals(cn1.getName(), cn2.getName());
        assertEquals(cn1, cn2);
       
        DBIdentifier tbl = DBIdentifier.newTable("tbl");
        DBIdentifier sch = DBIdentifier.newSchema("sch");
        QualifiedDBIdentifier path = QualifiedDBIdentifier.newPath(sch, tbl);
        QualifiedDBIdentifier path2 = path.clone();
        assertEquals(tbl.getName(), path.getBaseName());
        assertEquals(sch, path.getSchemaName());
        assertEquals(tbl.getName(), path2.getBaseName());
        assertEquals(sch, path2.getSchemaName());
       
        DBIdentifier tbl2 = DBIdentifier.newTable("tbl2");
        DBIdentifier sch2 = DBIdentifier.newSchema("sch2");
        DBIdentifier col = DBIdentifier.newColumn("col");
        QualifiedDBIdentifier cpath = QualifiedDBIdentifier.newPath(sch2, tbl2, col);
        QualifiedDBIdentifier cpath2 = cpath.clone();
        assertEquals(col.getName(), cpath2.getBaseName());
        assertEquals(sch2, cpath2.getSchemaName());
        assertEquals(tbl2, cpath2.getObjectTableName());
       
        // Test delimit operation on create
        DBIdentifier dName = DBIdentifier.newColumn("\"ITEMNAME\"", true);
        assertEquals("\"ITEMNAME\"", dName.getName());
       
View Full Code Here
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
    }
   
    public void testPathOps() {
       
        // Test equals operator with case insensitive names
        QualifiedDBIdentifier p1 = QualifiedDBIdentifier.newPath(DBIdentifier.newTable("MyTable"),
            DBIdentifier.newColumn("mycol"));
        QualifiedDBIdentifier p2 = QualifiedDBIdentifier.newPath(DBIdentifier.newTable("MYTABLE"),
            DBIdentifier.newColumn("MYCOL"));
        assertTrue(QualifiedDBIdentifier.equal(p1, p1));
       
        // Test equals operator with delimited, case sensitive names
        QualifiedDBIdentifier p3 = QualifiedDBIdentifier.newPath(DBIdentifier.newTable("\"MyTable\""),
            DBIdentifier.newColumn("\"mycol\""));
        QualifiedDBIdentifier p4 = QualifiedDBIdentifier.newPath(DBIdentifier.newTable("MYTABLE"),
            DBIdentifier.newColumn("MYCOL"));
        QualifiedDBIdentifier p5 = QualifiedDBIdentifier.newPath(DBIdentifier.newTable("\"MyTable\""),
            DBIdentifier.newColumn("\"mycol\""));
        assertFalse(QualifiedDBIdentifier.equal(p3, p4));
        assertTrue(QualifiedDBIdentifier.equal(p3, p5));
       
        // Test setPath method
        QualifiedDBIdentifier p6 = QualifiedDBIdentifier.newPath(DBIdentifier.newTable("MyTable"),
            DBIdentifier.newColumn("mycol"));
        DBIdentifier n1 = DBIdentifier.newSchema("Schema_1");
        DBIdentifier n2 = DBIdentifier.newTable("Table_1");
        DBIdentifier n3 = DBIdentifier.newColumn("Column_1");
        p6.setPath(n1);
        assertEquals("Schema_1", n1.getName());
        assertEquals(n1.getType(), DBIdentifierType.SCHEMA);
       
        p6.setPath(n2);
        assertEquals("Table_1", n2.getName());
        assertEquals(n2.getType(), DBIdentifierType.TABLE);

        p6.setPath(n3);
        assertEquals("Column_1", n3.getName());
        assertEquals(n3.getType(), DBIdentifierType.COLUMN);

        // Test isDelimited method
        QualifiedDBIdentifier p7 = QualifiedDBIdentifier.newPath(DBIdentifier.newTable("MyTable"),
            DBIdentifier.newColumn("mycol"));
        assertFalse(p7.isDelimited());
        // All identifiers not delimited
        QualifiedDBIdentifier p8 = QualifiedDBIdentifier.newPath(DBIdentifier.newTable("My Table"),
            DBIdentifier.newColumn("mycol"));
        assertFalse(p8.isDelimited());
        // All identifiers delimited by default
        QualifiedDBIdentifier p9 = QualifiedDBIdentifier.newPath(DBIdentifier.newTable("My Table"),
            DBIdentifier.newColumn("my col"));
        assertTrue(p9.isDelimited());

        // All identifiers specifically delimited
        QualifiedDBIdentifier p10 = QualifiedDBIdentifier.newPath(DBIdentifier.newTable("\"MyTable\""),
            DBIdentifier.newColumn("\"my col\""));
        assertTrue(p10.isDelimited());

        // All identifiers specifically delimited sch + tbl + col
        QualifiedDBIdentifier p11 = QualifiedDBIdentifier.newPath(DBIdentifier.newSchema("\"MySchema\""),
            DBIdentifier.newTable("\"my tbl\""));
        assertTrue(p11.isDelimited());

        // Table identifier not delimited
        QualifiedDBIdentifier p12 = QualifiedDBIdentifier.newPath(DBIdentifier.newSchema("\"MySchema\""),
            DBIdentifier.newTable("mytbl"),
            DBIdentifier.newColumn("\"my col\""));
        assertFalse(p12.isDelimited());

    }
View Full Code Here
254
255
256
257
258
259
260
261
262
263
264
265
        // we can create the table for each schema within the PU
        // in here.
       
        Schema[] schemas = group.getSchemas();
        for (int i = 0; i < schemas.length; i++) {
            QualifiedDBIdentifier path = QualifiedDBIdentifier.getPath(_table);
            DBIdentifier schemaName = path.getSchemaName();
            if (DBIdentifier.isEmpty(schemaName)) {
                schemaName = Schemas.getNewTableSchemaIdentifier(_conf);
            }
            if (DBIdentifier.isNull(schemaName)) {
                schemaName = schemas[i].getIdentifier();
View Full Code Here
382
383
384
385
386
387
388
389
390
391
392
393
394
395
     * Creates the object-level representation of the sequence table.
     */
    private void buildTable() {
        DBIdentifier tableName = DBIdentifier.NULL;
        DBIdentifier schemaName = DBIdentifier.NULL;
        QualifiedDBIdentifier path = QualifiedDBIdentifier.getPath(_table);
        if (!DBIdentifier.isEmpty(path.getSchemaName())) {
            schemaName = path.getSchemaName();
            tableName = path.getUnqualifiedName();
        }
        else {
            tableName = _table;
        }
       
View Full Code Here
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
    }

    @Override
    public void addSchema(ClassMapping mapping, SchemaGroup group) {
        // sequence already exists?
        QualifiedDBIdentifier path = QualifiedDBIdentifier.getPath(_seqName);
        if (group.isKnownSequence(path))
            return;

        DBIdentifier schemaName = getSchemaIdentifier();
        if (DBIdentifier.isEmpty(schemaName)) {
            schemaName = path.getSchemaName();
            if (DBIdentifier.isEmpty(schemaName))
                schemaName = Schemas.getNewTableSchemaIdentifier(_conf);
        }

        // create table in this group
View Full Code Here
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
    /**
     * Creates the sequence object.
     */
    private void buildSequence() {
        QualifiedDBIdentifier path = QualifiedDBIdentifier.getPath(_seqName);
        DBIdentifier seqName = path.getIdentifier();
        // JPA 2 added schema as a configurable attribute on 
        // sequence generator.  OpenJPA <= 1.x allowed this via
        // schema.sequence on the sequence name.  Specifying a schema
        // name on the annotation or in the orm will override the old
        // behavior.
        DBIdentifier schemaName = _schema;
        if (DBIdentifier.isEmpty(schemaName)) {
            schemaName = path.getSchemaName();
            if (DBIdentifier.isEmpty(schemaName))
                schemaName = Schemas.getNewTableSchemaIdentifier(_conf);
        }

        // build the sequence in one of the designated schemas
View Full Code Here
TOP

Related Classes of org.apache.openjpa.jdbc.identifier.QualifiedDBIdentifier

  • org.apache.openjpa.jdbc.kernel.NativeJDBCSeq
  • org.apache.openjpa.jdbc.kernel.TableJDBCSeq
  • org.apache.openjpa.jdbc.meta.ClassMappingInfo
  • org.apache.openjpa.jdbc.meta.MappingInfo
  • org.apache.openjpa.jdbc.schema.DynamicSchemaFactory
  • org.apache.openjpa.jdbc.schema.SchemaGenerator
  • org.apache.openjpa.jdbc.schema.TableSchemaFactory
  • org.apache.openjpa.jdbc.sql.identifier.TestDBIdentifiers
    • Copyright © 2018 www.massapicom. All rights reserved.
    All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.