From 32b312078e6dd1fd91a017a5aec62a07bcd63f1d Mon Sep 17 00:00:00 2001 From: Lukas Eder Date: Wed, 28 Mar 2012 18:49:08 +0000 Subject: [PATCH] [#1257] Add CUBRID support - Added dialect, factory, jooq-meta support, demodb generation --- .../java/org/jooq/util/AbstractDatabase.java | 27 +++ .../org/jooq/util/cubrid/CUBRIDDatabase.java | 209 ++++++++++++++++++ .../util/cubrid/CUBRIDTableDefinition.java | 109 +++++++++ .../java/org/jooq/util/cubrid/dba/Dba.java | 36 +++ .../org/jooq/util/cubrid/dba/DbaFactory.java | 33 +++ .../java/org/jooq/util/cubrid/dba/Tables.java | 44 ++++ .../util/cubrid/dba/tables/DbAttribute.java | 116 ++++++++++ .../jooq/util/cubrid/dba/tables/DbClass.java | 81 +++++++ .../jooq/util/cubrid/dba/tables/DbIndex.java | 86 +++++++ .../util/cubrid/dba/tables/DbIndexKey.java | 81 +++++++ .../jooq/util/cubrid/dba/tables/DbSerial.java | 111 ++++++++++ .../org/jooq/util/oracle/OracleDatabase.java | 21 +- .../jooq/configuration/lukas/cubrid/dba.xml | 28 +++ .../configuration/lukas/cubrid/demodb.xml | 34 +++ .../org/jooq/examples/cubrid/demodb/Keys.java | 34 +++ .../jooq/examples/cubrid/demodb/Public.java | 47 ++++ .../examples/cubrid/demodb/PublicFactory.java | 41 ++++ .../examples/cubrid/demodb/Sequences.java | 32 +++ .../jooq/examples/cubrid/demodb/Tables.java | 67 ++++++ .../cubrid/demodb/tables/Athlete.java | 92 ++++++++ .../examples/cubrid/demodb/tables/Code.java | 59 +++++ .../examples/cubrid/demodb/tables/Event.java | 87 ++++++++ .../examples/cubrid/demodb/tables/Game.java | 101 +++++++++ .../cubrid/demodb/tables/History.java | 89 ++++++++ .../examples/cubrid/demodb/tables/Nation.java | 82 +++++++ .../cubrid/demodb/tables/Olympic.java | 102 +++++++++ .../cubrid/demodb/tables/Participant.java | 89 ++++++++ .../examples/cubrid/demodb/tables/Record.java | 98 ++++++++ .../cubrid/demodb/tables/Stadium.java | 92 ++++++++ .../cubrid/demodb/tables/pojos/Athlete.java | 66 ++++++ .../cubrid/demodb/tables/pojos/Code.java | 35 +++ .../cubrid/demodb/tables/pojos/Event.java | 66 ++++++ .../cubrid/demodb/tables/pojos/Game.java | 87 ++++++++ .../cubrid/demodb/tables/pojos/History.java | 67 ++++++ .../cubrid/demodb/tables/pojos/Nation.java | 56 +++++ .../cubrid/demodb/tables/pojos/Olympic.java | 96 ++++++++ .../demodb/tables/pojos/Participant.java | 67 ++++++ .../cubrid/demodb/tables/pojos/Record.java | 77 +++++++ .../cubrid/demodb/tables/pojos/Stadium.java | 76 +++++++ .../demodb/tables/records/AthleteRecord.java | 101 +++++++++ .../demodb/tables/records/CodeRecord.java | 51 +++++ .../demodb/tables/records/EventRecord.java | 101 +++++++++ .../demodb/tables/records/GameRecord.java | 140 ++++++++++++ .../demodb/tables/records/HistoryRecord.java | 106 +++++++++ .../demodb/tables/records/NationRecord.java | 86 +++++++ .../demodb/tables/records/OlympicRecord.java | 146 ++++++++++++ .../tables/records/ParticipantRecord.java | 106 +++++++++ .../demodb/tables/records/RecordRecord.java | 129 +++++++++++ .../demodb/tables/records/StadiumRecord.java | 116 ++++++++++ .../GenerationTool CUBRID demodb.launch | 33 +++ .../launch/Meta-Generate CUBRID dba.launch | 31 +++ jOOQ-test/lib/JDBC-8.4.1.1018-cubrid.jar | Bin 0 -> 198347 bytes jOOQ/src/main/java/org/jooq/SQLDialect.java | 6 + .../java/org/jooq/impl/FieldTypeHelper.java | 3 + .../main/java/org/jooq/impl/SQLDataType.java | 2 + .../org/jooq/util/cubrid/CUBRIDDataType.java | 141 ++++++++++++ .../org/jooq/util/cubrid/CUBRIDFactory.java | 72 ++++++ 57 files changed, 4172 insertions(+), 19 deletions(-) create mode 100644 jOOQ-meta/src/main/java/org/jooq/util/cubrid/CUBRIDDatabase.java create mode 100644 jOOQ-meta/src/main/java/org/jooq/util/cubrid/CUBRIDTableDefinition.java create mode 100644 jOOQ-meta/src/main/java/org/jooq/util/cubrid/dba/Dba.java create mode 100644 jOOQ-meta/src/main/java/org/jooq/util/cubrid/dba/DbaFactory.java create mode 100644 jOOQ-meta/src/main/java/org/jooq/util/cubrid/dba/Tables.java create mode 100644 jOOQ-meta/src/main/java/org/jooq/util/cubrid/dba/tables/DbAttribute.java create mode 100644 jOOQ-meta/src/main/java/org/jooq/util/cubrid/dba/tables/DbClass.java create mode 100644 jOOQ-meta/src/main/java/org/jooq/util/cubrid/dba/tables/DbIndex.java create mode 100644 jOOQ-meta/src/main/java/org/jooq/util/cubrid/dba/tables/DbIndexKey.java create mode 100644 jOOQ-meta/src/main/java/org/jooq/util/cubrid/dba/tables/DbSerial.java create mode 100644 jOOQ-test/configuration/org/jooq/configuration/lukas/cubrid/dba.xml create mode 100644 jOOQ-test/configuration/org/jooq/configuration/lukas/cubrid/demodb.xml create mode 100644 jOOQ-test/examples/org/jooq/examples/cubrid/demodb/Keys.java create mode 100644 jOOQ-test/examples/org/jooq/examples/cubrid/demodb/Public.java create mode 100644 jOOQ-test/examples/org/jooq/examples/cubrid/demodb/PublicFactory.java create mode 100644 jOOQ-test/examples/org/jooq/examples/cubrid/demodb/Sequences.java create mode 100644 jOOQ-test/examples/org/jooq/examples/cubrid/demodb/Tables.java create mode 100644 jOOQ-test/examples/org/jooq/examples/cubrid/demodb/tables/Athlete.java create mode 100644 jOOQ-test/examples/org/jooq/examples/cubrid/demodb/tables/Code.java create mode 100644 jOOQ-test/examples/org/jooq/examples/cubrid/demodb/tables/Event.java create mode 100644 jOOQ-test/examples/org/jooq/examples/cubrid/demodb/tables/Game.java create mode 100644 jOOQ-test/examples/org/jooq/examples/cubrid/demodb/tables/History.java create mode 100644 jOOQ-test/examples/org/jooq/examples/cubrid/demodb/tables/Nation.java create mode 100644 jOOQ-test/examples/org/jooq/examples/cubrid/demodb/tables/Olympic.java create mode 100644 jOOQ-test/examples/org/jooq/examples/cubrid/demodb/tables/Participant.java create mode 100644 jOOQ-test/examples/org/jooq/examples/cubrid/demodb/tables/Record.java create mode 100644 jOOQ-test/examples/org/jooq/examples/cubrid/demodb/tables/Stadium.java create mode 100644 jOOQ-test/examples/org/jooq/examples/cubrid/demodb/tables/pojos/Athlete.java create mode 100644 jOOQ-test/examples/org/jooq/examples/cubrid/demodb/tables/pojos/Code.java create mode 100644 jOOQ-test/examples/org/jooq/examples/cubrid/demodb/tables/pojos/Event.java create mode 100644 jOOQ-test/examples/org/jooq/examples/cubrid/demodb/tables/pojos/Game.java create mode 100644 jOOQ-test/examples/org/jooq/examples/cubrid/demodb/tables/pojos/History.java create mode 100644 jOOQ-test/examples/org/jooq/examples/cubrid/demodb/tables/pojos/Nation.java create mode 100644 jOOQ-test/examples/org/jooq/examples/cubrid/demodb/tables/pojos/Olympic.java create mode 100644 jOOQ-test/examples/org/jooq/examples/cubrid/demodb/tables/pojos/Participant.java create mode 100644 jOOQ-test/examples/org/jooq/examples/cubrid/demodb/tables/pojos/Record.java create mode 100644 jOOQ-test/examples/org/jooq/examples/cubrid/demodb/tables/pojos/Stadium.java create mode 100644 jOOQ-test/examples/org/jooq/examples/cubrid/demodb/tables/records/AthleteRecord.java create mode 100644 jOOQ-test/examples/org/jooq/examples/cubrid/demodb/tables/records/CodeRecord.java create mode 100644 jOOQ-test/examples/org/jooq/examples/cubrid/demodb/tables/records/EventRecord.java create mode 100644 jOOQ-test/examples/org/jooq/examples/cubrid/demodb/tables/records/GameRecord.java create mode 100644 jOOQ-test/examples/org/jooq/examples/cubrid/demodb/tables/records/HistoryRecord.java create mode 100644 jOOQ-test/examples/org/jooq/examples/cubrid/demodb/tables/records/NationRecord.java create mode 100644 jOOQ-test/examples/org/jooq/examples/cubrid/demodb/tables/records/OlympicRecord.java create mode 100644 jOOQ-test/examples/org/jooq/examples/cubrid/demodb/tables/records/ParticipantRecord.java create mode 100644 jOOQ-test/examples/org/jooq/examples/cubrid/demodb/tables/records/RecordRecord.java create mode 100644 jOOQ-test/examples/org/jooq/examples/cubrid/demodb/tables/records/StadiumRecord.java create mode 100644 jOOQ-test/launch/GenerationTool CUBRID demodb.launch create mode 100644 jOOQ-test/launch/Meta-Generate CUBRID dba.launch create mode 100644 jOOQ-test/lib/JDBC-8.4.1.1018-cubrid.jar create mode 100644 jOOQ/src/main/java/org/jooq/util/cubrid/CUBRIDDataType.java create mode 100644 jOOQ/src/main/java/org/jooq/util/cubrid/CUBRIDFactory.java diff --git a/jOOQ-meta/src/main/java/org/jooq/util/AbstractDatabase.java b/jOOQ-meta/src/main/java/org/jooq/util/AbstractDatabase.java index 04d6fbf763..ebf9a97f1f 100644 --- a/jOOQ-meta/src/main/java/org/jooq/util/AbstractDatabase.java +++ b/jOOQ-meta/src/main/java/org/jooq/util/AbstractDatabase.java @@ -38,12 +38,14 @@ package org.jooq.util; import java.io.IOException; import java.io.StringReader; +import java.math.BigInteger; import java.sql.Connection; import java.sql.SQLException; import java.util.ArrayList; import java.util.List; import org.jooq.SQLDialect; +import org.jooq.impl.SQLDataType; import org.jooq.tools.JooqLogger; import org.jooq.tools.csv.CSVReader; import org.jooq.util.jaxb.CustomType; @@ -665,4 +667,29 @@ public abstract class AbstractDatabase implements Database { * {@link #getArrays(SchemaDefinition)} */ protected abstract List getArrays0() throws SQLException; + + /** + * Get the data type considering a known max value + */ + protected final DataTypeDefinition getDataTypeForMAX_VAL(SchemaDefinition schema, BigInteger value) { + DataTypeDefinition type; + + if (BigInteger.valueOf(Byte.MAX_VALUE).compareTo(value) >= 0) { + type = new DefaultDataTypeDefinition(this, schema, SQLDataType.NUMERIC.getTypeName(), 0, 2, 0); + } + else if (BigInteger.valueOf(Short.MAX_VALUE).compareTo(value) >= 0) { + type = new DefaultDataTypeDefinition(this, schema, SQLDataType.NUMERIC.getTypeName(), 0, 4, 0); + } + else if (BigInteger.valueOf(Integer.MAX_VALUE).compareTo(value) >= 0) { + type = new DefaultDataTypeDefinition(this, schema, SQLDataType.NUMERIC.getTypeName(), 0, 9, 0); + } + else if (BigInteger.valueOf(Long.MAX_VALUE).compareTo(value) >= 0) { + type = new DefaultDataTypeDefinition(this, schema, SQLDataType.NUMERIC.getTypeName(), 0, 18, 0); + } + else { + type = new DefaultDataTypeDefinition(this, schema, SQLDataType.NUMERIC.getTypeName(), 0, 38, 0); + } + + return type; + } } diff --git a/jOOQ-meta/src/main/java/org/jooq/util/cubrid/CUBRIDDatabase.java b/jOOQ-meta/src/main/java/org/jooq/util/cubrid/CUBRIDDatabase.java new file mode 100644 index 0000000000..25d60825c5 --- /dev/null +++ b/jOOQ-meta/src/main/java/org/jooq/util/cubrid/CUBRIDDatabase.java @@ -0,0 +1,209 @@ +/** + * Copyright (c) 2009-2012, Lukas Eder, lukas.eder@gmail.com + * All rights reserved. + * + * This software is licensed to you under the Apache License, Version 2.0 + * (the "License"); You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * . Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * . Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * . Neither the name "jOOQ" nor the names of its contributors may be + * used to endorse or promote products derived from this software without + * specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ + +package org.jooq.util.cubrid; + +import static org.jooq.util.cubrid.dba.Tables.DB_CLASS; +import static org.jooq.util.cubrid.dba.Tables.DB_INDEX; +import static org.jooq.util.cubrid.dba.Tables.DB_INDEX_KEY; +import static org.jooq.util.cubrid.dba.Tables.DB_SERIAL; + +import java.math.BigInteger; +import java.sql.SQLException; +import java.util.ArrayList; +import java.util.List; + +import org.jooq.Condition; +import org.jooq.Record; +import org.jooq.Result; +import org.jooq.impl.Factory; +import org.jooq.util.AbstractDatabase; +import org.jooq.util.ArrayDefinition; +import org.jooq.util.DataTypeDefinition; +import org.jooq.util.DefaultRelations; +import org.jooq.util.DefaultSequenceDefinition; +import org.jooq.util.EnumDefinition; +import org.jooq.util.PackageDefinition; +import org.jooq.util.RoutineDefinition; +import org.jooq.util.SchemaDefinition; +import org.jooq.util.SequenceDefinition; +import org.jooq.util.TableDefinition; +import org.jooq.util.UDTDefinition; + +/** + * @author Lukas Eder + */ +public class CUBRIDDatabase extends AbstractDatabase { + + @Override + protected void loadPrimaryKeys(DefaultRelations relations) throws SQLException { + for (Record record : fetchKeys(DB_INDEX.IS_UNIQUE.isTrue().and(DB_INDEX.IS_PRIMARY_KEY.isFalse()))) { + SchemaDefinition schema = getSchema(record.getValue(DB_CLASS.OWNER_NAME)); + String key = record.getValue(DB_INDEX.INDEX_NAME); + String tableName = record.getValue(DB_CLASS.CLASS_NAME); + String columnName = record.getValue(DB_INDEX_KEY.KEY_ATTR_NAME); + + TableDefinition table = getTable(schema, tableName); + if (table != null) { + relations.addUniqueKey(key, table.getColumn(columnName)); + } + } + } + + @Override + protected void loadUniqueKeys(DefaultRelations relations) throws SQLException { + for (Record record : fetchKeys(DB_INDEX.IS_PRIMARY_KEY.isTrue())) { + SchemaDefinition schema = getSchema(record.getValue(DB_CLASS.OWNER_NAME)); + String key = record.getValue(DB_INDEX.INDEX_NAME); + String tableName = record.getValue(DB_CLASS.CLASS_NAME); + String columnName = record.getValue(DB_INDEX_KEY.KEY_ATTR_NAME); + + TableDefinition table = getTable(schema, tableName); + if (table != null) { + relations.addPrimaryKey(key, table.getColumn(columnName)); + } + } + } + + private Result fetchKeys(Condition condition) { + return + create().select( + DB_INDEX.INDEX_NAME, + DB_INDEX_KEY.KEY_ATTR_NAME, + DB_CLASS.CLASS_NAME, + DB_CLASS.OWNER_NAME) + .from(DB_INDEX) + .join(DB_CLASS).on(DB_INDEX.CLASS_NAME.equal(DB_CLASS.CLASS_NAME)) + .join(DB_INDEX_KEY).on( + DB_INDEX_KEY.INDEX_NAME.equal(DB_INDEX.INDEX_NAME).and( + DB_INDEX_KEY.CLASS_NAME.equal(DB_INDEX.CLASS_NAME))) + .where(condition) + .and(DB_CLASS.OWNER_NAME.in(getInputSchemata())) + .orderBy( + DB_CLASS.OWNER_NAME.asc(), + DB_INDEX.INDEX_NAME.asc()) + .fetch(); + } + + @Override + protected void loadForeignKeys(DefaultRelations relations) throws SQLException { + } + + @Override + protected List getSequences0() throws SQLException { + List result = new ArrayList(); + + for (Record record : create() + .select( + DB_SERIAL.NAME, + DB_SERIAL.MAX_VAL) + .from(DB_SERIAL) + .fetch()) { + + // TODO: How to join DB_SERIAL.OWNER? + SchemaDefinition schema = getSchema(getInputSchemata().get(0)); + BigInteger value = record.getValue(DB_SERIAL.MAX_VAL, BigInteger.class, BigInteger.valueOf(Long.MAX_VALUE)); + DataTypeDefinition type = getDataTypeForMAX_VAL(schema, value); + + result.add(new DefaultSequenceDefinition( + schema, + record.getValue(DB_SERIAL.NAME), + type)); + } + + return result; + } + + @Override + protected List getTables0() throws SQLException { + List result = new ArrayList(); + + for (Record record : create() + .select( + DB_CLASS.OWNER_NAME, + DB_CLASS.CLASS_NAME) + .from(DB_CLASS) + .where(DB_CLASS.OWNER_NAME.in(getInputSchemata())) + .orderBy( + DB_CLASS.OWNER_NAME.asc(), + DB_CLASS.CLASS_NAME.asc()) + .fetch()) { + + SchemaDefinition schema = getSchema(record.getValue(DB_CLASS.OWNER_NAME)); + String name = record.getValue(DB_CLASS.CLASS_NAME); + + CUBRIDTableDefinition table = new CUBRIDTableDefinition(schema, name, null); + result.add(table); + } + + return result; + } + + @Override + protected List getEnums0() throws SQLException { + List result = new ArrayList(); + return result; + } + + @Override + protected List getUDTs0() throws SQLException { + List result = new ArrayList(); + return result; + } + + @Override + protected List getArrays0() throws SQLException { + List result = new ArrayList(); + return result; + } + + @Override + protected List getRoutines0() throws SQLException { + List result = new ArrayList(); + return result; + } + + @Override + protected List getPackages0() throws SQLException { + List result = new ArrayList(); + return result; + } + + @Override + public Factory create() { + return new CUBRIDFactory(getConnection()); + } +} diff --git a/jOOQ-meta/src/main/java/org/jooq/util/cubrid/CUBRIDTableDefinition.java b/jOOQ-meta/src/main/java/org/jooq/util/cubrid/CUBRIDTableDefinition.java new file mode 100644 index 0000000000..f02bb31e7a --- /dev/null +++ b/jOOQ-meta/src/main/java/org/jooq/util/cubrid/CUBRIDTableDefinition.java @@ -0,0 +1,109 @@ +/** + * Copyright (c) 2009-2012, Lukas Eder, lukas.eder@gmail.com + * All rights reserved. + * + * This software is licensed to you under the Apache License, Version 2.0 + * (the "License"); You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * . Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * . Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * . Neither the name "jOOQ" nor the names of its contributors may be + * used to endorse or promote products derived from this software without + * specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ + +package org.jooq.util.cubrid; + +import static org.jooq.util.cubrid.dba.Tables.DB_ATTRIBUTE; +import static org.jooq.util.cubrid.dba.Tables.DB_SERIAL; + +import java.sql.SQLException; +import java.util.ArrayList; +import java.util.List; + +import org.jooq.Record; +import org.jooq.util.AbstractTableDefinition; +import org.jooq.util.ColumnDefinition; +import org.jooq.util.DataTypeDefinition; +import org.jooq.util.DefaultColumnDefinition; +import org.jooq.util.DefaultDataTypeDefinition; +import org.jooq.util.SchemaDefinition; + +/** + * @author Lukas Eder + */ +public class CUBRIDTableDefinition extends AbstractTableDefinition { + + public CUBRIDTableDefinition(SchemaDefinition schema, String name, String comment) { + super(schema, name, comment); + } + + @Override + public List getElements0() throws SQLException { + List result = new ArrayList(); + + for (Record record : create() + .select( + DB_ATTRIBUTE.ATTR_NAME, + DB_ATTRIBUTE.DEF_ORDER, + DB_ATTRIBUTE.DATA_TYPE, + DB_ATTRIBUTE.PREC, + DB_ATTRIBUTE.SCALE, + DB_ATTRIBUTE.IS_NULLABLE, + DB_SERIAL.NAME) + .from(DB_ATTRIBUTE) + .leftOuterJoin(DB_SERIAL).on( + DB_ATTRIBUTE.ATTR_NAME.equal(DB_SERIAL.ATT_NAME).and( + DB_ATTRIBUTE.CLASS_NAME.equal(DB_SERIAL.CLASS_NAME))) + .where(DB_ATTRIBUTE.CLASS_NAME.equal(getName())) + .orderBy(DB_ATTRIBUTE.DEF_ORDER) + .fetch()) { + + String dataType = record.getValue(DB_ATTRIBUTE.DATA_TYPE); + + DataTypeDefinition type = new DefaultDataTypeDefinition( + getDatabase(), + getSchema(), + dataType, + record.getValue(DB_ATTRIBUTE.PREC), + record.getValue(DB_ATTRIBUTE.PREC), + record.getValue(DB_ATTRIBUTE.SCALE), + dataType); + + ColumnDefinition column = new DefaultColumnDefinition( + getDatabase().getTable(getSchema(), getName()), + record.getValue(DB_ATTRIBUTE.ATTR_NAME), + record.getValue(DB_ATTRIBUTE.DEF_ORDER), + type, + record.getValue(DB_ATTRIBUTE.IS_NULLABLE, boolean.class), + record.getValue(DB_SERIAL.NAME) != null, + null); + + result.add(column); + } + + return result; + } +} diff --git a/jOOQ-meta/src/main/java/org/jooq/util/cubrid/dba/Dba.java b/jOOQ-meta/src/main/java/org/jooq/util/cubrid/dba/Dba.java new file mode 100644 index 0000000000..0fde09500b --- /dev/null +++ b/jOOQ-meta/src/main/java/org/jooq/util/cubrid/dba/Dba.java @@ -0,0 +1,36 @@ +/** + * This class is generated by jOOQ + */ +package org.jooq.util.cubrid.dba; + +/** + * This class is generated by jOOQ. + */ +@javax.annotation.Generated(value = {"http://www.jooq.org", "2.1.0"}, + comments = "This class is generated by jOOQ") +public class Dba extends org.jooq.impl.SchemaImpl { + + private static final long serialVersionUID = 122025387; + + /** + * The singleton instance of DBA + */ + public static final Dba DBA = new Dba(); + + /** + * No further instances allowed + */ + private Dba() { + super("DBA"); + } + + @Override + public final java.util.List> getTables() { + return java.util.Arrays.>asList( + org.jooq.util.cubrid.dba.tables.DbAttribute.DB_ATTRIBUTE, + org.jooq.util.cubrid.dba.tables.DbClass.DB_CLASS, + org.jooq.util.cubrid.dba.tables.DbIndex.DB_INDEX, + org.jooq.util.cubrid.dba.tables.DbIndexKey.DB_INDEX_KEY, + org.jooq.util.cubrid.dba.tables.DbSerial.DB_SERIAL); + } +} diff --git a/jOOQ-meta/src/main/java/org/jooq/util/cubrid/dba/DbaFactory.java b/jOOQ-meta/src/main/java/org/jooq/util/cubrid/dba/DbaFactory.java new file mode 100644 index 0000000000..0561f9552e --- /dev/null +++ b/jOOQ-meta/src/main/java/org/jooq/util/cubrid/dba/DbaFactory.java @@ -0,0 +1,33 @@ +/** + * This class is generated by jOOQ + */ +package org.jooq.util.cubrid.dba; + +/** + * This class is generated by jOOQ. + */ +@javax.annotation.Generated(value = {"http://www.jooq.org", "2.1.0"}, + comments = "This class is generated by jOOQ") +public class DbaFactory extends org.jooq.util.ase.ASEFactory { + + private static final long serialVersionUID = 2132590899; + + /** + * Create a factory with a connection + * + * @param connection The connection to use with objects created from this factory + */ + public DbaFactory(java.sql.Connection connection) { + super(connection); + } + + /** + * Create a factory with a connection and some settings + * + * @param connection The connection to use with objects created from this factory + * @param settings The settings to apply to objects created from this factory + */ + public DbaFactory(java.sql.Connection connection, org.jooq.conf.Settings settings) { + super(connection, settings); + } +} diff --git a/jOOQ-meta/src/main/java/org/jooq/util/cubrid/dba/Tables.java b/jOOQ-meta/src/main/java/org/jooq/util/cubrid/dba/Tables.java new file mode 100644 index 0000000000..e12910ca1a --- /dev/null +++ b/jOOQ-meta/src/main/java/org/jooq/util/cubrid/dba/Tables.java @@ -0,0 +1,44 @@ +/** + * This class is generated by jOOQ + */ +package org.jooq.util.cubrid.dba; + +/** + * This class is generated by jOOQ. + * + * Convenience access to all tables in DBA + */ +@javax.annotation.Generated(value = {"http://www.jooq.org", "2.1.0"}, + comments = "This class is generated by jOOQ") +public final class Tables { + + /** + * The table DBA.db_attribute + */ + public static org.jooq.util.cubrid.dba.tables.DbAttribute DB_ATTRIBUTE = org.jooq.util.cubrid.dba.tables.DbAttribute.DB_ATTRIBUTE; + + /** + * The table DBA.db_class + */ + public static org.jooq.util.cubrid.dba.tables.DbClass DB_CLASS = org.jooq.util.cubrid.dba.tables.DbClass.DB_CLASS; + + /** + * The table DBA.db_index + */ + public static org.jooq.util.cubrid.dba.tables.DbIndex DB_INDEX = org.jooq.util.cubrid.dba.tables.DbIndex.DB_INDEX; + + /** + * The table DBA.db_index_key + */ + public static org.jooq.util.cubrid.dba.tables.DbIndexKey DB_INDEX_KEY = org.jooq.util.cubrid.dba.tables.DbIndexKey.DB_INDEX_KEY; + + /** + * The table DBA.db_serial + */ + public static org.jooq.util.cubrid.dba.tables.DbSerial DB_SERIAL = org.jooq.util.cubrid.dba.tables.DbSerial.DB_SERIAL; + + /** + * No instances + */ + private Tables() {} +} diff --git a/jOOQ-meta/src/main/java/org/jooq/util/cubrid/dba/tables/DbAttribute.java b/jOOQ-meta/src/main/java/org/jooq/util/cubrid/dba/tables/DbAttribute.java new file mode 100644 index 0000000000..c225683d8e --- /dev/null +++ b/jOOQ-meta/src/main/java/org/jooq/util/cubrid/dba/tables/DbAttribute.java @@ -0,0 +1,116 @@ +/** + * This class is generated by jOOQ + */ +package org.jooq.util.cubrid.dba.tables; + +/** + * This class is generated by jOOQ. + */ +@javax.annotation.Generated(value = {"http://www.jooq.org", "2.1.0"}, + comments = "This class is generated by jOOQ") +public class DbAttribute extends org.jooq.impl.TableImpl { + + private static final long serialVersionUID = 1673379172; + + /** + * The singleton instance of DBA.db_attribute + */ + public static final org.jooq.util.cubrid.dba.tables.DbAttribute DB_ATTRIBUTE = new org.jooq.util.cubrid.dba.tables.DbAttribute(); + + /** + * The class holding records for this type + */ + private static final java.lang.Class __RECORD_TYPE = org.jooq.Record.class; + + /** + * The class holding records for this type + */ + @Override + public java.lang.Class getRecordType() { + return __RECORD_TYPE; + } + + /** + * An uncommented item + */ + public final org.jooq.TableField ATTR_NAME = createField("attr_name", org.jooq.impl.SQLDataType.VARCHAR, this); + + /** + * An uncommented item + */ + public final org.jooq.TableField CLASS_NAME = createField("class_name", org.jooq.impl.SQLDataType.VARCHAR, this); + + /** + * An uncommented item + */ + public final org.jooq.TableField ATTR_TYPE = createField("attr_type", org.jooq.impl.SQLDataType.VARCHAR, this); + + /** + * An uncommented item + */ + public final org.jooq.TableField DEF_ORDER = createField("def_order", org.jooq.impl.SQLDataType.INTEGER, this); + + /** + * An uncommented item + */ + public final org.jooq.TableField FROM_CLASS_NAME = createField("from_class_name", org.jooq.impl.SQLDataType.VARCHAR, this); + + /** + * An uncommented item + */ + public final org.jooq.TableField FROM_ATTR_NAME = createField("from_attr_name", org.jooq.impl.SQLDataType.VARCHAR, this); + + /** + * An uncommented item + */ + public final org.jooq.TableField DATA_TYPE = createField("data_type", org.jooq.impl.SQLDataType.VARCHAR, this); + + /** + * An uncommented item + */ + public final org.jooq.TableField PREC = createField("prec", org.jooq.impl.SQLDataType.INTEGER, this); + + /** + * An uncommented item + */ + public final org.jooq.TableField SCALE = createField("scale", org.jooq.impl.SQLDataType.INTEGER, this); + + /** + * An uncommented item + */ + public final org.jooq.TableField CODE_SET = createField("code_set", org.jooq.impl.SQLDataType.INTEGER, this); + + /** + * An uncommented item + */ + public final org.jooq.TableField DOMAIN_CLASS_NAME = createField("domain_class_name", org.jooq.impl.SQLDataType.VARCHAR, this); + + /** + * An uncommented item + */ + public final org.jooq.TableField DEFAULT_VALUE = createField("default_value", org.jooq.impl.SQLDataType.VARCHAR, this); + + /** + * An uncommented item + */ + public final org.jooq.TableField IS_NULLABLE = createField("is_nullable", org.jooq.impl.SQLDataType.VARCHAR, this); + + /** + * No further instances allowed + */ + private DbAttribute() { + super("db_attribute", org.jooq.util.cubrid.dba.Dba.DBA); + } + + /** + * No further instances allowed + */ + private DbAttribute(java.lang.String alias) { + super(alias, org.jooq.util.cubrid.dba.Dba.DBA, org.jooq.util.cubrid.dba.tables.DbAttribute.DB_ATTRIBUTE); + } + + @Override + public org.jooq.util.cubrid.dba.tables.DbAttribute as(java.lang.String alias) { + return new org.jooq.util.cubrid.dba.tables.DbAttribute(alias); + } +} diff --git a/jOOQ-meta/src/main/java/org/jooq/util/cubrid/dba/tables/DbClass.java b/jOOQ-meta/src/main/java/org/jooq/util/cubrid/dba/tables/DbClass.java new file mode 100644 index 0000000000..35004f5a34 --- /dev/null +++ b/jOOQ-meta/src/main/java/org/jooq/util/cubrid/dba/tables/DbClass.java @@ -0,0 +1,81 @@ +/** + * This class is generated by jOOQ + */ +package org.jooq.util.cubrid.dba.tables; + +/** + * This class is generated by jOOQ. + */ +@javax.annotation.Generated(value = {"http://www.jooq.org", "2.1.0"}, + comments = "This class is generated by jOOQ") +public class DbClass extends org.jooq.impl.TableImpl { + + private static final long serialVersionUID = -742829459; + + /** + * The singleton instance of DBA.db_class + */ + public static final org.jooq.util.cubrid.dba.tables.DbClass DB_CLASS = new org.jooq.util.cubrid.dba.tables.DbClass(); + + /** + * The class holding records for this type + */ + private static final java.lang.Class __RECORD_TYPE = org.jooq.Record.class; + + /** + * The class holding records for this type + */ + @Override + public java.lang.Class getRecordType() { + return __RECORD_TYPE; + } + + /** + * An uncommented item + */ + public final org.jooq.TableField CLASS_NAME = createField("class_name", org.jooq.impl.SQLDataType.VARCHAR, this); + + /** + * An uncommented item + */ + public final org.jooq.TableField OWNER_NAME = createField("owner_name", org.jooq.impl.SQLDataType.VARCHAR, this); + + /** + * An uncommented item + */ + public final org.jooq.TableField CLASS_TYPE = createField("class_type", org.jooq.impl.SQLDataType.VARCHAR, this); + + /** + * An uncommented item + */ + public final org.jooq.TableField IS_SYSTEM_CLASS = createField("is_system_class", org.jooq.impl.SQLDataType.VARCHAR, this); + + /** + * An uncommented item + */ + public final org.jooq.TableField PARTITIONED = createField("partitioned", org.jooq.impl.SQLDataType.VARCHAR, this); + + /** + * An uncommented item + */ + public final org.jooq.TableField IS_REUSE_OID_CLASS = createField("is_reuse_oid_class", org.jooq.impl.SQLDataType.VARCHAR, this); + + /** + * No further instances allowed + */ + private DbClass() { + super("db_class", org.jooq.util.cubrid.dba.Dba.DBA); + } + + /** + * No further instances allowed + */ + private DbClass(java.lang.String alias) { + super(alias, org.jooq.util.cubrid.dba.Dba.DBA, org.jooq.util.cubrid.dba.tables.DbClass.DB_CLASS); + } + + @Override + public org.jooq.util.cubrid.dba.tables.DbClass as(java.lang.String alias) { + return new org.jooq.util.cubrid.dba.tables.DbClass(alias); + } +} diff --git a/jOOQ-meta/src/main/java/org/jooq/util/cubrid/dba/tables/DbIndex.java b/jOOQ-meta/src/main/java/org/jooq/util/cubrid/dba/tables/DbIndex.java new file mode 100644 index 0000000000..ed890ba1ce --- /dev/null +++ b/jOOQ-meta/src/main/java/org/jooq/util/cubrid/dba/tables/DbIndex.java @@ -0,0 +1,86 @@ +/** + * This class is generated by jOOQ + */ +package org.jooq.util.cubrid.dba.tables; + +/** + * This class is generated by jOOQ. + */ +@javax.annotation.Generated(value = {"http://www.jooq.org", "2.1.0"}, + comments = "This class is generated by jOOQ") +public class DbIndex extends org.jooq.impl.TableImpl { + + private static final long serialVersionUID = 114806504; + + /** + * The singleton instance of DBA.db_index + */ + public static final org.jooq.util.cubrid.dba.tables.DbIndex DB_INDEX = new org.jooq.util.cubrid.dba.tables.DbIndex(); + + /** + * The class holding records for this type + */ + private static final java.lang.Class __RECORD_TYPE = org.jooq.Record.class; + + /** + * The class holding records for this type + */ + @Override + public java.lang.Class getRecordType() { + return __RECORD_TYPE; + } + + /** + * An uncommented item + */ + public final org.jooq.TableField INDEX_NAME = createField("index_name", org.jooq.impl.SQLDataType.VARCHAR, this); + + /** + * An uncommented item + */ + public final org.jooq.TableField IS_UNIQUE = createField("is_unique", org.jooq.impl.SQLDataType.VARCHAR, this); + + /** + * An uncommented item + */ + public final org.jooq.TableField IS_REVERSE = createField("is_reverse", org.jooq.impl.SQLDataType.VARCHAR, this); + + /** + * An uncommented item + */ + public final org.jooq.TableField CLASS_NAME = createField("class_name", org.jooq.impl.SQLDataType.VARCHAR, this); + + /** + * An uncommented item + */ + public final org.jooq.TableField KEY_COUNT = createField("key_count", org.jooq.impl.SQLDataType.INTEGER, this); + + /** + * An uncommented item + */ + public final org.jooq.TableField IS_PRIMARY_KEY = createField("is_primary_key", org.jooq.impl.SQLDataType.VARCHAR, this); + + /** + * An uncommented item + */ + public final org.jooq.TableField IS_FOREIGN_KEY = createField("is_foreign_key", org.jooq.impl.SQLDataType.VARCHAR, this); + + /** + * No further instances allowed + */ + private DbIndex() { + super("db_index", org.jooq.util.cubrid.dba.Dba.DBA); + } + + /** + * No further instances allowed + */ + private DbIndex(java.lang.String alias) { + super(alias, org.jooq.util.cubrid.dba.Dba.DBA, org.jooq.util.cubrid.dba.tables.DbIndex.DB_INDEX); + } + + @Override + public org.jooq.util.cubrid.dba.tables.DbIndex as(java.lang.String alias) { + return new org.jooq.util.cubrid.dba.tables.DbIndex(alias); + } +} diff --git a/jOOQ-meta/src/main/java/org/jooq/util/cubrid/dba/tables/DbIndexKey.java b/jOOQ-meta/src/main/java/org/jooq/util/cubrid/dba/tables/DbIndexKey.java new file mode 100644 index 0000000000..060b7ed374 --- /dev/null +++ b/jOOQ-meta/src/main/java/org/jooq/util/cubrid/dba/tables/DbIndexKey.java @@ -0,0 +1,81 @@ +/** + * This class is generated by jOOQ + */ +package org.jooq.util.cubrid.dba.tables; + +/** + * This class is generated by jOOQ. + */ +@javax.annotation.Generated(value = {"http://www.jooq.org", "2.1.0"}, + comments = "This class is generated by jOOQ") +public class DbIndexKey extends org.jooq.impl.TableImpl { + + private static final long serialVersionUID = -859845233; + + /** + * The singleton instance of DBA.db_index_key + */ + public static final org.jooq.util.cubrid.dba.tables.DbIndexKey DB_INDEX_KEY = new org.jooq.util.cubrid.dba.tables.DbIndexKey(); + + /** + * The class holding records for this type + */ + private static final java.lang.Class __RECORD_TYPE = org.jooq.Record.class; + + /** + * The class holding records for this type + */ + @Override + public java.lang.Class getRecordType() { + return __RECORD_TYPE; + } + + /** + * An uncommented item + */ + public final org.jooq.TableField INDEX_NAME = createField("index_name", org.jooq.impl.SQLDataType.VARCHAR, this); + + /** + * An uncommented item + */ + public final org.jooq.TableField CLASS_NAME = createField("class_name", org.jooq.impl.SQLDataType.VARCHAR, this); + + /** + * An uncommented item + */ + public final org.jooq.TableField KEY_ATTR_NAME = createField("key_attr_name", org.jooq.impl.SQLDataType.VARCHAR, this); + + /** + * An uncommented item + */ + public final org.jooq.TableField KEY_ORDER = createField("key_order", org.jooq.impl.SQLDataType.INTEGER, this); + + /** + * An uncommented item + */ + public final org.jooq.TableField ASC_DESC = createField("asc_desc", org.jooq.impl.SQLDataType.VARCHAR, this); + + /** + * An uncommented item + */ + public final org.jooq.TableField KEY_PREFIX_LENGTH = createField("key_prefix_length", org.jooq.impl.SQLDataType.INTEGER, this); + + /** + * No further instances allowed + */ + private DbIndexKey() { + super("db_index_key", org.jooq.util.cubrid.dba.Dba.DBA); + } + + /** + * No further instances allowed + */ + private DbIndexKey(java.lang.String alias) { + super(alias, org.jooq.util.cubrid.dba.Dba.DBA, org.jooq.util.cubrid.dba.tables.DbIndexKey.DB_INDEX_KEY); + } + + @Override + public org.jooq.util.cubrid.dba.tables.DbIndexKey as(java.lang.String alias) { + return new org.jooq.util.cubrid.dba.tables.DbIndexKey(alias); + } +} diff --git a/jOOQ-meta/src/main/java/org/jooq/util/cubrid/dba/tables/DbSerial.java b/jOOQ-meta/src/main/java/org/jooq/util/cubrid/dba/tables/DbSerial.java new file mode 100644 index 0000000000..1c5c78b44b --- /dev/null +++ b/jOOQ-meta/src/main/java/org/jooq/util/cubrid/dba/tables/DbSerial.java @@ -0,0 +1,111 @@ +/** + * This class is generated by jOOQ + */ +package org.jooq.util.cubrid.dba.tables; + +/** + * This class is generated by jOOQ. + */ +@javax.annotation.Generated(value = {"http://www.jooq.org", "2.1.0"}, + comments = "This class is generated by jOOQ") +public class DbSerial extends org.jooq.impl.TableImpl { + + private static final long serialVersionUID = -1925603367; + + /** + * The singleton instance of DBA.db_serial + */ + public static final org.jooq.util.cubrid.dba.tables.DbSerial DB_SERIAL = new org.jooq.util.cubrid.dba.tables.DbSerial(); + + /** + * The class holding records for this type + */ + private static final java.lang.Class __RECORD_TYPE = org.jooq.Record.class; + + /** + * The class holding records for this type + */ + @Override + public java.lang.Class getRecordType() { + return __RECORD_TYPE; + } + + /** + * An uncommented item + * + * PRIMARY KEY + */ + public final org.jooq.TableField NAME = createField("name", org.jooq.impl.SQLDataType.VARCHAR, this); + + /** + * An uncommented item + * + * The SQL type of this item (OBJECT) could not be mapped.
+ * Deserialising this field might not work! + */ + public final org.jooq.TableField OWNER = createField("owner", org.jooq.util.cubrid.CUBRIDDataType.getDefaultDataType("OBJECT"), this); + + /** + * An uncommented item + */ + public final org.jooq.TableField CURRENT_VAL = createField("current_val", org.jooq.impl.SQLDataType.DECIMAL_INTEGER, this); + + /** + * An uncommented item + */ + public final org.jooq.TableField INCREMENT_VAL = createField("increment_val", org.jooq.impl.SQLDataType.DECIMAL_INTEGER, this); + + /** + * An uncommented item + */ + public final org.jooq.TableField MAX_VAL = createField("max_val", org.jooq.impl.SQLDataType.DECIMAL_INTEGER, this); + + /** + * An uncommented item + */ + public final org.jooq.TableField MIN_VAL = createField("min_val", org.jooq.impl.SQLDataType.DECIMAL_INTEGER, this); + + /** + * An uncommented item + */ + public final org.jooq.TableField CYCLIC = createField("cyclic", org.jooq.impl.SQLDataType.INTEGER, this); + + /** + * An uncommented item + */ + public final org.jooq.TableField STARTED = createField("started", org.jooq.impl.SQLDataType.INTEGER, this); + + /** + * An uncommented item + */ + public final org.jooq.TableField CLASS_NAME = createField("class_name", org.jooq.impl.SQLDataType.VARCHAR, this); + + /** + * An uncommented item + */ + public final org.jooq.TableField ATT_NAME = createField("att_name", org.jooq.impl.SQLDataType.VARCHAR, this); + + /** + * An uncommented item + */ + public final org.jooq.TableField CACHED_NUM = createField("cached_num", org.jooq.impl.SQLDataType.INTEGER, this); + + /** + * No further instances allowed + */ + private DbSerial() { + super("db_serial", org.jooq.util.cubrid.dba.Dba.DBA); + } + + /** + * No further instances allowed + */ + private DbSerial(java.lang.String alias) { + super(alias, org.jooq.util.cubrid.dba.Dba.DBA, org.jooq.util.cubrid.dba.tables.DbSerial.DB_SERIAL); + } + + @Override + public org.jooq.util.cubrid.dba.tables.DbSerial as(java.lang.String alias) { + return new org.jooq.util.cubrid.dba.tables.DbSerial(alias); + } +} diff --git a/jOOQ-meta/src/main/java/org/jooq/util/oracle/OracleDatabase.java b/jOOQ-meta/src/main/java/org/jooq/util/oracle/OracleDatabase.java index 8e3b8240cd..1199fca8a3 100644 --- a/jOOQ-meta/src/main/java/org/jooq/util/oracle/OracleDatabase.java +++ b/jOOQ-meta/src/main/java/org/jooq/util/oracle/OracleDatabase.java @@ -52,7 +52,6 @@ import java.util.List; import org.jooq.Record; import org.jooq.impl.Factory; -import org.jooq.impl.SQLDataType; import org.jooq.util.AbstractDatabase; import org.jooq.util.ArrayDefinition; import org.jooq.util.ColumnDefinition; @@ -191,29 +190,13 @@ public class OracleDatabase extends AbstractDatabase { ALL_SEQUENCES.SEQUENCE_NAME) .fetch()) { - DataTypeDefinition type; SchemaDefinition schema = getSchema(record.getValue(ALL_SEQUENCES.SEQUENCE_OWNER)); BigInteger value = record.getValue(ALL_SEQUENCES.MAX_VALUE, BigInteger.class, BigInteger.valueOf(Long.MAX_VALUE)); - - if (BigInteger.valueOf(Byte.MAX_VALUE).compareTo(value) >= 0) { - type = new DefaultDataTypeDefinition(this, schema, SQLDataType.NUMERIC.getTypeName(), 0, 2, 0); - } - else if (BigInteger.valueOf(Short.MAX_VALUE).compareTo(value) >= 0) { - type = new DefaultDataTypeDefinition(this, schema, SQLDataType.NUMERIC.getTypeName(), 0, 4, 0); - } - else if (BigInteger.valueOf(Integer.MAX_VALUE).compareTo(value) >= 0) { - type = new DefaultDataTypeDefinition(this, schema, SQLDataType.NUMERIC.getTypeName(), 0, 9, 0); - } - else if (BigInteger.valueOf(Long.MAX_VALUE).compareTo(value) >= 0) { - type = new DefaultDataTypeDefinition(this, schema, SQLDataType.NUMERIC.getTypeName(), 0, 18, 0); - } - else { - type = new DefaultDataTypeDefinition(this, schema, SQLDataType.NUMERIC.getTypeName(), 0, 38, 0); - } + DataTypeDefinition type = getDataTypeForMAX_VAL(schema, value); result.add(new DefaultSequenceDefinition( - getSchema(record.getValue(ALL_SEQUENCES.SEQUENCE_OWNER)), + schema, record.getValue(ALL_SEQUENCES.SEQUENCE_NAME), type)); } diff --git a/jOOQ-test/configuration/org/jooq/configuration/lukas/cubrid/dba.xml b/jOOQ-test/configuration/org/jooq/configuration/lukas/cubrid/dba.xml new file mode 100644 index 0000000000..74f1c1513d --- /dev/null +++ b/jOOQ-test/configuration/org/jooq/configuration/lukas/cubrid/dba.xml @@ -0,0 +1,28 @@ + + + + cubrid.jdbc.driver.CUBRIDDriver + jdbc:cubrid:localhost:33000:demodb::: + dba + + + + org.jooq.util.DefaultGenerator + + org.jooq.util.cubrid.CUBRIDDatabase + db_class,db_attribute,db_index,db_index_key,db_serial + + DBA + + + false + true + true + false + + + org.jooq.util.cubrid.dba + ./src/main/java + + + \ No newline at end of file diff --git a/jOOQ-test/configuration/org/jooq/configuration/lukas/cubrid/demodb.xml b/jOOQ-test/configuration/org/jooq/configuration/lukas/cubrid/demodb.xml new file mode 100644 index 0000000000..3ca823d840 --- /dev/null +++ b/jOOQ-test/configuration/org/jooq/configuration/lukas/cubrid/demodb.xml @@ -0,0 +1,34 @@ + + + + cubrid.jdbc.driver.CUBRIDDriver + jdbc:cubrid:localhost:33000:demodb::: + PUBLIC + dba + + + + org.jooq.util.DefaultGenerator + + org.jooq.util.cubrid.CUBRIDDatabase + .* + + false + true + + + true + true + true + true + false + true + true + true + + + org.jooq.examples.cubrid.demodb + ./examples + + + \ No newline at end of file diff --git a/jOOQ-test/examples/org/jooq/examples/cubrid/demodb/Keys.java b/jOOQ-test/examples/org/jooq/examples/cubrid/demodb/Keys.java new file mode 100644 index 0000000000..749b02f16a --- /dev/null +++ b/jOOQ-test/examples/org/jooq/examples/cubrid/demodb/Keys.java @@ -0,0 +1,34 @@ +/** + * This class is generated by jOOQ + */ +package org.jooq.examples.cubrid.demodb; + +/** + * This class is generated by jOOQ. + * + * A class modelling foreign key relationships between tables of the PUBLIC schema + */ +@SuppressWarnings({"unchecked"}) +public class Keys extends org.jooq.impl.AbstractKeys { + + // IDENTITY definitions + public static final org.jooq.Identity IDENTITY_ATHLETE = createIdentity(org.jooq.examples.cubrid.demodb.tables.Athlete.ATHLETE, org.jooq.examples.cubrid.demodb.tables.Athlete.ATHLETE.CODE); + + // UNIQUE and PRIMARY KEY definitions + public static final org.jooq.UniqueKey PK_ATHLETE_CODE = createUniqueKey(org.jooq.examples.cubrid.demodb.tables.Athlete.ATHLETE, org.jooq.examples.cubrid.demodb.tables.Athlete.ATHLETE.CODE); + public static final org.jooq.UniqueKey PK_EVENT_CODE = createUniqueKey(org.jooq.examples.cubrid.demodb.tables.Event.EVENT, org.jooq.examples.cubrid.demodb.tables.Event.EVENT.CODE); + public static final org.jooq.UniqueKey PK_GAME_HOST_YEAR_EVENT_CODE_ATHLETE_CODE = createUniqueKey(org.jooq.examples.cubrid.demodb.tables.Game.GAME, org.jooq.examples.cubrid.demodb.tables.Game.GAME.HOST_YEAR, org.jooq.examples.cubrid.demodb.tables.Game.GAME.EVENT_CODE, org.jooq.examples.cubrid.demodb.tables.Game.GAME.ATHLETE_CODE); + public static final org.jooq.UniqueKey PK_HISTORY_EVENT_CODE_ATHLETE = createUniqueKey(org.jooq.examples.cubrid.demodb.tables.History.HISTORY, org.jooq.examples.cubrid.demodb.tables.History.HISTORY.EVENT_CODE, org.jooq.examples.cubrid.demodb.tables.History.HISTORY.ATHLETE); + public static final org.jooq.UniqueKey PK_NATION_CODE = createUniqueKey(org.jooq.examples.cubrid.demodb.tables.Nation.NATION, org.jooq.examples.cubrid.demodb.tables.Nation.NATION.CODE); + public static final org.jooq.UniqueKey PK_OLYMPIC_HOST_YEAR = createUniqueKey(org.jooq.examples.cubrid.demodb.tables.Olympic.OLYMPIC, org.jooq.examples.cubrid.demodb.tables.Olympic.OLYMPIC.HOST_YEAR); + public static final org.jooq.UniqueKey PK_PARTICIPANT_HOST_YEAR_NATION_CODE = createUniqueKey(org.jooq.examples.cubrid.demodb.tables.Participant.PARTICIPANT, org.jooq.examples.cubrid.demodb.tables.Participant.PARTICIPANT.HOST_YEAR, org.jooq.examples.cubrid.demodb.tables.Participant.PARTICIPANT.NATION_CODE); + public static final org.jooq.UniqueKey PK_RECORD_HOST_YEAR_EVENT_CODE_ATHLETE_CODE_MEDAL = createUniqueKey(org.jooq.examples.cubrid.demodb.tables.Record.RECORD, org.jooq.examples.cubrid.demodb.tables.Record.RECORD.HOST_YEAR, org.jooq.examples.cubrid.demodb.tables.Record.RECORD.EVENT_CODE, org.jooq.examples.cubrid.demodb.tables.Record.RECORD.ATHLETE_CODE, org.jooq.examples.cubrid.demodb.tables.Record.RECORD.MEDAL); + public static final org.jooq.UniqueKey PK_STADIUM_CODE = createUniqueKey(org.jooq.examples.cubrid.demodb.tables.Stadium.STADIUM, org.jooq.examples.cubrid.demodb.tables.Stadium.STADIUM.CODE); + + // FOREIGN KEY definitions + + /** + * No instances + */ + private Keys() {} +} diff --git a/jOOQ-test/examples/org/jooq/examples/cubrid/demodb/Public.java b/jOOQ-test/examples/org/jooq/examples/cubrid/demodb/Public.java new file mode 100644 index 0000000000..00abd9cd55 --- /dev/null +++ b/jOOQ-test/examples/org/jooq/examples/cubrid/demodb/Public.java @@ -0,0 +1,47 @@ +/** + * This class is generated by jOOQ + */ +package org.jooq.examples.cubrid.demodb; + +/** + * This class is generated by jOOQ. + */ +public class Public extends org.jooq.impl.SchemaImpl { + + private static final long serialVersionUID = 1687384670; + + /** + * The singleton instance of PUBLIC + */ + public static final Public PUBLIC = new Public(); + + /** + * No further instances allowed + */ + private Public() { + super("PUBLIC"); + } + + @Override + public final java.util.List> getSequences() { + return java.util.Arrays.>asList( + org.jooq.examples.cubrid.demodb.Sequences.EVENT_NO, + org.jooq.examples.cubrid.demodb.Sequences.STADIUM_NO, + org.jooq.examples.cubrid.demodb.Sequences.ATHLETE_AI_CODE); + } + + @Override + public final java.util.List> getTables() { + return java.util.Arrays.>asList( + org.jooq.examples.cubrid.demodb.tables.Athlete.ATHLETE, + org.jooq.examples.cubrid.demodb.tables.Code.CODE, + org.jooq.examples.cubrid.demodb.tables.Event.EVENT, + org.jooq.examples.cubrid.demodb.tables.Game.GAME, + org.jooq.examples.cubrid.demodb.tables.History.HISTORY, + org.jooq.examples.cubrid.demodb.tables.Nation.NATION, + org.jooq.examples.cubrid.demodb.tables.Olympic.OLYMPIC, + org.jooq.examples.cubrid.demodb.tables.Participant.PARTICIPANT, + org.jooq.examples.cubrid.demodb.tables.Record.RECORD, + org.jooq.examples.cubrid.demodb.tables.Stadium.STADIUM); + } +} diff --git a/jOOQ-test/examples/org/jooq/examples/cubrid/demodb/PublicFactory.java b/jOOQ-test/examples/org/jooq/examples/cubrid/demodb/PublicFactory.java new file mode 100644 index 0000000000..53943f18ed --- /dev/null +++ b/jOOQ-test/examples/org/jooq/examples/cubrid/demodb/PublicFactory.java @@ -0,0 +1,41 @@ +/** + * This class is generated by jOOQ + */ +package org.jooq.examples.cubrid.demodb; + +/** + * This class is generated by jOOQ. + */ +public class PublicFactory extends org.jooq.util.ase.ASEFactory { + + private static final long serialVersionUID = -1645861218; + + /** + * Create a factory with a connection + * + * @param connection The connection to use with objects created from this factory + */ + public PublicFactory(java.sql.Connection connection) { + super(connection); + } + + /** + * Create a factory with a connection and a schema mapping + * + * @deprecated - 2.0.5 - Use {@link #PublicFactory(java.sql.Connection, org.jooq.conf.Settings)} instead + */ + @Deprecated + public PublicFactory(java.sql.Connection connection, org.jooq.SchemaMapping mapping) { + super(connection, mapping); + } + + /** + * Create a factory with a connection and some settings + * + * @param connection The connection to use with objects created from this factory + * @param settings The settings to apply to objects created from this factory + */ + public PublicFactory(java.sql.Connection connection, org.jooq.conf.Settings settings) { + super(connection, settings); + } +} diff --git a/jOOQ-test/examples/org/jooq/examples/cubrid/demodb/Sequences.java b/jOOQ-test/examples/org/jooq/examples/cubrid/demodb/Sequences.java new file mode 100644 index 0000000000..ef6d784ca1 --- /dev/null +++ b/jOOQ-test/examples/org/jooq/examples/cubrid/demodb/Sequences.java @@ -0,0 +1,32 @@ +/** + * This class is generated by jOOQ + */ +package org.jooq.examples.cubrid.demodb; + +/** + * This class is generated by jOOQ. + * + * Convenience access to all sequences in PUBLIC + */ +public final class Sequences { + + /** + * The sequence PUBLIC.event_no + */ + public static final org.jooq.Sequence EVENT_NO = new org.jooq.impl.SequenceImpl("event_no", org.jooq.examples.cubrid.demodb.Public.PUBLIC, org.jooq.impl.SQLDataType.DECIMAL_INTEGER); + + /** + * The sequence PUBLIC.stadium_no + */ + public static final org.jooq.Sequence STADIUM_NO = new org.jooq.impl.SequenceImpl("stadium_no", org.jooq.examples.cubrid.demodb.Public.PUBLIC, org.jooq.impl.SQLDataType.DECIMAL_INTEGER); + + /** + * The sequence PUBLIC.athlete_ai_code + */ + public static final org.jooq.Sequence ATHLETE_AI_CODE = new org.jooq.impl.SequenceImpl("athlete_ai_code", org.jooq.examples.cubrid.demodb.Public.PUBLIC, org.jooq.impl.SQLDataType.INTEGER); + + /** + * No instances + */ + private Sequences() {} +} diff --git a/jOOQ-test/examples/org/jooq/examples/cubrid/demodb/Tables.java b/jOOQ-test/examples/org/jooq/examples/cubrid/demodb/Tables.java new file mode 100644 index 0000000000..630a4ae455 --- /dev/null +++ b/jOOQ-test/examples/org/jooq/examples/cubrid/demodb/Tables.java @@ -0,0 +1,67 @@ +/** + * This class is generated by jOOQ + */ +package org.jooq.examples.cubrid.demodb; + +/** + * This class is generated by jOOQ. + * + * Convenience access to all tables in PUBLIC + */ +public final class Tables { + + /** + * The table PUBLIC.athlete + */ + public static org.jooq.examples.cubrid.demodb.tables.Athlete ATHLETE = org.jooq.examples.cubrid.demodb.tables.Athlete.ATHLETE; + + /** + * The table PUBLIC.code + */ + public static org.jooq.examples.cubrid.demodb.tables.Code CODE = org.jooq.examples.cubrid.demodb.tables.Code.CODE; + + /** + * The table PUBLIC.event + */ + public static org.jooq.examples.cubrid.demodb.tables.Event EVENT = org.jooq.examples.cubrid.demodb.tables.Event.EVENT; + + /** + * The table PUBLIC.game + */ + public static org.jooq.examples.cubrid.demodb.tables.Game GAME = org.jooq.examples.cubrid.demodb.tables.Game.GAME; + + /** + * The table PUBLIC.history + */ + public static org.jooq.examples.cubrid.demodb.tables.History HISTORY = org.jooq.examples.cubrid.demodb.tables.History.HISTORY; + + /** + * The table PUBLIC.nation + */ + public static org.jooq.examples.cubrid.demodb.tables.Nation NATION = org.jooq.examples.cubrid.demodb.tables.Nation.NATION; + + /** + * The table PUBLIC.olympic + */ + public static org.jooq.examples.cubrid.demodb.tables.Olympic OLYMPIC = org.jooq.examples.cubrid.demodb.tables.Olympic.OLYMPIC; + + /** + * The table PUBLIC.participant + */ + public static org.jooq.examples.cubrid.demodb.tables.Participant PARTICIPANT = org.jooq.examples.cubrid.demodb.tables.Participant.PARTICIPANT; + + /** + * The table PUBLIC.record + */ + public static org.jooq.examples.cubrid.demodb.tables.Record RECORD = org.jooq.examples.cubrid.demodb.tables.Record.RECORD; + + /** + * The table PUBLIC.stadium + */ + public static org.jooq.examples.cubrid.demodb.tables.Stadium STADIUM = org.jooq.examples.cubrid.demodb.tables.Stadium.STADIUM; + + /** + * No instances + */ + private Tables() {} +} diff --git a/jOOQ-test/examples/org/jooq/examples/cubrid/demodb/tables/Athlete.java b/jOOQ-test/examples/org/jooq/examples/cubrid/demodb/tables/Athlete.java new file mode 100644 index 0000000000..f32569b672 --- /dev/null +++ b/jOOQ-test/examples/org/jooq/examples/cubrid/demodb/tables/Athlete.java @@ -0,0 +1,92 @@ +/** + * This class is generated by jOOQ + */ +package org.jooq.examples.cubrid.demodb.tables; + +/** + * This class is generated by jOOQ. + */ +public class Athlete extends org.jooq.impl.UpdatableTableImpl { + + private static final long serialVersionUID = 1949978925; + + /** + * The singleton instance of PUBLIC.athlete + */ + public static final org.jooq.examples.cubrid.demodb.tables.Athlete ATHLETE = new org.jooq.examples.cubrid.demodb.tables.Athlete(); + + /** + * The class holding records for this type + */ + private static final java.lang.Class __RECORD_TYPE = org.jooq.examples.cubrid.demodb.tables.records.AthleteRecord.class; + + /** + * The class holding records for this type + */ + @Override + public java.lang.Class getRecordType() { + return __RECORD_TYPE; + } + + /** + * An uncommented item + * + * PRIMARY KEY + */ + public final org.jooq.TableField CODE = createField("code", org.jooq.impl.SQLDataType.INTEGER, this); + + /** + * An uncommented item + */ + public final org.jooq.TableField NAME = createField("name", org.jooq.impl.SQLDataType.VARCHAR, this); + + /** + * An uncommented item + */ + public final org.jooq.TableField GENDER = createField("gender", org.jooq.impl.SQLDataType.CHAR, this); + + /** + * An uncommented item + */ + public final org.jooq.TableField NATION_CODE = createField("nation_code", org.jooq.impl.SQLDataType.CHAR, this); + + /** + * An uncommented item + */ + public final org.jooq.TableField EVENT = createField("event", org.jooq.impl.SQLDataType.VARCHAR, this); + + /** + * No further instances allowed + */ + private Athlete() { + super("athlete", org.jooq.examples.cubrid.demodb.Public.PUBLIC); + } + + /** + * No further instances allowed + */ + private Athlete(java.lang.String alias) { + super(alias, org.jooq.examples.cubrid.demodb.Public.PUBLIC, org.jooq.examples.cubrid.demodb.tables.Athlete.ATHLETE); + } + + @Override + public org.jooq.Identity getIdentity() { + return org.jooq.examples.cubrid.demodb.Keys.IDENTITY_ATHLETE; + } + + @Override + public org.jooq.UniqueKey getMainKey() { + return org.jooq.examples.cubrid.demodb.Keys.PK_ATHLETE_CODE; + } + + @Override + @SuppressWarnings("unchecked") + public java.util.List> getKeys() { + return java.util.Arrays.>asList(org.jooq.examples.cubrid.demodb.Keys.PK_ATHLETE_CODE); + } + + @Override + public org.jooq.examples.cubrid.demodb.tables.Athlete as(java.lang.String alias) { + return new org.jooq.examples.cubrid.demodb.tables.Athlete(alias); + } +} diff --git a/jOOQ-test/examples/org/jooq/examples/cubrid/demodb/tables/Code.java b/jOOQ-test/examples/org/jooq/examples/cubrid/demodb/tables/Code.java new file mode 100644 index 0000000000..e15d78c320 --- /dev/null +++ b/jOOQ-test/examples/org/jooq/examples/cubrid/demodb/tables/Code.java @@ -0,0 +1,59 @@ +/** + * This class is generated by jOOQ + */ +package org.jooq.examples.cubrid.demodb.tables; + +/** + * This class is generated by jOOQ. + */ +public class Code extends org.jooq.impl.TableImpl { + + private static final long serialVersionUID = -1111681184; + + /** + * The singleton instance of PUBLIC.code + */ + public static final org.jooq.examples.cubrid.demodb.tables.Code CODE = new org.jooq.examples.cubrid.demodb.tables.Code(); + + /** + * The class holding records for this type + */ + private static final java.lang.Class __RECORD_TYPE = org.jooq.examples.cubrid.demodb.tables.records.CodeRecord.class; + + /** + * The class holding records for this type + */ + @Override + public java.lang.Class getRecordType() { + return __RECORD_TYPE; + } + + /** + * An uncommented item + */ + public final org.jooq.TableField S_NAME = createField("s_name", org.jooq.impl.SQLDataType.CHAR, this); + + /** + * An uncommented item + */ + public final org.jooq.TableField F_NAME = createField("f_name", org.jooq.impl.SQLDataType.VARCHAR, this); + + /** + * No further instances allowed + */ + private Code() { + super("code", org.jooq.examples.cubrid.demodb.Public.PUBLIC); + } + + /** + * No further instances allowed + */ + private Code(java.lang.String alias) { + super(alias, org.jooq.examples.cubrid.demodb.Public.PUBLIC, org.jooq.examples.cubrid.demodb.tables.Code.CODE); + } + + @Override + public org.jooq.examples.cubrid.demodb.tables.Code as(java.lang.String alias) { + return new org.jooq.examples.cubrid.demodb.tables.Code(alias); + } +} diff --git a/jOOQ-test/examples/org/jooq/examples/cubrid/demodb/tables/Event.java b/jOOQ-test/examples/org/jooq/examples/cubrid/demodb/tables/Event.java new file mode 100644 index 0000000000..17fa86fb4f --- /dev/null +++ b/jOOQ-test/examples/org/jooq/examples/cubrid/demodb/tables/Event.java @@ -0,0 +1,87 @@ +/** + * This class is generated by jOOQ + */ +package org.jooq.examples.cubrid.demodb.tables; + +/** + * This class is generated by jOOQ. + */ +public class Event extends org.jooq.impl.UpdatableTableImpl { + + private static final long serialVersionUID = -1544702914; + + /** + * The singleton instance of PUBLIC.event + */ + public static final org.jooq.examples.cubrid.demodb.tables.Event EVENT = new org.jooq.examples.cubrid.demodb.tables.Event(); + + /** + * The class holding records for this type + */ + private static final java.lang.Class __RECORD_TYPE = org.jooq.examples.cubrid.demodb.tables.records.EventRecord.class; + + /** + * The class holding records for this type + */ + @Override + public java.lang.Class getRecordType() { + return __RECORD_TYPE; + } + + /** + * An uncommented item + * + * PRIMARY KEY + */ + public final org.jooq.TableField CODE = createField("code", org.jooq.impl.SQLDataType.INTEGER, this); + + /** + * An uncommented item + */ + public final org.jooq.TableField SPORTS = createField("sports", org.jooq.impl.SQLDataType.VARCHAR, this); + + /** + * An uncommented item + */ + public final org.jooq.TableField NAME = createField("name", org.jooq.impl.SQLDataType.VARCHAR, this); + + /** + * An uncommented item + */ + public final org.jooq.TableField GENDER = createField("gender", org.jooq.impl.SQLDataType.CHAR, this); + + /** + * An uncommented item + */ + public final org.jooq.TableField PLAYERS = createField("players", org.jooq.impl.SQLDataType.INTEGER, this); + + /** + * No further instances allowed + */ + private Event() { + super("event", org.jooq.examples.cubrid.demodb.Public.PUBLIC); + } + + /** + * No further instances allowed + */ + private Event(java.lang.String alias) { + super(alias, org.jooq.examples.cubrid.demodb.Public.PUBLIC, org.jooq.examples.cubrid.demodb.tables.Event.EVENT); + } + + @Override + public org.jooq.UniqueKey getMainKey() { + return org.jooq.examples.cubrid.demodb.Keys.PK_EVENT_CODE; + } + + @Override + @SuppressWarnings("unchecked") + public java.util.List> getKeys() { + return java.util.Arrays.>asList(org.jooq.examples.cubrid.demodb.Keys.PK_EVENT_CODE); + } + + @Override + public org.jooq.examples.cubrid.demodb.tables.Event as(java.lang.String alias) { + return new org.jooq.examples.cubrid.demodb.tables.Event(alias); + } +} diff --git a/jOOQ-test/examples/org/jooq/examples/cubrid/demodb/tables/Game.java b/jOOQ-test/examples/org/jooq/examples/cubrid/demodb/tables/Game.java new file mode 100644 index 0000000000..a8161df70a --- /dev/null +++ b/jOOQ-test/examples/org/jooq/examples/cubrid/demodb/tables/Game.java @@ -0,0 +1,101 @@ +/** + * This class is generated by jOOQ + */ +package org.jooq.examples.cubrid.demodb.tables; + +/** + * This class is generated by jOOQ. + */ +public class Game extends org.jooq.impl.UpdatableTableImpl { + + private static final long serialVersionUID = 1253356251; + + /** + * The singleton instance of PUBLIC.game + */ + public static final org.jooq.examples.cubrid.demodb.tables.Game GAME = new org.jooq.examples.cubrid.demodb.tables.Game(); + + /** + * The class holding records for this type + */ + private static final java.lang.Class __RECORD_TYPE = org.jooq.examples.cubrid.demodb.tables.records.GameRecord.class; + + /** + * The class holding records for this type + */ + @Override + public java.lang.Class getRecordType() { + return __RECORD_TYPE; + } + + /** + * An uncommented item + * + * PRIMARY KEY + */ + public final org.jooq.TableField HOST_YEAR = createField("host_year", org.jooq.impl.SQLDataType.INTEGER, this); + + /** + * An uncommented item + * + * PRIMARY KEY + */ + public final org.jooq.TableField EVENT_CODE = createField("event_code", org.jooq.impl.SQLDataType.INTEGER, this); + + /** + * An uncommented item + * + * PRIMARY KEY + */ + public final org.jooq.TableField ATHLETE_CODE = createField("athlete_code", org.jooq.impl.SQLDataType.INTEGER, this); + + /** + * An uncommented item + */ + public final org.jooq.TableField STADIUM_CODE = createField("stadium_code", org.jooq.impl.SQLDataType.INTEGER, this); + + /** + * An uncommented item + */ + public final org.jooq.TableField NATION_CODE = createField("nation_code", org.jooq.impl.SQLDataType.CHAR, this); + + /** + * An uncommented item + */ + public final org.jooq.TableField MEDAL = createField("medal", org.jooq.impl.SQLDataType.CHAR, this); + + /** + * An uncommented item + */ + public final org.jooq.TableField GAME_DATE = createField("game_date", org.jooq.impl.SQLDataType.DATE, this); + + /** + * No further instances allowed + */ + private Game() { + super("game", org.jooq.examples.cubrid.demodb.Public.PUBLIC); + } + + /** + * No further instances allowed + */ + private Game(java.lang.String alias) { + super(alias, org.jooq.examples.cubrid.demodb.Public.PUBLIC, org.jooq.examples.cubrid.demodb.tables.Game.GAME); + } + + @Override + public org.jooq.UniqueKey getMainKey() { + return org.jooq.examples.cubrid.demodb.Keys.PK_GAME_HOST_YEAR_EVENT_CODE_ATHLETE_CODE; + } + + @Override + @SuppressWarnings("unchecked") + public java.util.List> getKeys() { + return java.util.Arrays.>asList(org.jooq.examples.cubrid.demodb.Keys.PK_GAME_HOST_YEAR_EVENT_CODE_ATHLETE_CODE); + } + + @Override + public org.jooq.examples.cubrid.demodb.tables.Game as(java.lang.String alias) { + return new org.jooq.examples.cubrid.demodb.tables.Game(alias); + } +} diff --git a/jOOQ-test/examples/org/jooq/examples/cubrid/demodb/tables/History.java b/jOOQ-test/examples/org/jooq/examples/cubrid/demodb/tables/History.java new file mode 100644 index 0000000000..bd603eb2ac --- /dev/null +++ b/jOOQ-test/examples/org/jooq/examples/cubrid/demodb/tables/History.java @@ -0,0 +1,89 @@ +/** + * This class is generated by jOOQ + */ +package org.jooq.examples.cubrid.demodb.tables; + +/** + * This class is generated by jOOQ. + */ +public class History extends org.jooq.impl.UpdatableTableImpl { + + private static final long serialVersionUID = -217390322; + + /** + * The singleton instance of PUBLIC.history + */ + public static final org.jooq.examples.cubrid.demodb.tables.History HISTORY = new org.jooq.examples.cubrid.demodb.tables.History(); + + /** + * The class holding records for this type + */ + private static final java.lang.Class __RECORD_TYPE = org.jooq.examples.cubrid.demodb.tables.records.HistoryRecord.class; + + /** + * The class holding records for this type + */ + @Override + public java.lang.Class getRecordType() { + return __RECORD_TYPE; + } + + /** + * An uncommented item + * + * PRIMARY KEY + */ + public final org.jooq.TableField EVENT_CODE = createField("event_code", org.jooq.impl.SQLDataType.INTEGER, this); + + /** + * An uncommented item + * + * PRIMARY KEY + */ + public final org.jooq.TableField ATHLETE = createField("athlete", org.jooq.impl.SQLDataType.VARCHAR, this); + + /** + * An uncommented item + */ + public final org.jooq.TableField HOST_YEAR = createField("host_year", org.jooq.impl.SQLDataType.INTEGER, this); + + /** + * An uncommented item + */ + public final org.jooq.TableField SCORE = createField("score", org.jooq.impl.SQLDataType.VARCHAR, this); + + /** + * An uncommented item + */ + public final org.jooq.TableField UNIT = createField("unit", org.jooq.impl.SQLDataType.VARCHAR, this); + + /** + * No further instances allowed + */ + private History() { + super("history", org.jooq.examples.cubrid.demodb.Public.PUBLIC); + } + + /** + * No further instances allowed + */ + private History(java.lang.String alias) { + super(alias, org.jooq.examples.cubrid.demodb.Public.PUBLIC, org.jooq.examples.cubrid.demodb.tables.History.HISTORY); + } + + @Override + public org.jooq.UniqueKey getMainKey() { + return org.jooq.examples.cubrid.demodb.Keys.PK_HISTORY_EVENT_CODE_ATHLETE; + } + + @Override + @SuppressWarnings("unchecked") + public java.util.List> getKeys() { + return java.util.Arrays.>asList(org.jooq.examples.cubrid.demodb.Keys.PK_HISTORY_EVENT_CODE_ATHLETE); + } + + @Override + public org.jooq.examples.cubrid.demodb.tables.History as(java.lang.String alias) { + return new org.jooq.examples.cubrid.demodb.tables.History(alias); + } +} diff --git a/jOOQ-test/examples/org/jooq/examples/cubrid/demodb/tables/Nation.java b/jOOQ-test/examples/org/jooq/examples/cubrid/demodb/tables/Nation.java new file mode 100644 index 0000000000..3bdfe675ee --- /dev/null +++ b/jOOQ-test/examples/org/jooq/examples/cubrid/demodb/tables/Nation.java @@ -0,0 +1,82 @@ +/** + * This class is generated by jOOQ + */ +package org.jooq.examples.cubrid.demodb.tables; + +/** + * This class is generated by jOOQ. + */ +public class Nation extends org.jooq.impl.UpdatableTableImpl { + + private static final long serialVersionUID = -480563514; + + /** + * The singleton instance of PUBLIC.nation + */ + public static final org.jooq.examples.cubrid.demodb.tables.Nation NATION = new org.jooq.examples.cubrid.demodb.tables.Nation(); + + /** + * The class holding records for this type + */ + private static final java.lang.Class __RECORD_TYPE = org.jooq.examples.cubrid.demodb.tables.records.NationRecord.class; + + /** + * The class holding records for this type + */ + @Override + public java.lang.Class getRecordType() { + return __RECORD_TYPE; + } + + /** + * An uncommented item + * + * PRIMARY KEY + */ + public final org.jooq.TableField CODE = createField("code", org.jooq.impl.SQLDataType.CHAR, this); + + /** + * An uncommented item + */ + public final org.jooq.TableField NAME = createField("name", org.jooq.impl.SQLDataType.VARCHAR, this); + + /** + * An uncommented item + */ + public final org.jooq.TableField CONTINENT = createField("continent", org.jooq.impl.SQLDataType.VARCHAR, this); + + /** + * An uncommented item + */ + public final org.jooq.TableField CAPITAL = createField("capital", org.jooq.impl.SQLDataType.VARCHAR, this); + + /** + * No further instances allowed + */ + private Nation() { + super("nation", org.jooq.examples.cubrid.demodb.Public.PUBLIC); + } + + /** + * No further instances allowed + */ + private Nation(java.lang.String alias) { + super(alias, org.jooq.examples.cubrid.demodb.Public.PUBLIC, org.jooq.examples.cubrid.demodb.tables.Nation.NATION); + } + + @Override + public org.jooq.UniqueKey getMainKey() { + return org.jooq.examples.cubrid.demodb.Keys.PK_NATION_CODE; + } + + @Override + @SuppressWarnings("unchecked") + public java.util.List> getKeys() { + return java.util.Arrays.>asList(org.jooq.examples.cubrid.demodb.Keys.PK_NATION_CODE); + } + + @Override + public org.jooq.examples.cubrid.demodb.tables.Nation as(java.lang.String alias) { + return new org.jooq.examples.cubrid.demodb.tables.Nation(alias); + } +} diff --git a/jOOQ-test/examples/org/jooq/examples/cubrid/demodb/tables/Olympic.java b/jOOQ-test/examples/org/jooq/examples/cubrid/demodb/tables/Olympic.java new file mode 100644 index 0000000000..5214160636 --- /dev/null +++ b/jOOQ-test/examples/org/jooq/examples/cubrid/demodb/tables/Olympic.java @@ -0,0 +1,102 @@ +/** + * This class is generated by jOOQ + */ +package org.jooq.examples.cubrid.demodb.tables; + +/** + * This class is generated by jOOQ. + */ +public class Olympic extends org.jooq.impl.UpdatableTableImpl { + + private static final long serialVersionUID = 1565507859; + + /** + * The singleton instance of PUBLIC.olympic + */ + public static final org.jooq.examples.cubrid.demodb.tables.Olympic OLYMPIC = new org.jooq.examples.cubrid.demodb.tables.Olympic(); + + /** + * The class holding records for this type + */ + private static final java.lang.Class __RECORD_TYPE = org.jooq.examples.cubrid.demodb.tables.records.OlympicRecord.class; + + /** + * The class holding records for this type + */ + @Override + public java.lang.Class getRecordType() { + return __RECORD_TYPE; + } + + /** + * An uncommented item + * + * PRIMARY KEY + */ + public final org.jooq.TableField HOST_YEAR = createField("host_year", org.jooq.impl.SQLDataType.INTEGER, this); + + /** + * An uncommented item + */ + public final org.jooq.TableField HOST_NATION = createField("host_nation", org.jooq.impl.SQLDataType.VARCHAR, this); + + /** + * An uncommented item + */ + public final org.jooq.TableField HOST_CITY = createField("host_city", org.jooq.impl.SQLDataType.VARCHAR, this); + + /** + * An uncommented item + */ + public final org.jooq.TableField OPENING_DATE = createField("opening_date", org.jooq.impl.SQLDataType.DATE, this); + + /** + * An uncommented item + */ + public final org.jooq.TableField CLOSING_DATE = createField("closing_date", org.jooq.impl.SQLDataType.DATE, this); + + /** + * An uncommented item + */ + public final org.jooq.TableField MASCOT = createField("mascot", org.jooq.impl.SQLDataType.VARCHAR, this); + + /** + * An uncommented item + */ + public final org.jooq.TableField SLOGAN = createField("slogan", org.jooq.impl.SQLDataType.VARCHAR, this); + + /** + * An uncommented item + */ + public final org.jooq.TableField INTRODUCTION = createField("introduction", org.jooq.impl.SQLDataType.VARCHAR, this); + + /** + * No further instances allowed + */ + private Olympic() { + super("olympic", org.jooq.examples.cubrid.demodb.Public.PUBLIC); + } + + /** + * No further instances allowed + */ + private Olympic(java.lang.String alias) { + super(alias, org.jooq.examples.cubrid.demodb.Public.PUBLIC, org.jooq.examples.cubrid.demodb.tables.Olympic.OLYMPIC); + } + + @Override + public org.jooq.UniqueKey getMainKey() { + return org.jooq.examples.cubrid.demodb.Keys.PK_OLYMPIC_HOST_YEAR; + } + + @Override + @SuppressWarnings("unchecked") + public java.util.List> getKeys() { + return java.util.Arrays.>asList(org.jooq.examples.cubrid.demodb.Keys.PK_OLYMPIC_HOST_YEAR); + } + + @Override + public org.jooq.examples.cubrid.demodb.tables.Olympic as(java.lang.String alias) { + return new org.jooq.examples.cubrid.demodb.tables.Olympic(alias); + } +} diff --git a/jOOQ-test/examples/org/jooq/examples/cubrid/demodb/tables/Participant.java b/jOOQ-test/examples/org/jooq/examples/cubrid/demodb/tables/Participant.java new file mode 100644 index 0000000000..ffc8b9a829 --- /dev/null +++ b/jOOQ-test/examples/org/jooq/examples/cubrid/demodb/tables/Participant.java @@ -0,0 +1,89 @@ +/** + * This class is generated by jOOQ + */ +package org.jooq.examples.cubrid.demodb.tables; + +/** + * This class is generated by jOOQ. + */ +public class Participant extends org.jooq.impl.UpdatableTableImpl { + + private static final long serialVersionUID = -914586083; + + /** + * The singleton instance of PUBLIC.participant + */ + public static final org.jooq.examples.cubrid.demodb.tables.Participant PARTICIPANT = new org.jooq.examples.cubrid.demodb.tables.Participant(); + + /** + * The class holding records for this type + */ + private static final java.lang.Class __RECORD_TYPE = org.jooq.examples.cubrid.demodb.tables.records.ParticipantRecord.class; + + /** + * The class holding records for this type + */ + @Override + public java.lang.Class getRecordType() { + return __RECORD_TYPE; + } + + /** + * An uncommented item + * + * PRIMARY KEY + */ + public final org.jooq.TableField HOST_YEAR = createField("host_year", org.jooq.impl.SQLDataType.INTEGER, this); + + /** + * An uncommented item + * + * PRIMARY KEY + */ + public final org.jooq.TableField NATION_CODE = createField("nation_code", org.jooq.impl.SQLDataType.CHAR, this); + + /** + * An uncommented item + */ + public final org.jooq.TableField GOLD = createField("gold", org.jooq.impl.SQLDataType.INTEGER, this); + + /** + * An uncommented item + */ + public final org.jooq.TableField SILVER = createField("silver", org.jooq.impl.SQLDataType.INTEGER, this); + + /** + * An uncommented item + */ + public final org.jooq.TableField BRONZE = createField("bronze", org.jooq.impl.SQLDataType.INTEGER, this); + + /** + * No further instances allowed + */ + private Participant() { + super("participant", org.jooq.examples.cubrid.demodb.Public.PUBLIC); + } + + /** + * No further instances allowed + */ + private Participant(java.lang.String alias) { + super(alias, org.jooq.examples.cubrid.demodb.Public.PUBLIC, org.jooq.examples.cubrid.demodb.tables.Participant.PARTICIPANT); + } + + @Override + public org.jooq.UniqueKey getMainKey() { + return org.jooq.examples.cubrid.demodb.Keys.PK_PARTICIPANT_HOST_YEAR_NATION_CODE; + } + + @Override + @SuppressWarnings("unchecked") + public java.util.List> getKeys() { + return java.util.Arrays.>asList(org.jooq.examples.cubrid.demodb.Keys.PK_PARTICIPANT_HOST_YEAR_NATION_CODE); + } + + @Override + public org.jooq.examples.cubrid.demodb.tables.Participant as(java.lang.String alias) { + return new org.jooq.examples.cubrid.demodb.tables.Participant(alias); + } +} diff --git a/jOOQ-test/examples/org/jooq/examples/cubrid/demodb/tables/Record.java b/jOOQ-test/examples/org/jooq/examples/cubrid/demodb/tables/Record.java new file mode 100644 index 0000000000..9389bd4974 --- /dev/null +++ b/jOOQ-test/examples/org/jooq/examples/cubrid/demodb/tables/Record.java @@ -0,0 +1,98 @@ +/** + * This class is generated by jOOQ + */ +package org.jooq.examples.cubrid.demodb.tables; + +/** + * This class is generated by jOOQ. + */ +public class Record extends org.jooq.impl.UpdatableTableImpl { + + private static final long serialVersionUID = 1769435371; + + /** + * The singleton instance of PUBLIC.record + */ + public static final org.jooq.examples.cubrid.demodb.tables.Record RECORD = new org.jooq.examples.cubrid.demodb.tables.Record(); + + /** + * The class holding records for this type + */ + private static final java.lang.Class __RECORD_TYPE = org.jooq.examples.cubrid.demodb.tables.records.RecordRecord.class; + + /** + * The class holding records for this type + */ + @Override + public java.lang.Class getRecordType() { + return __RECORD_TYPE; + } + + /** + * An uncommented item + * + * PRIMARY KEY + */ + public final org.jooq.TableField HOST_YEAR = createField("host_year", org.jooq.impl.SQLDataType.INTEGER, this); + + /** + * An uncommented item + * + * PRIMARY KEY + */ + public final org.jooq.TableField EVENT_CODE = createField("event_code", org.jooq.impl.SQLDataType.INTEGER, this); + + /** + * An uncommented item + * + * PRIMARY KEY + */ + public final org.jooq.TableField ATHLETE_CODE = createField("athlete_code", org.jooq.impl.SQLDataType.INTEGER, this); + + /** + * An uncommented item + * + * PRIMARY KEY + */ + public final org.jooq.TableField MEDAL = createField("medal", org.jooq.impl.SQLDataType.CHAR, this); + + /** + * An uncommented item + */ + public final org.jooq.TableField SCORE = createField("score", org.jooq.impl.SQLDataType.VARCHAR, this); + + /** + * An uncommented item + */ + public final org.jooq.TableField UNIT = createField("unit", org.jooq.impl.SQLDataType.VARCHAR, this); + + /** + * No further instances allowed + */ + private Record() { + super("record", org.jooq.examples.cubrid.demodb.Public.PUBLIC); + } + + /** + * No further instances allowed + */ + private Record(java.lang.String alias) { + super(alias, org.jooq.examples.cubrid.demodb.Public.PUBLIC, org.jooq.examples.cubrid.demodb.tables.Record.RECORD); + } + + @Override + public org.jooq.UniqueKey getMainKey() { + return org.jooq.examples.cubrid.demodb.Keys.PK_RECORD_HOST_YEAR_EVENT_CODE_ATHLETE_CODE_MEDAL; + } + + @Override + @SuppressWarnings("unchecked") + public java.util.List> getKeys() { + return java.util.Arrays.>asList(org.jooq.examples.cubrid.demodb.Keys.PK_RECORD_HOST_YEAR_EVENT_CODE_ATHLETE_CODE_MEDAL); + } + + @Override + public org.jooq.examples.cubrid.demodb.tables.Record as(java.lang.String alias) { + return new org.jooq.examples.cubrid.demodb.tables.Record(alias); + } +} diff --git a/jOOQ-test/examples/org/jooq/examples/cubrid/demodb/tables/Stadium.java b/jOOQ-test/examples/org/jooq/examples/cubrid/demodb/tables/Stadium.java new file mode 100644 index 0000000000..fddbf71d30 --- /dev/null +++ b/jOOQ-test/examples/org/jooq/examples/cubrid/demodb/tables/Stadium.java @@ -0,0 +1,92 @@ +/** + * This class is generated by jOOQ + */ +package org.jooq.examples.cubrid.demodb.tables; + +/** + * This class is generated by jOOQ. + */ +public class Stadium extends org.jooq.impl.UpdatableTableImpl { + + private static final long serialVersionUID = 2068855390; + + /** + * The singleton instance of PUBLIC.stadium + */ + public static final org.jooq.examples.cubrid.demodb.tables.Stadium STADIUM = new org.jooq.examples.cubrid.demodb.tables.Stadium(); + + /** + * The class holding records for this type + */ + private static final java.lang.Class __RECORD_TYPE = org.jooq.examples.cubrid.demodb.tables.records.StadiumRecord.class; + + /** + * The class holding records for this type + */ + @Override + public java.lang.Class getRecordType() { + return __RECORD_TYPE; + } + + /** + * An uncommented item + * + * PRIMARY KEY + */ + public final org.jooq.TableField CODE = createField("code", org.jooq.impl.SQLDataType.INTEGER, this); + + /** + * An uncommented item + */ + public final org.jooq.TableField NATION_CODE = createField("nation_code", org.jooq.impl.SQLDataType.CHAR, this); + + /** + * An uncommented item + */ + public final org.jooq.TableField NAME = createField("name", org.jooq.impl.SQLDataType.VARCHAR, this); + + /** + * An uncommented item + */ + public final org.jooq.TableField AREA = createField("area", org.jooq.impl.SQLDataType.DECIMAL, this); + + /** + * An uncommented item + */ + public final org.jooq.TableField SEATS = createField("seats", org.jooq.impl.SQLDataType.INTEGER, this); + + /** + * An uncommented item + */ + public final org.jooq.TableField ADDRESS = createField("address", org.jooq.impl.SQLDataType.VARCHAR, this); + + /** + * No further instances allowed + */ + private Stadium() { + super("stadium", org.jooq.examples.cubrid.demodb.Public.PUBLIC); + } + + /** + * No further instances allowed + */ + private Stadium(java.lang.String alias) { + super(alias, org.jooq.examples.cubrid.demodb.Public.PUBLIC, org.jooq.examples.cubrid.demodb.tables.Stadium.STADIUM); + } + + @Override + public org.jooq.UniqueKey getMainKey() { + return org.jooq.examples.cubrid.demodb.Keys.PK_STADIUM_CODE; + } + + @Override + @SuppressWarnings("unchecked") + public java.util.List> getKeys() { + return java.util.Arrays.>asList(org.jooq.examples.cubrid.demodb.Keys.PK_STADIUM_CODE); + } + + @Override + public org.jooq.examples.cubrid.demodb.tables.Stadium as(java.lang.String alias) { + return new org.jooq.examples.cubrid.demodb.tables.Stadium(alias); + } +} diff --git a/jOOQ-test/examples/org/jooq/examples/cubrid/demodb/tables/pojos/Athlete.java b/jOOQ-test/examples/org/jooq/examples/cubrid/demodb/tables/pojos/Athlete.java new file mode 100644 index 0000000000..aa87889165 --- /dev/null +++ b/jOOQ-test/examples/org/jooq/examples/cubrid/demodb/tables/pojos/Athlete.java @@ -0,0 +1,66 @@ +/** + * This class is generated by jOOQ + */ +package org.jooq.examples.cubrid.demodb.tables.pojos; + +/** + * This class is generated by jOOQ. + */ +@javax.persistence.Entity +@javax.persistence.Table(name = "athlete", schema = "PUBLIC") +public class Athlete implements java.io.Serializable { + + private static final long serialVersionUID = -1286219248; + + private java.lang.Integer code; + private java.lang.String name; + private java.lang.String gender; + private java.lang.String nationCode; + private java.lang.String event; + + @javax.persistence.Id + @javax.persistence.Column(name = "code", unique = true, nullable = false) + public java.lang.Integer getCode() { + return this.code; + } + + public void setCode(java.lang.Integer code) { + this.code = code; + } + + @javax.persistence.Column(name = "name", nullable = false, precision = 40) + public java.lang.String getName() { + return this.name; + } + + public void setName(java.lang.String name) { + this.name = name; + } + + @javax.persistence.Column(name = "gender", length = 1) + public java.lang.String getGender() { + return this.gender; + } + + public void setGender(java.lang.String gender) { + this.gender = gender; + } + + @javax.persistence.Column(name = "nation_code", length = 3) + public java.lang.String getNationCode() { + return this.nationCode; + } + + public void setNationCode(java.lang.String nationCode) { + this.nationCode = nationCode; + } + + @javax.persistence.Column(name = "event", precision = 30) + public java.lang.String getEvent() { + return this.event; + } + + public void setEvent(java.lang.String event) { + this.event = event; + } +} diff --git a/jOOQ-test/examples/org/jooq/examples/cubrid/demodb/tables/pojos/Code.java b/jOOQ-test/examples/org/jooq/examples/cubrid/demodb/tables/pojos/Code.java new file mode 100644 index 0000000000..0df860ceba --- /dev/null +++ b/jOOQ-test/examples/org/jooq/examples/cubrid/demodb/tables/pojos/Code.java @@ -0,0 +1,35 @@ +/** + * This class is generated by jOOQ + */ +package org.jooq.examples.cubrid.demodb.tables.pojos; + +/** + * This class is generated by jOOQ. + */ +@javax.persistence.Entity +@javax.persistence.Table(name = "code", schema = "PUBLIC") +public class Code implements java.io.Serializable { + + private static final long serialVersionUID = -717243519; + + private java.lang.String sName; + private java.lang.String fName; + + @javax.persistence.Column(name = "s_name", length = 1) + public java.lang.String getSName() { + return this.sName; + } + + public void setSName(java.lang.String sName) { + this.sName = sName; + } + + @javax.persistence.Column(name = "f_name", precision = 6) + public java.lang.String getFName() { + return this.fName; + } + + public void setFName(java.lang.String fName) { + this.fName = fName; + } +} diff --git a/jOOQ-test/examples/org/jooq/examples/cubrid/demodb/tables/pojos/Event.java b/jOOQ-test/examples/org/jooq/examples/cubrid/demodb/tables/pojos/Event.java new file mode 100644 index 0000000000..d29b6940c7 --- /dev/null +++ b/jOOQ-test/examples/org/jooq/examples/cubrid/demodb/tables/pojos/Event.java @@ -0,0 +1,66 @@ +/** + * This class is generated by jOOQ + */ +package org.jooq.examples.cubrid.demodb.tables.pojos; + +/** + * This class is generated by jOOQ. + */ +@javax.persistence.Entity +@javax.persistence.Table(name = "event", schema = "PUBLIC") +public class Event implements java.io.Serializable { + + private static final long serialVersionUID = -1266442252; + + private java.lang.Integer code; + private java.lang.String sports; + private java.lang.String name; + private java.lang.String gender; + private java.lang.Integer players; + + @javax.persistence.Id + @javax.persistence.Column(name = "code", unique = true, nullable = false) + public java.lang.Integer getCode() { + return this.code; + } + + public void setCode(java.lang.Integer code) { + this.code = code; + } + + @javax.persistence.Column(name = "sports", precision = 50) + public java.lang.String getSports() { + return this.sports; + } + + public void setSports(java.lang.String sports) { + this.sports = sports; + } + + @javax.persistence.Column(name = "name", precision = 50) + public java.lang.String getName() { + return this.name; + } + + public void setName(java.lang.String name) { + this.name = name; + } + + @javax.persistence.Column(name = "gender", length = 1) + public java.lang.String getGender() { + return this.gender; + } + + public void setGender(java.lang.String gender) { + this.gender = gender; + } + + @javax.persistence.Column(name = "players") + public java.lang.Integer getPlayers() { + return this.players; + } + + public void setPlayers(java.lang.Integer players) { + this.players = players; + } +} diff --git a/jOOQ-test/examples/org/jooq/examples/cubrid/demodb/tables/pojos/Game.java b/jOOQ-test/examples/org/jooq/examples/cubrid/demodb/tables/pojos/Game.java new file mode 100644 index 0000000000..fe4f123d89 --- /dev/null +++ b/jOOQ-test/examples/org/jooq/examples/cubrid/demodb/tables/pojos/Game.java @@ -0,0 +1,87 @@ +/** + * This class is generated by jOOQ + */ +package org.jooq.examples.cubrid.demodb.tables.pojos; + +/** + * This class is generated by jOOQ. + */ +@javax.persistence.Entity +@javax.persistence.Table(name = "game", schema = "PUBLIC", uniqueConstraints = { + @javax.persistence.UniqueConstraint(columnNames = {"host_year", "event_code", "athlete_code"}) +}) +public class Game implements java.io.Serializable { + + private static final long serialVersionUID = 709922232; + + private java.lang.Integer hostYear; + private java.lang.Integer eventCode; + private java.lang.Integer athleteCode; + private java.lang.Integer stadiumCode; + private java.lang.String nationCode; + private java.lang.String medal; + private java.sql.Date gameDate; + + @javax.persistence.Column(name = "host_year", nullable = false) + public java.lang.Integer getHostYear() { + return this.hostYear; + } + + public void setHostYear(java.lang.Integer hostYear) { + this.hostYear = hostYear; + } + + @javax.persistence.Column(name = "event_code", nullable = false) + public java.lang.Integer getEventCode() { + return this.eventCode; + } + + public void setEventCode(java.lang.Integer eventCode) { + this.eventCode = eventCode; + } + + @javax.persistence.Column(name = "athlete_code", nullable = false) + public java.lang.Integer getAthleteCode() { + return this.athleteCode; + } + + public void setAthleteCode(java.lang.Integer athleteCode) { + this.athleteCode = athleteCode; + } + + @javax.persistence.Column(name = "stadium_code", nullable = false) + public java.lang.Integer getStadiumCode() { + return this.stadiumCode; + } + + public void setStadiumCode(java.lang.Integer stadiumCode) { + this.stadiumCode = stadiumCode; + } + + @javax.persistence.Column(name = "nation_code", length = 3) + public java.lang.String getNationCode() { + return this.nationCode; + } + + public void setNationCode(java.lang.String nationCode) { + this.nationCode = nationCode; + } + + @javax.persistence.Column(name = "medal", length = 1) + public java.lang.String getMedal() { + return this.medal; + } + + public void setMedal(java.lang.String medal) { + this.medal = medal; + } + + @javax.persistence.Column(name = "game_date") + public java.sql.Date getGameDate() { + return this.gameDate; + } + + public void setGameDate(java.sql.Date gameDate) { + this.gameDate = gameDate; + } +} diff --git a/jOOQ-test/examples/org/jooq/examples/cubrid/demodb/tables/pojos/History.java b/jOOQ-test/examples/org/jooq/examples/cubrid/demodb/tables/pojos/History.java new file mode 100644 index 0000000000..c4686c2d27 --- /dev/null +++ b/jOOQ-test/examples/org/jooq/examples/cubrid/demodb/tables/pojos/History.java @@ -0,0 +1,67 @@ +/** + * This class is generated by jOOQ + */ +package org.jooq.examples.cubrid.demodb.tables.pojos; + +/** + * This class is generated by jOOQ. + */ +@javax.persistence.Entity +@javax.persistence.Table(name = "history", schema = "PUBLIC", uniqueConstraints = { + @javax.persistence.UniqueConstraint(columnNames = {"event_code", "athlete"}) +}) +public class History implements java.io.Serializable { + + private static final long serialVersionUID = 1518631114; + + private java.lang.Integer eventCode; + private java.lang.String athlete; + private java.lang.Integer hostYear; + private java.lang.String score; + private java.lang.String unit; + + @javax.persistence.Column(name = "event_code", nullable = false) + public java.lang.Integer getEventCode() { + return this.eventCode; + } + + public void setEventCode(java.lang.Integer eventCode) { + this.eventCode = eventCode; + } + + @javax.persistence.Column(name = "athlete", nullable = false, precision = 40) + public java.lang.String getAthlete() { + return this.athlete; + } + + public void setAthlete(java.lang.String athlete) { + this.athlete = athlete; + } + + @javax.persistence.Column(name = "host_year") + public java.lang.Integer getHostYear() { + return this.hostYear; + } + + public void setHostYear(java.lang.Integer hostYear) { + this.hostYear = hostYear; + } + + @javax.persistence.Column(name = "score", precision = 10) + public java.lang.String getScore() { + return this.score; + } + + public void setScore(java.lang.String score) { + this.score = score; + } + + @javax.persistence.Column(name = "unit", precision = 5) + public java.lang.String getUnit() { + return this.unit; + } + + public void setUnit(java.lang.String unit) { + this.unit = unit; + } +} diff --git a/jOOQ-test/examples/org/jooq/examples/cubrid/demodb/tables/pojos/Nation.java b/jOOQ-test/examples/org/jooq/examples/cubrid/demodb/tables/pojos/Nation.java new file mode 100644 index 0000000000..422b1ed812 --- /dev/null +++ b/jOOQ-test/examples/org/jooq/examples/cubrid/demodb/tables/pojos/Nation.java @@ -0,0 +1,56 @@ +/** + * This class is generated by jOOQ + */ +package org.jooq.examples.cubrid.demodb.tables.pojos; + +/** + * This class is generated by jOOQ. + */ +@javax.persistence.Entity +@javax.persistence.Table(name = "nation", schema = "PUBLIC") +public class Nation implements java.io.Serializable { + + private static final long serialVersionUID = 1194497602; + + private java.lang.String code; + private java.lang.String name; + private java.lang.String continent; + private java.lang.String capital; + + @javax.persistence.Id + @javax.persistence.Column(name = "code", unique = true, nullable = false, length = 3) + public java.lang.String getCode() { + return this.code; + } + + public void setCode(java.lang.String code) { + this.code = code; + } + + @javax.persistence.Column(name = "name", nullable = false, precision = 40) + public java.lang.String getName() { + return this.name; + } + + public void setName(java.lang.String name) { + this.name = name; + } + + @javax.persistence.Column(name = "continent", precision = 10) + public java.lang.String getContinent() { + return this.continent; + } + + public void setContinent(java.lang.String continent) { + this.continent = continent; + } + + @javax.persistence.Column(name = "capital", precision = 30) + public java.lang.String getCapital() { + return this.capital; + } + + public void setCapital(java.lang.String capital) { + this.capital = capital; + } +} diff --git a/jOOQ-test/examples/org/jooq/examples/cubrid/demodb/tables/pojos/Olympic.java b/jOOQ-test/examples/org/jooq/examples/cubrid/demodb/tables/pojos/Olympic.java new file mode 100644 index 0000000000..299e1b2fa4 --- /dev/null +++ b/jOOQ-test/examples/org/jooq/examples/cubrid/demodb/tables/pojos/Olympic.java @@ -0,0 +1,96 @@ +/** + * This class is generated by jOOQ + */ +package org.jooq.examples.cubrid.demodb.tables.pojos; + +/** + * This class is generated by jOOQ. + */ +@javax.persistence.Entity +@javax.persistence.Table(name = "olympic", schema = "PUBLIC") +public class Olympic implements java.io.Serializable { + + private static final long serialVersionUID = -833188373; + + private java.lang.Integer hostYear; + private java.lang.String hostNation; + private java.lang.String hostCity; + private java.sql.Date openingDate; + private java.sql.Date closingDate; + private java.lang.String mascot; + private java.lang.String slogan; + private java.lang.String introduction; + + @javax.persistence.Id + @javax.persistence.Column(name = "host_year", unique = true, nullable = false) + public java.lang.Integer getHostYear() { + return this.hostYear; + } + + public void setHostYear(java.lang.Integer hostYear) { + this.hostYear = hostYear; + } + + @javax.persistence.Column(name = "host_nation", nullable = false, precision = 40) + public java.lang.String getHostNation() { + return this.hostNation; + } + + public void setHostNation(java.lang.String hostNation) { + this.hostNation = hostNation; + } + + @javax.persistence.Column(name = "host_city", nullable = false, precision = 20) + public java.lang.String getHostCity() { + return this.hostCity; + } + + public void setHostCity(java.lang.String hostCity) { + this.hostCity = hostCity; + } + + @javax.persistence.Column(name = "opening_date", nullable = false) + public java.sql.Date getOpeningDate() { + return this.openingDate; + } + + public void setOpeningDate(java.sql.Date openingDate) { + this.openingDate = openingDate; + } + + @javax.persistence.Column(name = "closing_date", nullable = false) + public java.sql.Date getClosingDate() { + return this.closingDate; + } + + public void setClosingDate(java.sql.Date closingDate) { + this.closingDate = closingDate; + } + + @javax.persistence.Column(name = "mascot", precision = 20) + public java.lang.String getMascot() { + return this.mascot; + } + + public void setMascot(java.lang.String mascot) { + this.mascot = mascot; + } + + @javax.persistence.Column(name = "slogan", precision = 40) + public java.lang.String getSlogan() { + return this.slogan; + } + + public void setSlogan(java.lang.String slogan) { + this.slogan = slogan; + } + + @javax.persistence.Column(name = "introduction", precision = 1500) + public java.lang.String getIntroduction() { + return this.introduction; + } + + public void setIntroduction(java.lang.String introduction) { + this.introduction = introduction; + } +} diff --git a/jOOQ-test/examples/org/jooq/examples/cubrid/demodb/tables/pojos/Participant.java b/jOOQ-test/examples/org/jooq/examples/cubrid/demodb/tables/pojos/Participant.java new file mode 100644 index 0000000000..bee384c672 --- /dev/null +++ b/jOOQ-test/examples/org/jooq/examples/cubrid/demodb/tables/pojos/Participant.java @@ -0,0 +1,67 @@ +/** + * This class is generated by jOOQ + */ +package org.jooq.examples.cubrid.demodb.tables.pojos; + +/** + * This class is generated by jOOQ. + */ +@javax.persistence.Entity +@javax.persistence.Table(name = "participant", schema = "PUBLIC", uniqueConstraints = { + @javax.persistence.UniqueConstraint(columnNames = {"host_year", "nation_code"}) +}) +public class Participant implements java.io.Serializable { + + private static final long serialVersionUID = 80587499; + + private java.lang.Integer hostYear; + private java.lang.String nationCode; + private java.lang.Integer gold; + private java.lang.Integer silver; + private java.lang.Integer bronze; + + @javax.persistence.Column(name = "host_year", nullable = false) + public java.lang.Integer getHostYear() { + return this.hostYear; + } + + public void setHostYear(java.lang.Integer hostYear) { + this.hostYear = hostYear; + } + + @javax.persistence.Column(name = "nation_code", nullable = false, length = 3) + public java.lang.String getNationCode() { + return this.nationCode; + } + + public void setNationCode(java.lang.String nationCode) { + this.nationCode = nationCode; + } + + @javax.persistence.Column(name = "gold") + public java.lang.Integer getGold() { + return this.gold; + } + + public void setGold(java.lang.Integer gold) { + this.gold = gold; + } + + @javax.persistence.Column(name = "silver") + public java.lang.Integer getSilver() { + return this.silver; + } + + public void setSilver(java.lang.Integer silver) { + this.silver = silver; + } + + @javax.persistence.Column(name = "bronze") + public java.lang.Integer getBronze() { + return this.bronze; + } + + public void setBronze(java.lang.Integer bronze) { + this.bronze = bronze; + } +} diff --git a/jOOQ-test/examples/org/jooq/examples/cubrid/demodb/tables/pojos/Record.java b/jOOQ-test/examples/org/jooq/examples/cubrid/demodb/tables/pojos/Record.java new file mode 100644 index 0000000000..820ce8ded5 --- /dev/null +++ b/jOOQ-test/examples/org/jooq/examples/cubrid/demodb/tables/pojos/Record.java @@ -0,0 +1,77 @@ +/** + * This class is generated by jOOQ + */ +package org.jooq.examples.cubrid.demodb.tables.pojos; + +/** + * This class is generated by jOOQ. + */ +@javax.persistence.Entity +@javax.persistence.Table(name = "record", schema = "PUBLIC", uniqueConstraints = { + @javax.persistence.UniqueConstraint(columnNames = {"host_year", "event_code", "athlete_code", "medal"}) +}) +public class Record implements java.io.Serializable { + + private static final long serialVersionUID = 182628481; + + private java.lang.Integer hostYear; + private java.lang.Integer eventCode; + private java.lang.Integer athleteCode; + private java.lang.String medal; + private java.lang.String score; + private java.lang.String unit; + + @javax.persistence.Column(name = "host_year", nullable = false) + public java.lang.Integer getHostYear() { + return this.hostYear; + } + + public void setHostYear(java.lang.Integer hostYear) { + this.hostYear = hostYear; + } + + @javax.persistence.Column(name = "event_code", nullable = false) + public java.lang.Integer getEventCode() { + return this.eventCode; + } + + public void setEventCode(java.lang.Integer eventCode) { + this.eventCode = eventCode; + } + + @javax.persistence.Column(name = "athlete_code", nullable = false) + public java.lang.Integer getAthleteCode() { + return this.athleteCode; + } + + public void setAthleteCode(java.lang.Integer athleteCode) { + this.athleteCode = athleteCode; + } + + @javax.persistence.Column(name = "medal", nullable = false, length = 1) + public java.lang.String getMedal() { + return this.medal; + } + + public void setMedal(java.lang.String medal) { + this.medal = medal; + } + + @javax.persistence.Column(name = "score", precision = 20) + public java.lang.String getScore() { + return this.score; + } + + public void setScore(java.lang.String score) { + this.score = score; + } + + @javax.persistence.Column(name = "unit", precision = 5) + public java.lang.String getUnit() { + return this.unit; + } + + public void setUnit(java.lang.String unit) { + this.unit = unit; + } +} diff --git a/jOOQ-test/examples/org/jooq/examples/cubrid/demodb/tables/pojos/Stadium.java b/jOOQ-test/examples/org/jooq/examples/cubrid/demodb/tables/pojos/Stadium.java new file mode 100644 index 0000000000..75c3e08ecf --- /dev/null +++ b/jOOQ-test/examples/org/jooq/examples/cubrid/demodb/tables/pojos/Stadium.java @@ -0,0 +1,76 @@ +/** + * This class is generated by jOOQ + */ +package org.jooq.examples.cubrid.demodb.tables.pojos; + +/** + * This class is generated by jOOQ. + */ +@javax.persistence.Entity +@javax.persistence.Table(name = "stadium", schema = "PUBLIC") +public class Stadium implements java.io.Serializable { + + private static final long serialVersionUID = -624213762; + + private java.lang.Integer code; + private java.lang.String nationCode; + private java.lang.String name; + private java.math.BigDecimal area; + private java.lang.Integer seats; + private java.lang.String address; + + @javax.persistence.Id + @javax.persistence.Column(name = "code", unique = true, nullable = false) + public java.lang.Integer getCode() { + return this.code; + } + + public void setCode(java.lang.Integer code) { + this.code = code; + } + + @javax.persistence.Column(name = "nation_code", nullable = false, length = 3) + public java.lang.String getNationCode() { + return this.nationCode; + } + + public void setNationCode(java.lang.String nationCode) { + this.nationCode = nationCode; + } + + @javax.persistence.Column(name = "name", nullable = false, precision = 50) + public java.lang.String getName() { + return this.name; + } + + public void setName(java.lang.String name) { + this.name = name; + } + + @javax.persistence.Column(name = "area", precision = 10, scale = 2) + public java.math.BigDecimal getArea() { + return this.area; + } + + public void setArea(java.math.BigDecimal area) { + this.area = area; + } + + @javax.persistence.Column(name = "seats") + public java.lang.Integer getSeats() { + return this.seats; + } + + public void setSeats(java.lang.Integer seats) { + this.seats = seats; + } + + @javax.persistence.Column(name = "address", precision = 100) + public java.lang.String getAddress() { + return this.address; + } + + public void setAddress(java.lang.String address) { + this.address = address; + } +} diff --git a/jOOQ-test/examples/org/jooq/examples/cubrid/demodb/tables/records/AthleteRecord.java b/jOOQ-test/examples/org/jooq/examples/cubrid/demodb/tables/records/AthleteRecord.java new file mode 100644 index 0000000000..ea56889618 --- /dev/null +++ b/jOOQ-test/examples/org/jooq/examples/cubrid/demodb/tables/records/AthleteRecord.java @@ -0,0 +1,101 @@ +/** + * This class is generated by jOOQ + */ +package org.jooq.examples.cubrid.demodb.tables.records; + +/** + * This class is generated by jOOQ. + */ +@javax.persistence.Entity +@javax.persistence.Table(name = "athlete", schema = "PUBLIC") +public class AthleteRecord extends org.jooq.impl.UpdatableRecordImpl { + + private static final long serialVersionUID = -927949830; + + /** + * An uncommented item + * + * PRIMARY KEY + */ + public void setCode(java.lang.Integer value) { + setValue(org.jooq.examples.cubrid.demodb.tables.Athlete.ATHLETE.CODE, value); + } + + /** + * An uncommented item + * + * PRIMARY KEY + */ + @javax.persistence.Id + @javax.persistence.Column(name = "code", unique = true, nullable = false) + public java.lang.Integer getCode() { + return getValue(org.jooq.examples.cubrid.demodb.tables.Athlete.ATHLETE.CODE); + } + + /** + * An uncommented item + */ + public void setName(java.lang.String value) { + setValue(org.jooq.examples.cubrid.demodb.tables.Athlete.ATHLETE.NAME, value); + } + + /** + * An uncommented item + */ + @javax.persistence.Column(name = "name", nullable = false, precision = 40) + public java.lang.String getName() { + return getValue(org.jooq.examples.cubrid.demodb.tables.Athlete.ATHLETE.NAME); + } + + /** + * An uncommented item + */ + public void setGender(java.lang.String value) { + setValue(org.jooq.examples.cubrid.demodb.tables.Athlete.ATHLETE.GENDER, value); + } + + /** + * An uncommented item + */ + @javax.persistence.Column(name = "gender", length = 1) + public java.lang.String getGender() { + return getValue(org.jooq.examples.cubrid.demodb.tables.Athlete.ATHLETE.GENDER); + } + + /** + * An uncommented item + */ + public void setNationCode(java.lang.String value) { + setValue(org.jooq.examples.cubrid.demodb.tables.Athlete.ATHLETE.NATION_CODE, value); + } + + /** + * An uncommented item + */ + @javax.persistence.Column(name = "nation_code", length = 3) + public java.lang.String getNationCode() { + return getValue(org.jooq.examples.cubrid.demodb.tables.Athlete.ATHLETE.NATION_CODE); + } + + /** + * An uncommented item + */ + public void setEvent(java.lang.String value) { + setValue(org.jooq.examples.cubrid.demodb.tables.Athlete.ATHLETE.EVENT, value); + } + + /** + * An uncommented item + */ + @javax.persistence.Column(name = "event", precision = 30) + public java.lang.String getEvent() { + return getValue(org.jooq.examples.cubrid.demodb.tables.Athlete.ATHLETE.EVENT); + } + + /** + * Create a detached AthleteRecord + */ + public AthleteRecord() { + super(org.jooq.examples.cubrid.demodb.tables.Athlete.ATHLETE); + } +} diff --git a/jOOQ-test/examples/org/jooq/examples/cubrid/demodb/tables/records/CodeRecord.java b/jOOQ-test/examples/org/jooq/examples/cubrid/demodb/tables/records/CodeRecord.java new file mode 100644 index 0000000000..448d4a2d71 --- /dev/null +++ b/jOOQ-test/examples/org/jooq/examples/cubrid/demodb/tables/records/CodeRecord.java @@ -0,0 +1,51 @@ +/** + * This class is generated by jOOQ + */ +package org.jooq.examples.cubrid.demodb.tables.records; + +/** + * This class is generated by jOOQ. + */ +@javax.persistence.Entity +@javax.persistence.Table(name = "code", schema = "PUBLIC") +public class CodeRecord extends org.jooq.impl.TableRecordImpl { + + private static final long serialVersionUID = 1136850229; + + /** + * An uncommented item + */ + public void setSName(java.lang.String value) { + setValue(org.jooq.examples.cubrid.demodb.tables.Code.CODE.S_NAME, value); + } + + /** + * An uncommented item + */ + @javax.persistence.Column(name = "s_name", length = 1) + public java.lang.String getSName() { + return getValue(org.jooq.examples.cubrid.demodb.tables.Code.CODE.S_NAME); + } + + /** + * An uncommented item + */ + public void setFName(java.lang.String value) { + setValue(org.jooq.examples.cubrid.demodb.tables.Code.CODE.F_NAME, value); + } + + /** + * An uncommented item + */ + @javax.persistence.Column(name = "f_name", precision = 6) + public java.lang.String getFName() { + return getValue(org.jooq.examples.cubrid.demodb.tables.Code.CODE.F_NAME); + } + + /** + * Create a detached CodeRecord + */ + public CodeRecord() { + super(org.jooq.examples.cubrid.demodb.tables.Code.CODE); + } +} diff --git a/jOOQ-test/examples/org/jooq/examples/cubrid/demodb/tables/records/EventRecord.java b/jOOQ-test/examples/org/jooq/examples/cubrid/demodb/tables/records/EventRecord.java new file mode 100644 index 0000000000..91bde7686f --- /dev/null +++ b/jOOQ-test/examples/org/jooq/examples/cubrid/demodb/tables/records/EventRecord.java @@ -0,0 +1,101 @@ +/** + * This class is generated by jOOQ + */ +package org.jooq.examples.cubrid.demodb.tables.records; + +/** + * This class is generated by jOOQ. + */ +@javax.persistence.Entity +@javax.persistence.Table(name = "event", schema = "PUBLIC") +public class EventRecord extends org.jooq.impl.UpdatableRecordImpl { + + private static final long serialVersionUID = -1891026539; + + /** + * An uncommented item + * + * PRIMARY KEY + */ + public void setCode(java.lang.Integer value) { + setValue(org.jooq.examples.cubrid.demodb.tables.Event.EVENT.CODE, value); + } + + /** + * An uncommented item + * + * PRIMARY KEY + */ + @javax.persistence.Id + @javax.persistence.Column(name = "code", unique = true, nullable = false) + public java.lang.Integer getCode() { + return getValue(org.jooq.examples.cubrid.demodb.tables.Event.EVENT.CODE); + } + + /** + * An uncommented item + */ + public void setSports(java.lang.String value) { + setValue(org.jooq.examples.cubrid.demodb.tables.Event.EVENT.SPORTS, value); + } + + /** + * An uncommented item + */ + @javax.persistence.Column(name = "sports", precision = 50) + public java.lang.String getSports() { + return getValue(org.jooq.examples.cubrid.demodb.tables.Event.EVENT.SPORTS); + } + + /** + * An uncommented item + */ + public void setName(java.lang.String value) { + setValue(org.jooq.examples.cubrid.demodb.tables.Event.EVENT.NAME, value); + } + + /** + * An uncommented item + */ + @javax.persistence.Column(name = "name", precision = 50) + public java.lang.String getName() { + return getValue(org.jooq.examples.cubrid.demodb.tables.Event.EVENT.NAME); + } + + /** + * An uncommented item + */ + public void setGender(java.lang.String value) { + setValue(org.jooq.examples.cubrid.demodb.tables.Event.EVENT.GENDER, value); + } + + /** + * An uncommented item + */ + @javax.persistence.Column(name = "gender", length = 1) + public java.lang.String getGender() { + return getValue(org.jooq.examples.cubrid.demodb.tables.Event.EVENT.GENDER); + } + + /** + * An uncommented item + */ + public void setPlayers(java.lang.Integer value) { + setValue(org.jooq.examples.cubrid.demodb.tables.Event.EVENT.PLAYERS, value); + } + + /** + * An uncommented item + */ + @javax.persistence.Column(name = "players") + public java.lang.Integer getPlayers() { + return getValue(org.jooq.examples.cubrid.demodb.tables.Event.EVENT.PLAYERS); + } + + /** + * Create a detached EventRecord + */ + public EventRecord() { + super(org.jooq.examples.cubrid.demodb.tables.Event.EVENT); + } +} diff --git a/jOOQ-test/examples/org/jooq/examples/cubrid/demodb/tables/records/GameRecord.java b/jOOQ-test/examples/org/jooq/examples/cubrid/demodb/tables/records/GameRecord.java new file mode 100644 index 0000000000..c13e8c51bc --- /dev/null +++ b/jOOQ-test/examples/org/jooq/examples/cubrid/demodb/tables/records/GameRecord.java @@ -0,0 +1,140 @@ +/** + * This class is generated by jOOQ + */ +package org.jooq.examples.cubrid.demodb.tables.records; + +/** + * This class is generated by jOOQ. + */ +@javax.persistence.Entity +@javax.persistence.Table(name = "game", schema = "PUBLIC", uniqueConstraints = { + @javax.persistence.UniqueConstraint(columnNames = {"host_year", "event_code", "athlete_code"}) +}) +public class GameRecord extends org.jooq.impl.UpdatableRecordImpl { + + private static final long serialVersionUID = -118829765; + + /** + * An uncommented item + * + * PRIMARY KEY + */ + public void setHostYear(java.lang.Integer value) { + setValue(org.jooq.examples.cubrid.demodb.tables.Game.GAME.HOST_YEAR, value); + } + + /** + * An uncommented item + * + * PRIMARY KEY + */ + @javax.persistence.Column(name = "host_year", nullable = false) + public java.lang.Integer getHostYear() { + return getValue(org.jooq.examples.cubrid.demodb.tables.Game.GAME.HOST_YEAR); + } + + /** + * An uncommented item + * + * PRIMARY KEY + */ + public void setEventCode(java.lang.Integer value) { + setValue(org.jooq.examples.cubrid.demodb.tables.Game.GAME.EVENT_CODE, value); + } + + /** + * An uncommented item + * + * PRIMARY KEY + */ + @javax.persistence.Column(name = "event_code", nullable = false) + public java.lang.Integer getEventCode() { + return getValue(org.jooq.examples.cubrid.demodb.tables.Game.GAME.EVENT_CODE); + } + + /** + * An uncommented item + * + * PRIMARY KEY + */ + public void setAthleteCode(java.lang.Integer value) { + setValue(org.jooq.examples.cubrid.demodb.tables.Game.GAME.ATHLETE_CODE, value); + } + + /** + * An uncommented item + * + * PRIMARY KEY + */ + @javax.persistence.Column(name = "athlete_code", nullable = false) + public java.lang.Integer getAthleteCode() { + return getValue(org.jooq.examples.cubrid.demodb.tables.Game.GAME.ATHLETE_CODE); + } + + /** + * An uncommented item + */ + public void setStadiumCode(java.lang.Integer value) { + setValue(org.jooq.examples.cubrid.demodb.tables.Game.GAME.STADIUM_CODE, value); + } + + /** + * An uncommented item + */ + @javax.persistence.Column(name = "stadium_code", nullable = false) + public java.lang.Integer getStadiumCode() { + return getValue(org.jooq.examples.cubrid.demodb.tables.Game.GAME.STADIUM_CODE); + } + + /** + * An uncommented item + */ + public void setNationCode(java.lang.String value) { + setValue(org.jooq.examples.cubrid.demodb.tables.Game.GAME.NATION_CODE, value); + } + + /** + * An uncommented item + */ + @javax.persistence.Column(name = "nation_code", length = 3) + public java.lang.String getNationCode() { + return getValue(org.jooq.examples.cubrid.demodb.tables.Game.GAME.NATION_CODE); + } + + /** + * An uncommented item + */ + public void setMedal(java.lang.String value) { + setValue(org.jooq.examples.cubrid.demodb.tables.Game.GAME.MEDAL, value); + } + + /** + * An uncommented item + */ + @javax.persistence.Column(name = "medal", length = 1) + public java.lang.String getMedal() { + return getValue(org.jooq.examples.cubrid.demodb.tables.Game.GAME.MEDAL); + } + + /** + * An uncommented item + */ + public void setGameDate(java.sql.Date value) { + setValue(org.jooq.examples.cubrid.demodb.tables.Game.GAME.GAME_DATE, value); + } + + /** + * An uncommented item + */ + @javax.persistence.Column(name = "game_date") + public java.sql.Date getGameDate() { + return getValue(org.jooq.examples.cubrid.demodb.tables.Game.GAME.GAME_DATE); + } + + /** + * Create a detached GameRecord + */ + public GameRecord() { + super(org.jooq.examples.cubrid.demodb.tables.Game.GAME); + } +} diff --git a/jOOQ-test/examples/org/jooq/examples/cubrid/demodb/tables/records/HistoryRecord.java b/jOOQ-test/examples/org/jooq/examples/cubrid/demodb/tables/records/HistoryRecord.java new file mode 100644 index 0000000000..2168fd0cc5 --- /dev/null +++ b/jOOQ-test/examples/org/jooq/examples/cubrid/demodb/tables/records/HistoryRecord.java @@ -0,0 +1,106 @@ +/** + * This class is generated by jOOQ + */ +package org.jooq.examples.cubrid.demodb.tables.records; + +/** + * This class is generated by jOOQ. + */ +@javax.persistence.Entity +@javax.persistence.Table(name = "history", schema = "PUBLIC", uniqueConstraints = { + @javax.persistence.UniqueConstraint(columnNames = {"event_code", "athlete"}) +}) +public class HistoryRecord extends org.jooq.impl.UpdatableRecordImpl { + + private static final long serialVersionUID = 986266930; + + /** + * An uncommented item + * + * PRIMARY KEY + */ + public void setEventCode(java.lang.Integer value) { + setValue(org.jooq.examples.cubrid.demodb.tables.History.HISTORY.EVENT_CODE, value); + } + + /** + * An uncommented item + * + * PRIMARY KEY + */ + @javax.persistence.Column(name = "event_code", nullable = false) + public java.lang.Integer getEventCode() { + return getValue(org.jooq.examples.cubrid.demodb.tables.History.HISTORY.EVENT_CODE); + } + + /** + * An uncommented item + * + * PRIMARY KEY + */ + public void setAthlete(java.lang.String value) { + setValue(org.jooq.examples.cubrid.demodb.tables.History.HISTORY.ATHLETE, value); + } + + /** + * An uncommented item + * + * PRIMARY KEY + */ + @javax.persistence.Column(name = "athlete", nullable = false, precision = 40) + public java.lang.String getAthlete() { + return getValue(org.jooq.examples.cubrid.demodb.tables.History.HISTORY.ATHLETE); + } + + /** + * An uncommented item + */ + public void setHostYear(java.lang.Integer value) { + setValue(org.jooq.examples.cubrid.demodb.tables.History.HISTORY.HOST_YEAR, value); + } + + /** + * An uncommented item + */ + @javax.persistence.Column(name = "host_year") + public java.lang.Integer getHostYear() { + return getValue(org.jooq.examples.cubrid.demodb.tables.History.HISTORY.HOST_YEAR); + } + + /** + * An uncommented item + */ + public void setScore(java.lang.String value) { + setValue(org.jooq.examples.cubrid.demodb.tables.History.HISTORY.SCORE, value); + } + + /** + * An uncommented item + */ + @javax.persistence.Column(name = "score", precision = 10) + public java.lang.String getScore() { + return getValue(org.jooq.examples.cubrid.demodb.tables.History.HISTORY.SCORE); + } + + /** + * An uncommented item + */ + public void setUnit(java.lang.String value) { + setValue(org.jooq.examples.cubrid.demodb.tables.History.HISTORY.UNIT, value); + } + + /** + * An uncommented item + */ + @javax.persistence.Column(name = "unit", precision = 5) + public java.lang.String getUnit() { + return getValue(org.jooq.examples.cubrid.demodb.tables.History.HISTORY.UNIT); + } + + /** + * Create a detached HistoryRecord + */ + public HistoryRecord() { + super(org.jooq.examples.cubrid.demodb.tables.History.HISTORY); + } +} diff --git a/jOOQ-test/examples/org/jooq/examples/cubrid/demodb/tables/records/NationRecord.java b/jOOQ-test/examples/org/jooq/examples/cubrid/demodb/tables/records/NationRecord.java new file mode 100644 index 0000000000..8d4aa90427 --- /dev/null +++ b/jOOQ-test/examples/org/jooq/examples/cubrid/demodb/tables/records/NationRecord.java @@ -0,0 +1,86 @@ +/** + * This class is generated by jOOQ + */ +package org.jooq.examples.cubrid.demodb.tables.records; + +/** + * This class is generated by jOOQ. + */ +@javax.persistence.Entity +@javax.persistence.Table(name = "nation", schema = "PUBLIC") +public class NationRecord extends org.jooq.impl.UpdatableRecordImpl { + + private static final long serialVersionUID = -126024393; + + /** + * An uncommented item + * + * PRIMARY KEY + */ + public void setCode(java.lang.String value) { + setValue(org.jooq.examples.cubrid.demodb.tables.Nation.NATION.CODE, value); + } + + /** + * An uncommented item + * + * PRIMARY KEY + */ + @javax.persistence.Id + @javax.persistence.Column(name = "code", unique = true, nullable = false, length = 3) + public java.lang.String getCode() { + return getValue(org.jooq.examples.cubrid.demodb.tables.Nation.NATION.CODE); + } + + /** + * An uncommented item + */ + public void setName(java.lang.String value) { + setValue(org.jooq.examples.cubrid.demodb.tables.Nation.NATION.NAME, value); + } + + /** + * An uncommented item + */ + @javax.persistence.Column(name = "name", nullable = false, precision = 40) + public java.lang.String getName() { + return getValue(org.jooq.examples.cubrid.demodb.tables.Nation.NATION.NAME); + } + + /** + * An uncommented item + */ + public void setContinent(java.lang.String value) { + setValue(org.jooq.examples.cubrid.demodb.tables.Nation.NATION.CONTINENT, value); + } + + /** + * An uncommented item + */ + @javax.persistence.Column(name = "continent", precision = 10) + public java.lang.String getContinent() { + return getValue(org.jooq.examples.cubrid.demodb.tables.Nation.NATION.CONTINENT); + } + + /** + * An uncommented item + */ + public void setCapital(java.lang.String value) { + setValue(org.jooq.examples.cubrid.demodb.tables.Nation.NATION.CAPITAL, value); + } + + /** + * An uncommented item + */ + @javax.persistence.Column(name = "capital", precision = 30) + public java.lang.String getCapital() { + return getValue(org.jooq.examples.cubrid.demodb.tables.Nation.NATION.CAPITAL); + } + + /** + * Create a detached NationRecord + */ + public NationRecord() { + super(org.jooq.examples.cubrid.demodb.tables.Nation.NATION); + } +} diff --git a/jOOQ-test/examples/org/jooq/examples/cubrid/demodb/tables/records/OlympicRecord.java b/jOOQ-test/examples/org/jooq/examples/cubrid/demodb/tables/records/OlympicRecord.java new file mode 100644 index 0000000000..49a84e9fc6 --- /dev/null +++ b/jOOQ-test/examples/org/jooq/examples/cubrid/demodb/tables/records/OlympicRecord.java @@ -0,0 +1,146 @@ +/** + * This class is generated by jOOQ + */ +package org.jooq.examples.cubrid.demodb.tables.records; + +/** + * This class is generated by jOOQ. + */ +@javax.persistence.Entity +@javax.persistence.Table(name = "olympic", schema = "PUBLIC") +public class OlympicRecord extends org.jooq.impl.UpdatableRecordImpl { + + private static final long serialVersionUID = -57913018; + + /** + * An uncommented item + * + * PRIMARY KEY + */ + public void setHostYear(java.lang.Integer value) { + setValue(org.jooq.examples.cubrid.demodb.tables.Olympic.OLYMPIC.HOST_YEAR, value); + } + + /** + * An uncommented item + * + * PRIMARY KEY + */ + @javax.persistence.Id + @javax.persistence.Column(name = "host_year", unique = true, nullable = false) + public java.lang.Integer getHostYear() { + return getValue(org.jooq.examples.cubrid.demodb.tables.Olympic.OLYMPIC.HOST_YEAR); + } + + /** + * An uncommented item + */ + public void setHostNation(java.lang.String value) { + setValue(org.jooq.examples.cubrid.demodb.tables.Olympic.OLYMPIC.HOST_NATION, value); + } + + /** + * An uncommented item + */ + @javax.persistence.Column(name = "host_nation", nullable = false, precision = 40) + public java.lang.String getHostNation() { + return getValue(org.jooq.examples.cubrid.demodb.tables.Olympic.OLYMPIC.HOST_NATION); + } + + /** + * An uncommented item + */ + public void setHostCity(java.lang.String value) { + setValue(org.jooq.examples.cubrid.demodb.tables.Olympic.OLYMPIC.HOST_CITY, value); + } + + /** + * An uncommented item + */ + @javax.persistence.Column(name = "host_city", nullable = false, precision = 20) + public java.lang.String getHostCity() { + return getValue(org.jooq.examples.cubrid.demodb.tables.Olympic.OLYMPIC.HOST_CITY); + } + + /** + * An uncommented item + */ + public void setOpeningDate(java.sql.Date value) { + setValue(org.jooq.examples.cubrid.demodb.tables.Olympic.OLYMPIC.OPENING_DATE, value); + } + + /** + * An uncommented item + */ + @javax.persistence.Column(name = "opening_date", nullable = false) + public java.sql.Date getOpeningDate() { + return getValue(org.jooq.examples.cubrid.demodb.tables.Olympic.OLYMPIC.OPENING_DATE); + } + + /** + * An uncommented item + */ + public void setClosingDate(java.sql.Date value) { + setValue(org.jooq.examples.cubrid.demodb.tables.Olympic.OLYMPIC.CLOSING_DATE, value); + } + + /** + * An uncommented item + */ + @javax.persistence.Column(name = "closing_date", nullable = false) + public java.sql.Date getClosingDate() { + return getValue(org.jooq.examples.cubrid.demodb.tables.Olympic.OLYMPIC.CLOSING_DATE); + } + + /** + * An uncommented item + */ + public void setMascot(java.lang.String value) { + setValue(org.jooq.examples.cubrid.demodb.tables.Olympic.OLYMPIC.MASCOT, value); + } + + /** + * An uncommented item + */ + @javax.persistence.Column(name = "mascot", precision = 20) + public java.lang.String getMascot() { + return getValue(org.jooq.examples.cubrid.demodb.tables.Olympic.OLYMPIC.MASCOT); + } + + /** + * An uncommented item + */ + public void setSlogan(java.lang.String value) { + setValue(org.jooq.examples.cubrid.demodb.tables.Olympic.OLYMPIC.SLOGAN, value); + } + + /** + * An uncommented item + */ + @javax.persistence.Column(name = "slogan", precision = 40) + public java.lang.String getSlogan() { + return getValue(org.jooq.examples.cubrid.demodb.tables.Olympic.OLYMPIC.SLOGAN); + } + + /** + * An uncommented item + */ + public void setIntroduction(java.lang.String value) { + setValue(org.jooq.examples.cubrid.demodb.tables.Olympic.OLYMPIC.INTRODUCTION, value); + } + + /** + * An uncommented item + */ + @javax.persistence.Column(name = "introduction", precision = 1500) + public java.lang.String getIntroduction() { + return getValue(org.jooq.examples.cubrid.demodb.tables.Olympic.OLYMPIC.INTRODUCTION); + } + + /** + * Create a detached OlympicRecord + */ + public OlympicRecord() { + super(org.jooq.examples.cubrid.demodb.tables.Olympic.OLYMPIC); + } +} diff --git a/jOOQ-test/examples/org/jooq/examples/cubrid/demodb/tables/records/ParticipantRecord.java b/jOOQ-test/examples/org/jooq/examples/cubrid/demodb/tables/records/ParticipantRecord.java new file mode 100644 index 0000000000..f59244d28f --- /dev/null +++ b/jOOQ-test/examples/org/jooq/examples/cubrid/demodb/tables/records/ParticipantRecord.java @@ -0,0 +1,106 @@ +/** + * This class is generated by jOOQ + */ +package org.jooq.examples.cubrid.demodb.tables.records; + +/** + * This class is generated by jOOQ. + */ +@javax.persistence.Entity +@javax.persistence.Table(name = "participant", schema = "PUBLIC", uniqueConstraints = { + @javax.persistence.UniqueConstraint(columnNames = {"host_year", "nation_code"}) +}) +public class ParticipantRecord extends org.jooq.impl.UpdatableRecordImpl { + + private static final long serialVersionUID = 934168601; + + /** + * An uncommented item + * + * PRIMARY KEY + */ + public void setHostYear(java.lang.Integer value) { + setValue(org.jooq.examples.cubrid.demodb.tables.Participant.PARTICIPANT.HOST_YEAR, value); + } + + /** + * An uncommented item + * + * PRIMARY KEY + */ + @javax.persistence.Column(name = "host_year", nullable = false) + public java.lang.Integer getHostYear() { + return getValue(org.jooq.examples.cubrid.demodb.tables.Participant.PARTICIPANT.HOST_YEAR); + } + + /** + * An uncommented item + * + * PRIMARY KEY + */ + public void setNationCode(java.lang.String value) { + setValue(org.jooq.examples.cubrid.demodb.tables.Participant.PARTICIPANT.NATION_CODE, value); + } + + /** + * An uncommented item + * + * PRIMARY KEY + */ + @javax.persistence.Column(name = "nation_code", nullable = false, length = 3) + public java.lang.String getNationCode() { + return getValue(org.jooq.examples.cubrid.demodb.tables.Participant.PARTICIPANT.NATION_CODE); + } + + /** + * An uncommented item + */ + public void setGold(java.lang.Integer value) { + setValue(org.jooq.examples.cubrid.demodb.tables.Participant.PARTICIPANT.GOLD, value); + } + + /** + * An uncommented item + */ + @javax.persistence.Column(name = "gold") + public java.lang.Integer getGold() { + return getValue(org.jooq.examples.cubrid.demodb.tables.Participant.PARTICIPANT.GOLD); + } + + /** + * An uncommented item + */ + public void setSilver(java.lang.Integer value) { + setValue(org.jooq.examples.cubrid.demodb.tables.Participant.PARTICIPANT.SILVER, value); + } + + /** + * An uncommented item + */ + @javax.persistence.Column(name = "silver") + public java.lang.Integer getSilver() { + return getValue(org.jooq.examples.cubrid.demodb.tables.Participant.PARTICIPANT.SILVER); + } + + /** + * An uncommented item + */ + public void setBronze(java.lang.Integer value) { + setValue(org.jooq.examples.cubrid.demodb.tables.Participant.PARTICIPANT.BRONZE, value); + } + + /** + * An uncommented item + */ + @javax.persistence.Column(name = "bronze") + public java.lang.Integer getBronze() { + return getValue(org.jooq.examples.cubrid.demodb.tables.Participant.PARTICIPANT.BRONZE); + } + + /** + * Create a detached ParticipantRecord + */ + public ParticipantRecord() { + super(org.jooq.examples.cubrid.demodb.tables.Participant.PARTICIPANT); + } +} diff --git a/jOOQ-test/examples/org/jooq/examples/cubrid/demodb/tables/records/RecordRecord.java b/jOOQ-test/examples/org/jooq/examples/cubrid/demodb/tables/records/RecordRecord.java new file mode 100644 index 0000000000..d5250b2979 --- /dev/null +++ b/jOOQ-test/examples/org/jooq/examples/cubrid/demodb/tables/records/RecordRecord.java @@ -0,0 +1,129 @@ +/** + * This class is generated by jOOQ + */ +package org.jooq.examples.cubrid.demodb.tables.records; + +/** + * This class is generated by jOOQ. + */ +@javax.persistence.Entity +@javax.persistence.Table(name = "record", schema = "PUBLIC", uniqueConstraints = { + @javax.persistence.UniqueConstraint(columnNames = {"host_year", "event_code", "athlete_code", "medal"}) +}) +public class RecordRecord extends org.jooq.impl.UpdatableRecordImpl { + + private static final long serialVersionUID = 373569526; + + /** + * An uncommented item + * + * PRIMARY KEY + */ + public void setHostYear(java.lang.Integer value) { + setValue(org.jooq.examples.cubrid.demodb.tables.Record.RECORD.HOST_YEAR, value); + } + + /** + * An uncommented item + * + * PRIMARY KEY + */ + @javax.persistence.Column(name = "host_year", nullable = false) + public java.lang.Integer getHostYear() { + return getValue(org.jooq.examples.cubrid.demodb.tables.Record.RECORD.HOST_YEAR); + } + + /** + * An uncommented item + * + * PRIMARY KEY + */ + public void setEventCode(java.lang.Integer value) { + setValue(org.jooq.examples.cubrid.demodb.tables.Record.RECORD.EVENT_CODE, value); + } + + /** + * An uncommented item + * + * PRIMARY KEY + */ + @javax.persistence.Column(name = "event_code", nullable = false) + public java.lang.Integer getEventCode() { + return getValue(org.jooq.examples.cubrid.demodb.tables.Record.RECORD.EVENT_CODE); + } + + /** + * An uncommented item + * + * PRIMARY KEY + */ + public void setAthleteCode(java.lang.Integer value) { + setValue(org.jooq.examples.cubrid.demodb.tables.Record.RECORD.ATHLETE_CODE, value); + } + + /** + * An uncommented item + * + * PRIMARY KEY + */ + @javax.persistence.Column(name = "athlete_code", nullable = false) + public java.lang.Integer getAthleteCode() { + return getValue(org.jooq.examples.cubrid.demodb.tables.Record.RECORD.ATHLETE_CODE); + } + + /** + * An uncommented item + * + * PRIMARY KEY + */ + public void setMedal(java.lang.String value) { + setValue(org.jooq.examples.cubrid.demodb.tables.Record.RECORD.MEDAL, value); + } + + /** + * An uncommented item + * + * PRIMARY KEY + */ + @javax.persistence.Column(name = "medal", nullable = false, length = 1) + public java.lang.String getMedal() { + return getValue(org.jooq.examples.cubrid.demodb.tables.Record.RECORD.MEDAL); + } + + /** + * An uncommented item + */ + public void setScore(java.lang.String value) { + setValue(org.jooq.examples.cubrid.demodb.tables.Record.RECORD.SCORE, value); + } + + /** + * An uncommented item + */ + @javax.persistence.Column(name = "score", precision = 20) + public java.lang.String getScore() { + return getValue(org.jooq.examples.cubrid.demodb.tables.Record.RECORD.SCORE); + } + + /** + * An uncommented item + */ + public void setUnit(java.lang.String value) { + setValue(org.jooq.examples.cubrid.demodb.tables.Record.RECORD.UNIT, value); + } + + /** + * An uncommented item + */ + @javax.persistence.Column(name = "unit", precision = 5) + public java.lang.String getUnit() { + return getValue(org.jooq.examples.cubrid.demodb.tables.Record.RECORD.UNIT); + } + + /** + * Create a detached RecordRecord + */ + public RecordRecord() { + super(org.jooq.examples.cubrid.demodb.tables.Record.RECORD); + } +} diff --git a/jOOQ-test/examples/org/jooq/examples/cubrid/demodb/tables/records/StadiumRecord.java b/jOOQ-test/examples/org/jooq/examples/cubrid/demodb/tables/records/StadiumRecord.java new file mode 100644 index 0000000000..230ef6508f --- /dev/null +++ b/jOOQ-test/examples/org/jooq/examples/cubrid/demodb/tables/records/StadiumRecord.java @@ -0,0 +1,116 @@ +/** + * This class is generated by jOOQ + */ +package org.jooq.examples.cubrid.demodb.tables.records; + +/** + * This class is generated by jOOQ. + */ +@javax.persistence.Entity +@javax.persistence.Table(name = "stadium", schema = "PUBLIC") +public class StadiumRecord extends org.jooq.impl.UpdatableRecordImpl { + + private static final long serialVersionUID = 1748878530; + + /** + * An uncommented item + * + * PRIMARY KEY + */ + public void setCode(java.lang.Integer value) { + setValue(org.jooq.examples.cubrid.demodb.tables.Stadium.STADIUM.CODE, value); + } + + /** + * An uncommented item + * + * PRIMARY KEY + */ + @javax.persistence.Id + @javax.persistence.Column(name = "code", unique = true, nullable = false) + public java.lang.Integer getCode() { + return getValue(org.jooq.examples.cubrid.demodb.tables.Stadium.STADIUM.CODE); + } + + /** + * An uncommented item + */ + public void setNationCode(java.lang.String value) { + setValue(org.jooq.examples.cubrid.demodb.tables.Stadium.STADIUM.NATION_CODE, value); + } + + /** + * An uncommented item + */ + @javax.persistence.Column(name = "nation_code", nullable = false, length = 3) + public java.lang.String getNationCode() { + return getValue(org.jooq.examples.cubrid.demodb.tables.Stadium.STADIUM.NATION_CODE); + } + + /** + * An uncommented item + */ + public void setName(java.lang.String value) { + setValue(org.jooq.examples.cubrid.demodb.tables.Stadium.STADIUM.NAME, value); + } + + /** + * An uncommented item + */ + @javax.persistence.Column(name = "name", nullable = false, precision = 50) + public java.lang.String getName() { + return getValue(org.jooq.examples.cubrid.demodb.tables.Stadium.STADIUM.NAME); + } + + /** + * An uncommented item + */ + public void setArea(java.math.BigDecimal value) { + setValue(org.jooq.examples.cubrid.demodb.tables.Stadium.STADIUM.AREA, value); + } + + /** + * An uncommented item + */ + @javax.persistence.Column(name = "area", precision = 10, scale = 2) + public java.math.BigDecimal getArea() { + return getValue(org.jooq.examples.cubrid.demodb.tables.Stadium.STADIUM.AREA); + } + + /** + * An uncommented item + */ + public void setSeats(java.lang.Integer value) { + setValue(org.jooq.examples.cubrid.demodb.tables.Stadium.STADIUM.SEATS, value); + } + + /** + * An uncommented item + */ + @javax.persistence.Column(name = "seats") + public java.lang.Integer getSeats() { + return getValue(org.jooq.examples.cubrid.demodb.tables.Stadium.STADIUM.SEATS); + } + + /** + * An uncommented item + */ + public void setAddress(java.lang.String value) { + setValue(org.jooq.examples.cubrid.demodb.tables.Stadium.STADIUM.ADDRESS, value); + } + + /** + * An uncommented item + */ + @javax.persistence.Column(name = "address", precision = 100) + public java.lang.String getAddress() { + return getValue(org.jooq.examples.cubrid.demodb.tables.Stadium.STADIUM.ADDRESS); + } + + /** + * Create a detached StadiumRecord + */ + public StadiumRecord() { + super(org.jooq.examples.cubrid.demodb.tables.Stadium.STADIUM); + } +} diff --git a/jOOQ-test/launch/GenerationTool CUBRID demodb.launch b/jOOQ-test/launch/GenerationTool CUBRID demodb.launch new file mode 100644 index 0000000000..b306e66e55 --- /dev/null +++ b/jOOQ-test/launch/GenerationTool CUBRID demodb.launch @@ -0,0 +1,33 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/jOOQ-test/launch/Meta-Generate CUBRID dba.launch b/jOOQ-test/launch/Meta-Generate CUBRID dba.launch new file mode 100644 index 0000000000..c4db76a207 --- /dev/null +++ b/jOOQ-test/launch/Meta-Generate CUBRID dba.launch @@ -0,0 +1,31 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/jOOQ-test/lib/JDBC-8.4.1.1018-cubrid.jar b/jOOQ-test/lib/JDBC-8.4.1.1018-cubrid.jar new file mode 100644 index 0000000000000000000000000000000000000000..7828f1d66eda8a869c25ee4fd291294fafbd0b4c GIT binary patch literal 198347 zcmb4qbCf1ewrzFUwr$(CZQHhOblK{!%r1XrtIKwm)n&W-_1u|z-06_NSJ zj>xlC>^OPigt`cWjG`pd=MNAN<$pk-K_>n{ z6}m*94gWxG|1|VJ?SG&OB8oDS5^Cy<3X*pUlN0iC42*LKatyT7lQT`K%!_P0hpv-i zs4n!<^3&29AhBO4rXJvZ+VkR6(d1Os-1BKgeknY_?;%XNr^3ghvxmyvq5HF?#@)uz z#mT9<#bNN@r980vw0pPzk3IixI@BL~%sfn8ZOobe+vtA>!T(>7t+}b$Um(%`1!?YT z<7wgg7Xy(0Wq_@j&Ho45-pT6!1MO(x{ugMJf3d{F-Nybe;BfyJ?&k7WK!`s;TN6){ zznBZ=zaf7;6XZW&-hVOG-w67*w|O)DzjHzV7iD*n@Vg-XybBB!1cdAl?jP&^UrYLr zg%Z;cRh1DJwRbXQG_yBxb4$?naaJ28_#{kuI5@U~=Nwp#LE&n&2avNf4)26=hvKgx zW=(uu_!j-mWJ!M%iE6YEx{L50ofzf}7+#FU>{verAH3VIKnK@YA@nx7y?5vQF4f z%UNwBV53d?D=4Zgm-wW%KHENDi?e8^@l{M#S$JuGfw2Z8T> z0~D{)_?LhSnJK4?a{Ovt1}vEdpo0^c-P8r9 z&bXJe|Bp1!FJFzM|7A#vaoU(O=bN-k+O-B!$#accQ9r(5Jg3e4THcAej%Dm z?%Latu6#Y8ejrjhI`BtmWMvx#WXHqFqk80zvO$5@qOWn|-pR?E1ykLDCQB&GQ$5dt zFq}#bao|>kgilDL57=7#3?b{?fxhT&k(Clrd^I`J759slsBl?fG2XTzF&aL)x@Ed< zh?1s}&J6Zf4{gvv7zJt0=fhy5##4J4f>G?BQS~ftX+c9A+I6X)c+Y4kk^}Ssr9zw>x2F8U} zYfYm6VZba(B0`hWKwgY#6i3rcW)24OJQ8IyvxGrG-r?hAprex-gGjx*IO-f>KoiM4 ztsDihY?r8X^=fpK_NNSUwJE`}oHn}!2CH-GjR1z#cUf#dnUM)v!~SYoO@PcWZcYBQ zWLb*nQ%$U;zvl4M4H!l}NyT0uxJ6gp9{x||8?mm+J$}XtZ@FjNQB9Z!HQh%lU%!V6 z!XN#FNo$LHHPVR{(8msQ`f1R+D^^1cP%*8B!7QbP zbS zJa=0S99b>{Y&@kO83~^Vx!>lb*@qKKBY8?95|mezUw>YM5AEvt} z$lMeRqDi}yR7bVMpFx~Z2~%@(=$L~KJEV|iBkn^3acnTQ|iM6_Vs94^ETy;i-*&a1CQwm;BZ78=f$pNV$B#g0eP zOH;6PV?{6MmsUr1beQhOlb(U|?eWNne6(xe{9rD&;;LmV)LS?hul=r#1NSo2j)jW* z0$M#%-VnP#bKTAf*7Q=yZj~_ZuBimu z8Q_NAD))UQAUfNO`j?(E6#> zTWv&jz^OKBPnBD59M<~V^R*KVDn=bMs@a&}RsDJ6m(D33mwv`km+E;AyXOu~R-01B zG;*;TTIznW`#P84+Ne}FtVwCBlXm20Abz)Ai@EhrNE2sl~)fi zXyB%PN6BJ$z%DC(wVcGU!e5A5*}kXGu#z{DlXJUvRn*lWoh1{Yvs;&9fT*Q{>V|va znE6rBS~p^W#NjsGQ=dE)lS`BzF?CpxGCCvw>;>~%@7Q_A0BB(F9MOc5Ki!H7?yI}Qso=|IaLK0V(o zYvt5~3133v7P82e9$|5^_buv zz9By!Hx~Wal$@Z7`Bf;RO3S^s5LzQ|$Ze-Fta}WK+UXD`I$%FP)hZ_fQ5CgR z0xR`BwdQ&vZ!%R_BVXVb85AR2@x@G2(WeAl{YCvnex&p<*XE7zYN^1MxH3xPSt~1= zlDJ&DA_MA3GszaUhjd1JBs(W)c#qd|SGKargeAOC@zx*qU zZmY<|`mBO$MlxoHY`jcuDzMT9*D7&Pc!APGwY2*@q0O_mL^hxpDHT%w3_L0QQOe=1 zuJ~(}TKU*hp5JBr_RCFvZtv%(8B`y)C5O8Sd8C=Q9DRrOJTAOByRDT*ysa|JH&b~r zc(Oh6>RpHUYHz9G@JKT5@?x}O4f!f>tx)}{b_$qE(RPj7JXz0nRaz^$f+kbHwKXNT zyQ6e`f-;H-0)-8P=n!EjoAk9P>@gXIg1d2YlDf-2-T>azs;ez49R=3Y6H8O7-1xJ$EFG z9r_)7EZ)eZg7bOf?UwNvg8Hd;x*II)hGX~1Blk~6Zn%AC@kU|ptGt;KpI9)YP-$Sm z2AK4kel4BrS8I0u;`P{mM7&L9_CGORrhBw)IK*-~-qh@#=f93M!^Kk9k2ixPl0Jc{ zWACl7z^cPoFX{m6+_#)E-B^+X(%(+X%o=Shw(hMLuh)*RfPU@6l5b3~w{5n4Yv1sF7j5A1D@UXtvM%u(=bGw-iRZ5o*X)sFux1 zJUitSvOHg`#&0A1(6D=jgycCi@P{!82M<^j4eb{$fG!!hB7X%6NnCI~q5P0B!%InC z6CcCg6ko+&JU3ih54V4Zg(B9 zj3bRL2`4v7Q| zjhQRfg;Y^+++k<;`UiS1@I+=Y<%M_mltFFZ;p4C|zNPH|;@`|4{nT&JE_YZidlsui z0{uRoR%uy~QY*1vG)$GA^f0NJs%A+KIX?07P{sP_V_P7!^S*r#0P?>$8}+})exJ%)YlRG z;393%WTQKZD4I+$nsM^c?(@@hE4Xtpti~IfH%DfD9qFh5P+_dRvorv>E!NlBnc04| zD#xnR2w#rKKrY*Z9~2%vrr2?1hMw%zUyymeluSrCu3G?_psJ8$!A)Q~?NlmVR&!TOgQ!o$+i!qvk3-#(5WY6@y-BFF)$Nn79Pi-g08cVc5- zQZUl+QGcX>7o(z7!RwY5aE^mx%5b)<4JYwwe1g>b9u7p%LdY?+p9QJN9vpX1{inPCej&O zDGr+V7qXQ#TJ~<48?Ql!Ec${=ZkLWgj!*(XPo>&?jgzJL(?|X}+2Go@@nv~iGHeEP z(}+vT&T-I#lgzO>tTlf@Nuj{!t{c<|x(#=4Jn6&GC4#ng2!y?|FYtma^12W<3QZJ# zA>YWi_=J2o3b2JBLCt_v38hugPJPpoZjrQzfnT5Bt4lyo24J%Jz&dISy&9pcL^VsYQ`cnNd8DtN?LH zsQ*bI4bfKMO32g@ZTBaZ^p&bAIWo-a;5^Df8hVDH@VXTDoNPq%_vTTor{C|g_{CO4 zwz`;c(f+Q|9KOk7AG)`GK^NqsMZ)ti%;EmBJzL0YFBbmt~v0k1KNaL8w z0R#zK4o}+JZ8=K)pgLXZSbKIpgF| zBM04h`igZ{(puKC;7RS%5smed*R0ml5}3gA>>DWH5(A%AmWn&R)YEI>Vs1qXT-K!D zRbalG)AYyZ-JKSQ9Q9Z9+j}I&Sm`uAb#r{`56PJFQrwHWcWA%JJ8;vVI!n|5rmHh0Nn(v+)o(^{I zd3Ij_p)Ay}s9z~2>9qSKU^3D5M=)TtFwB$Hib!U@uioY|w%r?4ugx=LUai#yvT}*N zZg-8AQ$_VQ3E&r!;7IaWUd8lS_$uLiGf>>sZq=Mvk`w`~L*HvR$DQxTnjBaosg1@c z(a-2#t__N+GA>^}hZV_jt_VkF5R@OXiG%Wt#eP-zH7lTK_(kOvL}H>`DAeW@DH=cW zL8c?sL@_Ly-vl;m6kHKSEZ854#N5%ELc}j=EYq7NL#8V*?ofW`GD!4ZLuInM!CIC- zR2f}u4=)-jOEaRkL7S4|a>EX)H?U$rUP}~O%E;2*nAMG6p#az^;x|v;HvN3zMuSjemLX{mMQUYHwF^$ zGTHz)A=RX?wcO)(suJyhb!O;h^Ftiu?BqDjrT~5CZD+^~Gi9r-sD;AI-E2+7(bm_k1IUGF`d zFjDXQxBgh}*KREe!#jg|U8|GIx6qCB8ZE!>BLS4UnPDN^#NurKuiDqR--fUZ*0?eP z*n4yIvYgT;^qr5j&%))|W+NQIAbD|o^*mgWlsZ`B>%4n(oGRH%Ef?x|Er}QIZS_}E zsNqW4N+s@DfjNkCsdt&AG(!B)>$J$zz>SF4GA!W!`_GX&e^+}(w032F} zrSOW>i()iR9KZ0GNeYqrkW<_M(#2UL(vSGHBd078<9OqXvn1NCCupK?Uw-qi)fqFv zV9->tDq17?=4P|Jil+F;YK?W{ z!cZ%@^rY;CqQFti$yRlF-M+Ogqy}ZZ9g#d|j=YfgSSbb7IHvZ&p8*zBLqh=X7TG+B zy3c6hhCRZMI#kdH`T>j^Go~3c7zk+eL9ZA%#ldETB*T9N`)5i!8T)A={-N~wpZ33^ zw3e%l`~Of{Wx{bm8Cihq2H>)VZjH)Z^7Yns4_qD#;j4NYr}AzyL}jT-|BpncJ`GeY zMSa3IS$`0{RnI7O7+6v0$7`k81~F3MvDzn!+qTYhW;YF8xsR5e-KM(iQr7b3lT=*2aO42Dz_x8$q^rPva47<^sC=c zPc#NgruPTtUHk0TTljNzqx#~Iw=QqEa>o2Tp7h(8^}tnDmYkfQzs>IzBn58x;+R-` zot*cJ;Hr2)q(;^E*oPCsd-cRBBf#`gG)vMxdiIFN`cDM?eg)C03gZx0EEl9U8aEU@ zZBoJtvq-diB?&iaf-nC}tWMtaEj>gK5KC?l5az$~m0~9L_9mwG7HaM$?iLOfj_!YV zm$kYu-s(#jf=?DHGL%Tt13AHC)8=f!p|T(pFvh0PvLHIm&#XS-{p0d^+27R}T9&su z_H|n{(mKdUqwyHiHT8d~Iv8x&p6O7 zQ_$p7BPi3Ij}8go-9yse0?3DMI+VfoBNqi8YQG7a<2e^>%VEygZz|`pRan7~9k?97 zyvS6ix4NoK1QRtS%#RJT0xN0<+MhFA>q6$}nX~Kd@PaB?@G9LoZY}J_Y~Skc)tWsg zA*lx~V7ThgFnRPmVY13)70`FS$7^O-7A75q;{-oi+`p~;GrE1Jor4e|k`Eg}QtJ-a ztX2h$b%21w(~H4fxQr1MCR=iKM5I3R$ssz|Q;L9c5~DUzoM5T8RoX3_?ubC4b!=04 z$XWboeHo8*3)AiAk};giFpFgSiH?dDoh>u4Hidj}HKrK%r8< z`IXq+?%rHdoE=O?TuMO4z_2aw%<|KExrObVvR)R2Ahn#&cAHnc&D5|KzmCJXpOu1f zX{pCs_<5A$R&LI&as*W81a}FHUJaEtE0UJ_6264pUWY8%$5vOQ>n``xd7e3I@Mc+FeN|hfn59%vwh;~udt&z1d(~{G2VIB)?Y@?Z+MICg z`VBo)K0d7u=Ek}P15H~GORXH_CPa8CE~fk>REMucW0w(Q&yzVRu8#F(XMq!7C0#sR z6xBQvVcBQUXBLMbT+^;y^A~uH`Y9sapkc4zVIeFlEy!|p5%=hRp#>FQeglMZkpgT# z6P+3f-AVHTJ7|&*iuQ!5QQ5G<&&cu(NKy;ASOCT~Jzh??$|k2ZNH`5yen*Vf2%g~y z-d^ZV`)N3FWltH|OL|N35^=UxOBsNvw716WIwdp4&K~u*o@Hq-cH?P;+r5Brw-GK; zl0a1@!egWzSofTf*V7syhlNw(oT>%S4m~R{?c_|1Gxj*d1sxc?iY5{J?}|^(l@#vq zzXDA#PVJ%bs+vq{)XN8LS`|Ii>(#)f=4=?J7EYmU7b{~D7b~-m%0pk|iqzof#Khp- zd1DioZAe;vHAiEfHK%11U!P|m?>X0WR>O@FHwB1f;&6CtryAifqbXi-bLy9;+lMQ* zU1y(1338@f)HkWvH)kfyt!Z;kPmG+|gXUJS2|3&~y5?&*$H3H}R+4;3p{|8whbP76 z7)UPKE1@u+-RL+egsEkEx+=yWJ$zIrG^JwbZpfO!7li%nx=e5Irh-oz1BW=h2ds9~ zD8YQ$J+Tx9onqy8FRwT>BA{^jdQ4r(tv$~^38 zYAqfu3`xcQ%~RjG3t_+B$DUZzO8mr=s%4MC9Q+~&E;&}oNydpB;Dg=Hk3hEl&K_U& zINMw$RdFp_Rq2}rt5@ZfoX8scYT(Q8A`2;hXHT+q$!C{SzRtDU6c@|iyfiPkm8xvC znewe?5$q#k!OewXs-;Z78{__fM(PBf7jLEM)c?%3vnWP(mNDub7PvztTpJFT7zGCp zEJC<}GhU~}Z-({jx8+S-R)&fwW)MBAj8g=los!1RQ^vy74NL>DyHW%poCxUapzczM zJy^2}L63yM?h>GX&Ok`6LSo<`oTCAZ2KG*k-7!n1ApvfEC;H61Nb!Lb%mW2AW7f)r z*aqNnSYdON(gu){nPGDn#_kl@1{BPqAv?^x5L!KbNEkQ|^!@!!Y>fRXZDJxUFO{gW zv?evGq#g|MhES?2V!t410aMZ_T%aj3867P7sojt7ZG;qTB)fYq+X+Qy~U!iliENZt*3S5T3dLlJ?Ld|(;L0WN!m`5Pa znm_8`9yDbkPFj&kY=cf3ww{!yJ979pFXks+XtnZB+CL(fQ~hBp)fSG4SYI^EZP2?m zk_W`BUbv&Hke4@Y6(Z<(Wji|7^?Idv!N_5yz7sa-07OZn;JHlWdkpLV24>OS`Y~(s zLhKJD%w7QKBBVsTiH!|=;^8d$QE`}dT^}?Qp@gIj77&(9Q<(4w3=n9%NE8nltb&4# z5vCH;2YpN`A^G+cGl$HK3oB`1%#I%~89Wzg%#IrWn2F8cg`F^vj%EAuv`}HeXLEm9 zGRqWdtOmJo(W6*Q zR;9G@5=+Qbfh%d-au-whs!|JTi_uuSKADK(TuoB}l+}U;a=3?*I+g~*sg#p467P6t zS4W;9I~!2PE;&;{11oOdNkJJUZ_x9oz!d4{J8f#eb$ft15_oEH_))l-ykHYSZGmhMo09khi_XWeK($k>SRfqurVTfH#V#X?b2-3PHEs|C^itkp zlLPdUe$i3@xCswDquAt$eQcEmx?y~{RtNJTK{0Un>6HQt>!UXqhd)3iHoH|fnbd~_ zs1N(&&|Q*bx0x6kcTZ1erzsic=ar*U%@vB1m{v#Y~cpjJuh zDMl>!&HG$Dpbhs@;WXMSo%GV7G6krM^3oo`p&EV5Vr=rKgeq|#XX^Dn|*m7z-qWyPpU+ev*WUHa^tk|W4gti+>L z0!53mwrQJYZ%A#PwnN7yaF6B`vty}0;j}WvYhL{HuI;E?zgA!LXGZ9KiG(JYPjGmb z0Sphs7#Kx~DMuv%{qCjmhCwq9s-lb5yd@lv&&Ccm(V}k(#o23)Q$pViR&l>qiWdmo zHQ=+%EhKxunCnD@C~(0yR_MxGGjPh>Tl%ZPHjtCP7w%d#+>HNbo8x_XiIXd(i+M$s z&;bR*HqPdIYq+G%sB%PW8scmQ40|h;jlI`qi|_N&Vi3@w#gy$~)Zmb_YF&hRL(CD1 zU}xH%@9?T9M{oRmj8MFa!~KL&+GP3!vYuP$=q_nt%C#+QS73lq)@`JYP2qmpC|*s$e&K`~ zLt7-fgla=u4Ef7}^;tbFYfmG-h-E=#T^Qp0qf@#iG{6eXJx?U7#C7O*5s$KMp!|3h1!ZNGH^TTKI zJkpsw(m%u1Y7~E$ygtxag$Mg(6sQd)U^>q%!2Kbl-g}|OS#ciimnYL(Ash2Sg$zX{ zrjUHtnZ?&zrlGiyUft(Rj2kw;U8DYw>g6rFe^m>3%SvHAeE|W1{gc%D4+m98GYfka z4+~cxb?ZNR0rP(dFjfDN1o8Yel*Jj5atmEbUJ6v~7v;xf@50qZNB>#`0ppn%AYnkE z=zI|y2qM&vR+9#wO@?j2j>? zk=+EF%j$x-06Cp2UIl3jX$c-rem)+U109_a+>?BdJ>C4#j20ErN$Bp+6+Nhc(>Y}o zr=<6!h02sHfI|TXniCJY+>MTH6RwiAiTVBFH;u!Tz;TVG&{t5i3+9xh1w*NkYQu6l z@wkQPWli!s588c(>Et}~y8DII%!y)CjmKQh?y<}*s@RqeOgScC*QJ9m=7>rwb7V>c z0K3H*JR<@wi^F*?G@-H2W!SCL@cxH^@BV}c>LVGP8|~q{#sJX*xNKBFpvX%?T^bl| zGZ8JqQjk$N)_v15=rFUaIevK<_<}!mYEl(RIXLqV8jkGpW_mDM0mvUFi^O$bVUEGV z0SL)%zr?H+EuaIUfPLT&I6mvuvoB5PE(srXO|OtmR9PEW%^tI-DR+dgz{h}#3#o&A ztc&{h>FzL@@(a_Fp08BqXH^ zoElJUTA=aLlrXNQ@Vz^7kORE?^h9=&5jKidvI!!S+A^D!5LqCb;Am0lpR*kSBp(f& zNFX4GME^m!EA~Ia-C7+ufAz!k--YIumj|ve%;UnK;n)SKGNS0@V`AapUt>r_1^_6` zo92wn$d&{A$g8cM7me$l9-ZkwZqJvo)=j@?QLcUu)@+zv-dbPZT6c8tsIIPUSu(I| z)AXIr&&}o=2YfO1F|xQk8#0WwgbeYQa{)o2dx18>Ybe!aBn$Rbz)bRhnSY>NV&!?2Z7=U`xV}U9bX4r{!S+;}^7mvSfvT(TNI?9q+Syi@?|;&eACZF% zEE-_S$sa({*o@6QJe4Bd*_KHCt$btFMSA=$ZWu(1_q%e(iq>)`Yc|)ayK3hcHn7-~ z(@>2Cu6|-Kh~~L8luLb+Jnrtg4Eot=?uub8P_Mu+V^<3{uy)Tfc_q%v{EDmby)OE9 zZRmE4{G-}5c+%lxj%9Ar(qk<(rZ6F(;l&8a&h&Lr`_=b#;Ud^3RQB49#y)iY zb2uM8lf!wo@vzP)(ACiTC*=~s#VTV$ z73W~w_&OAcAepAj8cf?_7TaWs8e?5wyl3t*40?`4|7tf6zt1%d&VOqH&$tNv=2l-NQNDWW^*Ja|6sA>2Kn{u|~T<6$& zw8L4IgK=TGCfu{=y8L(u2$Z@^U4pQ1E3DZ^8vVnXy^YM!g{`kC4>3(6oAlT0kts#Mx5#~XSio5`ZF$XGJ zFQC+Y)dPUKM{8>oli=F0tA~Xk;BuNS9GaJGk#$Ajimuj}z;&>T&(@mc!n@$0^3O8k z*6k8CC;?Co=Dy>3p_ReY@>$fO$V0H14D7%}C(EhC;7YKfqgB;YuVsKh_e{jLCC7T# z!;|T}#V2V-n#EjRO0zqH>vbelFpiaxEL*4TysfBzQ>o-9=o3khT)>VPu~nDcXQwT< zW3TGV%!c)9Xu%l|ah_f6w<)p^3m`{99AQ;;VY(z+)SpxKLnKi*Tvp|))#fpbgu(5J zg{mLXt2}q3a4M}3zZFlQ++|FlOsz5zdbDMa@DF#vxywZ}Fqj}MW@cNxt}zEXLq~Dk zs-;Jcx_r%z?vXdX8~)~OMLyPVW>#wnrHnwB4#$(u+!d4;quYXO5I4%+p%`hyZU8v5 zi4^s~ol48Zv&N*F{SqSuSVL`>IE7s>y;~ylPE+>O(Pqc*H`Bo_ZG?L=)A5K>Q-1CK zBcZ$}`A|)*1yLfr-yDf}K#2RBAbSZG9wDOb%%Ir#?NNRI_!=VoH|wRmRuIkIJk%D6 z2YLF3eotSHFB_iMZ9pvE2P={hH6=d(TRBXrS}X;x=_xIrv`w~mJLfR{swDyaC01qCtnlK7lOO)xwu5{N&qI>ejRsxm=CQEI`V{nJ+pHO`X20uE#0Jr z2jBwRCg`=pLTmPfRlK@^MoydS9+xvXP=9X%_{4J6WEpO(ja) zDc;MyPLFURGqA%?)0UI59Y9^khpfr7q;q{*y!x$n>n6V}uJjX5)R!MM9Z%Qh>mAPAJ%86!Kl%C_yczA-0WQcO#VAe0Tfm*l*1L; zi_nV8UAA01k6Qw#730Fuq(eB5+c4*`!}4T)1kY&gQ#gm4UjMCE)(js@WTDq?{qsv| zmn)(oxA*1kQ}BEDnBCpMQ=bc}V(+NOdH^acQ^$s{vNNjf5*+pU@YhzV;s@iCwW?hT z8FbFKYDLqmLY+vq)9BV+3J!tmJn`h-SMu18$>VgB5_o_)HBbLBir}!BK;#`Tl%wJ} z>3o=am?6GT_W3*P!V8->=km4Hvo5{)d&a(JjV1UBYhdUOq@+EZ*^^Dij)3`eL|c)AkBDxb=CCZBjysD%nNhmg`oXPQWjj3q9IwKt<^o=K~&k+Nb1Dh4xI zppckD-x~2d@q+AVwEC-HU?Bq29TfI*;+-?wT`Gw7w=e-ApbJ%aPz_Z@qR7omPv5@P zV(o9dA7Th(?PRZp$&9{h*jJh*a2?;UI2 zJ~qEcr79x2PWR2;e~^lwqVx9(8rX&w8a8={SK85#yu#7}ZpZbuISY*(1HBXBT~VTZ z37~c!d7F~&dAp_`zC8|N&&T1MfA82lVLkptZ{?UI)0df)-;0cIS7Qku<Jy73Q_Uv|bNIN%`RJWvm;UHDPE8?Ix?ODLCagRX1 zA0C!eDpz6-KI2tq2{p*t;Ev3>Z?O2>+JVxE@K5UJ;a7^sB5REcyfK&S7d+vQu=fgK zj6IwI&1Fy15NOI(8B(m7VKf4ge4_3WGpa}Yb#5D_MqWN30`ws`F{kt36mWHMGvVMSm^oTtajh!YNbS^pZEk+C zp2bJ0Bs2I#x0s9vmC~cdbYhz*6PWR$p`AjiFVO4H6qaz!;nNr4%?aPRuq~P4aO`mE zMtkapCp2U0Q3orjka;dJcn9Y=XJzcc*p9I1Mv}Me(bx95HKSr#V;BOKyrUckqnabp zbtejE+ZLqfoBZ2^0wjJOEHY}HMQ_?EE>-UA#JjN>HB(qMp*3Jv9{B0YfFH@m9dd1t z-WMh7)s~7fTecN^8K7eRf%-OEcvx>c!9|v294m8BKb^@TH4Et}lt}A6+R0F58#v8;OR+QZdTu&5hP8B-yvd9hsfnvDB`hH^?XoEqdk|(}! zQ(6h)bhNLVqV2g1Pt0}PQ~F4%P$>CjYn!4wF*ogjQ z{BpB~C>K~c7${8Q^>qzubE@A9NpkkM(e#b(nTqf*n6)5cfyVpkEJj-PNvmB)CRy>Q zjlW>H-Bts&mJ|DsNxO)tf#d1!hgjHc4R+rh$ldv2dQ`*8-r7Ku`ReIF>d=pm3R!_# z+bUn&>KL>U>%eDlmo*1H-4Avn7yJ;w%UJ1(67w1PC2aXERImWXg;g|?F)D#5MgWA` zDYLClf#kO%vdxg>bRsovpqiJHLl8G%2>yMRguu*?GC*}fe@6gy9dDG!-orQB)VD{# zOLp)>w8%a8@m0MDpx*5>Fw~21bfsodYd}}l$(`Nn8Gc!i?xlQdlw!$cP|YwSCVP;w zm_GyWX_AibqM$a7U}TfE>7vqY{aZtqdU9YiS;Mr-rN{a5ai$MJzfafEj_26fYS8Hb z%7LFj>5puvH$|t61-W#1-ZmF4INpAid-Bm)HDIKiD2B`X9F2Ur;bh4|mVy;fH2)Cj zi|KHWzdU!xe8Mj%gXN56Ftl|~uqm~@ukDwtwjh_66Bs>uI;zw5c*bqJ+Y)_4yOW>E z6t;5sTFmy*Q5^7G1Cdpgc{R>BL*u_SuRPtxJIXtZSbQ%R%br^2YJ;0Sc9xQn!Z-Dx zkFd$wo}}+v#=lRP#GfJOm;H)+-;uPQ6VCp<%?w?r=SSaXUPu5!>ZymmRPPYJZp4Z#!1fhRXuS9m_nvML)+X(+Dy#32ckG~ze|4qyqp>E)Yrhy%(*qE!(Dkr9= zD(xUG6zs^^iqc>80jeh48Yv0ASgCPFsk4{i&SlS;zpP@_Wjum+2^^fku>{g!O|LGa zly{qt5S8{=;iWRu>K}9+clk`;30{q^34Ojh5cTPtu)Z>5iZH47l$cvfPk3YOzjKo; zq$FSG#50eO=cSXF#hV#sx*#4?bdi{-N^<>7LmAdX{h7f$Oq^Dwm`svQ#}QknFw3<%G;FzyCaI`8}1xvL= zl>EkHK?6}e+WK_9bYYDsJMxY+hv+c_2+q3@*qif>9&_dZrdp(hyuadVr1`Cy$8e?IC zXSh1j;0S{sQ1;oI%Yd&iGB%;Im?w4{`tV}XTj6KoYSG4@+CiX-b-yT^v1{E~5K-G< zm2w`v+cBa!Ug^MMZCi&hhP5)8!d3e_O77`6nL?DqT@`Y z_q!Q6K(*=(b%R5c+2j{v3CgiDHA@2oPiIMJ&d6X$UXL3d;Xr4IAzK$_W*^XZ4+X># zA&E$Hyrb*-hssYsq&AsSd(VRVMAqat*{soguLWM)4;9rod$Q&H;aIpwVcO{$;4Eb0 z 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%0ApuJo7QSVI&CMK?h$CPG^;9-_2dS*|MAYXF5_ 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

^EZH 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 jfB_o(eOhX*W&qF1L{vA=_Jp~| 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 Rlo?`D)kYr{r)wkl+e;0Py9eCR>{`hwPu| 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 extends AbstractDataType { try { Class.forName(ASEDataType.class.getName()); + Class.forName(CUBRIDDataType.class.getName()); Class.forName(DB2DataType.class.getName()); Class.forName(DerbyDataType.class.getName()); Class.forName(H2DataType.class.getName()); diff --git a/jOOQ/src/main/java/org/jooq/util/cubrid/CUBRIDDataType.java b/jOOQ/src/main/java/org/jooq/util/cubrid/CUBRIDDataType.java new file mode 100644 index 0000000000..6c60d9cebc --- /dev/null +++ b/jOOQ/src/main/java/org/jooq/util/cubrid/CUBRIDDataType.java @@ -0,0 +1,141 @@ +/** + * Copyright (c) 2009-2012, Lukas Eder, lukas.eder@gmail.com + * All rights reserved. + * + * This software is licensed to you under the Apache License, Version 2.0 + * (the "License"); You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * . Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * . Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * . Neither the name "jOOQ" nor the names of its contributors may be + * used to endorse or promote products derived from this software without + * specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ + +package org.jooq.util.cubrid; + +import java.math.BigDecimal; +import java.math.BigInteger; +import java.sql.Date; +import java.sql.Time; +import java.sql.Timestamp; + +import org.jooq.DataType; +import org.jooq.SQLDialect; +import org.jooq.impl.AbstractDataType; +import org.jooq.impl.SQLDataType; + +/** + * Supported data types for the {@link SQLDialect#CUBRID} dialect + * + * @author Lukas Eder + */ +public class CUBRIDDataType extends AbstractDataType { + + /** + * Generated UID + */ + private static final long serialVersionUID = -5677365115109672781L; + + // ------------------------------------------------------------------------- + // Default SQL data types and synonyms thereof + // ------------------------------------------------------------------------- + + public static final CUBRIDDataType INT = new CUBRIDDataType(SQLDataType.INTEGER, "int"); + public static final CUBRIDDataType INTEGER = new CUBRIDDataType(SQLDataType.INTEGER, "integer"); + public static final CUBRIDDataType SHORT = new CUBRIDDataType(SQLDataType.SMALLINT, "short"); + public static final CUBRIDDataType SMALLINT = new CUBRIDDataType(SQLDataType.SMALLINT, "smallint"); + public static final CUBRIDDataType BIGINT = new CUBRIDDataType(SQLDataType.BIGINT, "bigint"); + public static final CUBRIDDataType DECIMAL = new CUBRIDDataType(SQLDataType.DECIMAL, "decimal"); + public static final CUBRIDDataType DEC = new CUBRIDDataType(SQLDataType.DECIMAL, "dec"); + public static final CUBRIDDataType NUMERIC = new CUBRIDDataType(SQLDataType.DECIMAL, "numeric"); + public static final CUBRIDDataType FLOAT = new CUBRIDDataType(SQLDataType.REAL, "float"); + public static final CUBRIDDataType REAL = new CUBRIDDataType(SQLDataType.REAL, "real"); + public static final CUBRIDDataType DOUBLE = new CUBRIDDataType(SQLDataType.DOUBLE, "double"); + public static final CUBRIDDataType DOUBLEPRECISION = new CUBRIDDataType(SQLDataType.DOUBLE, "double precision"); + + public static final CUBRIDDataType VARCHAR = new CUBRIDDataType(SQLDataType.VARCHAR, "varchar"); + public static final CUBRIDDataType CHARVARYING = new CUBRIDDataType(SQLDataType.VARCHAR, "char varying"); + public static final CUBRIDDataType CHARACTERVARYING = new CUBRIDDataType(SQLDataType.VARCHAR, "character varying"); + public static final CUBRIDDataType CHAR = new CUBRIDDataType(SQLDataType.CHAR, "char"); + public static final CUBRIDDataType CHARACTER = new CUBRIDDataType(SQLDataType.CHAR, "character"); + public static final CUBRIDDataType STRING = new CUBRIDDataType(SQLDataType.VARCHAR, "string"); + public static final CUBRIDDataType NCHAR = new CUBRIDDataType(SQLDataType.NCHAR, "nchar"); + public static final CUBRIDDataType NCHARVARYING = new CUBRIDDataType(SQLDataType.NVARCHAR, "nchar varying"); + public static final CUBRIDDataType NATIONALCHARVARYING = new CUBRIDDataType(SQLDataType.NVARCHAR, "national char varying"); + public static final CUBRIDDataType NATIONALCHARACTERVARYING = new CUBRIDDataType(SQLDataType.NVARCHAR, "national character varying"); + public static final CUBRIDDataType CLOB = new CUBRIDDataType(SQLDataType.CLOB, "clob"); + + public static final CUBRIDDataType DATE = new CUBRIDDataType(SQLDataType.DATE, "date"); + public static final CUBRIDDataType