diff --git a/jOOQ-test/.classpath b/jOOQ-test/.classpath index d051989ac3..c08c6db295 100644 --- a/jOOQ-test/.classpath +++ b/jOOQ-test/.classpath @@ -32,6 +32,10 @@ + + + + diff --git a/jOOQ-test/.gitignore b/jOOQ-test/.gitignore index 1925373ec0..6d2d36d02d 100644 --- a/jOOQ-test/.gitignore +++ b/jOOQ-test/.gitignore @@ -9,3 +9,4 @@ /test.script /test /test.lobs +/access diff --git a/jOOQ-test/configuration/org/jooq/configuration/lukas/access/library.xml b/jOOQ-test/configuration/org/jooq/configuration/lukas/access/library.xml new file mode 100644 index 0000000000..09a2073d2b --- /dev/null +++ b/jOOQ-test/configuration/org/jooq/configuration/lukas/access/library.xml @@ -0,0 +1,117 @@ + + + + net.ucanaccess.jdbc.UcanaccessDriver + jdbc:ucanaccess:///C:/Users/Lukas/workspace/jOOQ/jOOQ-test/access/test.mdb;Newdatabaseversion=V2010 + admin + + + + org.jooq.util.DefaultGenerator + + org.jooq.util.jdbc.JDBCDatabase + (?i:t_.*|x_.*|v_.*|V_.*|p_.*|f_.*|(f|p)[0-9]+|s_.*) + (?i:t_book_details) + false + true + + + + org.jooq.test._.converters.Boolean_10 + org.jooq.test._.converters.Boolean_10_Converter + + + org.jooq.test._.converters.Boolean_TF_LC + org.jooq.test._.converters.Boolean_TF_LC_Converter + + + org.jooq.test._.converters.Boolean_TF_UC + org.jooq.test._.converters.Boolean_TF_UC_Converter + + + org.jooq.test._.converters.Boolean_YN_LC + org.jooq.test._.converters.Boolean_YN_LC_Converter + + + org.jooq.test._.converters.Boolean_YN_UC + org.jooq.test._.converters.Boolean_YN_UC_Converter + + + org.jooq.test._.converters.Boolean_YES_NO_LC + org.jooq.test._.converters.Boolean_YES_NO_LC_Converter + + + org.jooq.test._.converters.Boolean_YES_NO_UC + org.jooq.test._.converters.Boolean_YES_NO_UC_Converter + + + + + + BIT + (?i:(.*?.)?T_BOOLEANS.(VC|C|N)_BOOLEAN) + + + + + TINYINTUNSIGNED + (?i:(.*?.)?T_UNSIGNED.U_BYTE) + + + SMALLINTUNSIGNED + (?i:(.*?.)?T_UNSIGNED.U_SHORT) + + + INTEGERUNSIGNED + (?i:(.*?.)?T_UNSIGNED.U_INT) + + + BIGINTUNSIGNED + (?i:(.*?.)?T_UNSIGNED.U_LONG) + + + + org.jooq.test._.converters.Boolean_YES_NO_LC + (?i:(.*?.)?T_BOOLEANS.YES_NO_LC) + + + org.jooq.test._.converters.Boolean_YES_NO_UC + (?i:(.*?.)?T_BOOLEANS.YES_NO_UC) + + + org.jooq.test._.converters.Boolean_YN_LC + (?i:(.*?.)?T_BOOLEANS.Y_N_LC) + + + org.jooq.test._.converters.Boolean_YN_UC + (?i:(.*?.)?T_BOOLEANS.Y_N_UC) + + + org.jooq.test._.converters.Boolean_TF_LC + (?i:(.*?.)?T_BOOLEANS.TRUE_FALSE_LC) + + + org.jooq.test._.converters.Boolean_TF_UC + (?i:(.*?.)?T_BOOLEANS.TRUE_FALSE_UC) + + + org.jooq.test._.converters.Boolean_10 + (?i:(.*?.)?T_BOOLEANS.ONE_ZERO) + + + + + true + true + false + false + true + false + false + + + org.jooq.test.access.generatedclasses + ./src + + + \ No newline at end of file diff --git a/jOOQ-test/launch/AccessTest.launch b/jOOQ-test/launch/AccessTest.launch new file mode 100644 index 0000000000..93be6cab0c --- /dev/null +++ b/jOOQ-test/launch/AccessTest.launch @@ -0,0 +1,20 @@ + + + + + + + + + + + + + + + + + + + + diff --git a/jOOQ-test/launch/GenerationTool Access test.launch b/jOOQ-test/launch/GenerationTool Access test.launch new file mode 100644 index 0000000000..70e8c578aa --- /dev/null +++ b/jOOQ-test/launch/GenerationTool Access test.launch @@ -0,0 +1,37 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/jOOQ-test/lib/ucanaccess/commons-lang-2.4.jar b/jOOQ-test/lib/ucanaccess/commons-lang-2.4.jar new file mode 100644 index 0000000000..532939ecab Binary files /dev/null and b/jOOQ-test/lib/ucanaccess/commons-lang-2.4.jar differ diff --git a/jOOQ-test/lib/ucanaccess/commons-logging-1.0.4.jar b/jOOQ-test/lib/ucanaccess/commons-logging-1.0.4.jar new file mode 100644 index 0000000000..b73a80fab6 Binary files /dev/null and b/jOOQ-test/lib/ucanaccess/commons-logging-1.0.4.jar differ diff --git a/jOOQ-test/lib/ucanaccess/jackcess-1.2.13.jar b/jOOQ-test/lib/ucanaccess/jackcess-1.2.13.jar new file mode 100644 index 0000000000..20fa91bf92 Binary files /dev/null and b/jOOQ-test/lib/ucanaccess/jackcess-1.2.13.jar differ diff --git a/jOOQ-test/lib/ucanaccess/ucanaccess-1.0.2.jar b/jOOQ-test/lib/ucanaccess/ucanaccess-1.0.2.jar new file mode 100644 index 0000000000..02c97d5856 Binary files /dev/null and b/jOOQ-test/lib/ucanaccess/ucanaccess-1.0.2.jar differ diff --git a/jOOQ-test/src/org/jooq/test/AccessTest.java b/jOOQ-test/src/org/jooq/test/AccessTest.java new file mode 100644 index 0000000000..c0f8be2398 --- /dev/null +++ b/jOOQ-test/src/org/jooq/test/AccessTest.java @@ -0,0 +1,760 @@ +/** + * Copyright (c) 2009-2013, Lukas Eder, lukas.eder@gmail.com + * All rights reserved. + * + * 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 of the "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.test; + +import static org.jooq.test.access.generatedclasses.Tables.T_BOOK_TO_BOOK_STORE; +import static org.jooq.test.access.generatedclasses.Tables.T_BOOLEANS; +import static org.jooq.test.access.generatedclasses.Tables.T_DATES; +import static org.jooq.test.access.generatedclasses.Tables.T_IDENTITY; +import static org.jooq.test.access.generatedclasses.Tables.T_IDENTITY_PK; + +import java.math.BigDecimal; +import java.math.BigInteger; +import java.sql.Date; +import java.util.UUID; + +import org.jooq.ArrayRecord; +import org.jooq.DSLContext; +import org.jooq.DataType; +import org.jooq.Field; +import org.jooq.ForeignKey; +import org.jooq.Record; +import org.jooq.Result; +import org.jooq.SQLDialect; +import org.jooq.Table; +import org.jooq.TableField; +import org.jooq.UDTRecord; +import org.jooq.conf.Settings; +import org.jooq.impl.DSL; +import org.jooq.test._.converters.Boolean_10; +import org.jooq.test._.converters.Boolean_TF_LC; +import org.jooq.test._.converters.Boolean_TF_UC; +import org.jooq.test._.converters.Boolean_YES_NO_LC; +import org.jooq.test._.converters.Boolean_YES_NO_UC; +import org.jooq.test._.converters.Boolean_YN_LC; +import org.jooq.test._.converters.Boolean_YN_UC; +import org.jooq.test.access.generatedclasses.Keys; +import org.jooq.test.access.generatedclasses.tables.TAuthor; +import org.jooq.test.access.generatedclasses.tables.TBook; +import org.jooq.test.access.generatedclasses.tables.TBookStore; +import org.jooq.test.access.generatedclasses.tables.TBookToBookStore; +import org.jooq.test.access.generatedclasses.tables.TBooleans; +import org.jooq.test.access.generatedclasses.tables.TIdentity; +import org.jooq.test.access.generatedclasses.tables.TIdentityPk; +import org.jooq.test.access.generatedclasses.tables.TTriggers; +import org.jooq.test.access.generatedclasses.tables.T_639NumbersTable; +import org.jooq.test.access.generatedclasses.tables.T_725LobTest; +import org.jooq.test.access.generatedclasses.tables.T_785; +import org.jooq.test.access.generatedclasses.tables.records.TAuthorRecord; +import org.jooq.test.access.generatedclasses.tables.records.TBookRecord; +import org.jooq.test.access.generatedclasses.tables.records.TBookStoreRecord; +import org.jooq.test.access.generatedclasses.tables.records.TBookToBookStoreRecord; +import org.jooq.test.access.generatedclasses.tables.records.TBooleansRecord; +import org.jooq.test.access.generatedclasses.tables.records.TDatesRecord; +import org.jooq.test.access.generatedclasses.tables.records.TIdentityPkRecord; +import org.jooq.test.access.generatedclasses.tables.records.TIdentityRecord; +import org.jooq.test.access.generatedclasses.tables.records.TTriggersRecord; +import org.jooq.test.access.generatedclasses.tables.records.T_639NumbersTableRecord; +import org.jooq.test.access.generatedclasses.tables.records.T_725LobTestRecord; +import org.jooq.test.access.generatedclasses.tables.records.T_785Record; +import org.jooq.types.UByte; +import org.jooq.types.UInteger; +import org.jooq.types.ULong; +import org.jooq.types.UShort; +import org.jooq.util.access.AccessDataType; + + +/** + * Integration test that creates tables and performs various sql operations. + * + * @author Lukas Eder + */ +public class AccessTest extends jOOQAbstractTest< + TAuthorRecord, + Object, + TBookRecord, + TBookStoreRecord, + TBookToBookStoreRecord, + TBookRecord, + TBookRecord, + TBookRecord, + TDatesRecord, + TBooleansRecord, + TBookRecord, + TTriggersRecord, + TBookRecord, + TBookRecord, + TIdentityRecord, + TIdentityPkRecord, + TBookRecord, + TBookRecord, + T_785Record> { + + @Override + protected DSLContext create0(Settings settings) { + return DSL.using(getConnection(), SQLDialect.ACCESS, settings); + } + + @Override + protected Table TAuthor() { + return TAuthor.T_AUTHOR; + } + + @Override + protected TableField TAuthor_LAST_NAME() { + return TAuthor.LAST_NAME; + } + + @Override + protected TableField TAuthor_FIRST_NAME() { + return TAuthor.FIRST_NAME; + } + + @Override + protected TableField TAuthor_DATE_OF_BIRTH() { + return TAuthor.DATE_OF_BIRTH; + } + + @Override + protected TableField TAuthor_YEAR_OF_BIRTH() { + return TAuthor.YEAR_OF_BIRTH; + } + + @Override + protected TableField TAuthor_ID() { + return TAuthor.ID; + } + + @Override + protected TableField> TAuthor_ADDRESS() { + return null; + } + + @Override + protected Table TBook() { + return TBook.T_BOOK; + } + + @Override + protected TableField TBook_ID() { + return TBook.ID; + } + + @Override + protected TableField TBook_AUTHOR_ID() { + return TBook.AUTHOR_ID; + } + + @Override + protected TableField TBook_TITLE() { + return TBook.TITLE; + } + + @Override + protected Table TBookStore() { + return TBookStore.T_BOOK_STORE; + } + + @Override + protected TableField TBookStore_NAME() { + return TBookStore.NAME; + } + + @Override + protected Table TBookToBookStore() { + return T_BOOK_TO_BOOK_STORE; + } + + @Override + protected Table TBookSale() { + return null; + } + + @Override + protected TableField TBookToBookStore_BOOK_ID() { + return TBookToBookStore.BOOK_ID; + } + + @Override + protected TableField TBookToBookStore_BOOK_STORE_NAME() { + return TBookToBookStore.BOOK_STORE_NAME; + } + + @Override + protected TableField TBookToBookStore_STOCK() { + return TBookToBookStore.STOCK; + } + + @Override + protected ForeignKey FK_T_BOOK_AUTHOR_ID() { + return Keys.T_BOOK__FK_T_BOOK_AUTHOR_ID; + } + + @Override + protected ForeignKey FK_T_BOOK_CO_AUTHOR_ID() { + return Keys.T_BOOK__FK_T_BOOK_CO_AUTHOR_ID; + } + + @Override + protected Table T725() { + return T_725LobTest.T_725_LOB_TEST; + } + + @Override + protected TableField T725_ID() { + return T_725LobTest.ID; + } + + @Override + protected TableField T725_LOB() { + return T_725LobTest.LOB; + } + + @Override + protected Table T785() { + return T_785.T_785; + } + + @Override + protected TableField T785_ID() { + return T_785.ID; + } + + @Override + protected TableField T785_NAME() { + return T_785.NAME; + } + + @Override + protected TableField T785_VALUE() { + return T_785.VALUE; + } + + @Override + protected Table TUnsigned() { + return null; + } + + @Override + protected TableField TUnsigned_U_BYTE() { + return null; + } + + @Override + protected TableField TUnsigned_U_SHORT() { + return null; + } + + @Override + protected TableField TUnsigned_U_INT() { + return null; + } + + @Override + protected TableField TUnsigned_U_LONG() { + return null; + } + + @Override + protected Table TExoticTypes() { + return null; + } + + @Override + protected TableField TExoticTypes_ID() { + return null; + } + + @Override + protected TableField TExoticTypes_UU() { + return null; + } + + @Override + protected Table TDates() { + return T_DATES; + } + + @Override + protected Table TBooleans() { + return T_BOOLEANS; + } + + @Override + protected TableField TBooleans_ID() { + return TBooleans.ID; + } + + @Override + protected TableField TBooleans_BOOLEAN_10() { + return TBooleans.ONE_ZERO; + } + + @Override + protected TableField TBooleans_Boolean_TF_LC() { + return TBooleans.TRUE_FALSE_LC; + } + + @Override + protected TableField TBooleans_Boolean_TF_UC() { + return TBooleans.TRUE_FALSE_UC; + } + + @Override + protected TableField TBooleans_Boolean_YN_LC() { + return TBooleans.Y_N_LC; + } + + @Override + protected TableField TBooleans_Boolean_YN_UC() { + return TBooleans.Y_N_UC; + } + + @Override + protected TableField TBooleans_Boolean_YES_NO_LC() { + return TBooleans.YES_NO_LC; + } + + @Override + protected TableField TBooleans_Boolean_YES_NO_UC() { + return TBooleans.YES_NO_UC; + } + + @Override + protected TableField TBooleans_VC() { + return TBooleans.VC_BOOLEAN; + } + + @Override + protected TableField TBooleans_C() { + return TBooleans.C_BOOLEAN; + } + + @Override + protected TableField TBooleans_N() { + return TBooleans.N_BOOLEAN; + } + + @Override + protected Table T639() { + return T_639NumbersTable.T_639_NUMBERS_TABLE; + } + + @Override + protected TableField T639_ID() { + return T_639NumbersTable.ID; + } + + @Override + protected TableField T639_BIG_DECIMAL() { + return T_639NumbersTable.BIG_DECIMAL; + } + + @Override + protected TableField T639_BIG_INTEGER() { + return T_639NumbersTable.BIG_INTEGER; + } + + @Override + protected TableField T639_BYTE() { + return T_639NumbersTable.BYTE; + } + + @Override + protected TableField T639_BYTE_DECIMAL() { + return T_639NumbersTable.BYTE_DECIMAL; + } + + @Override + protected TableField T639_SHORT() { + return T_639NumbersTable.SHORT; + } + + @Override + protected TableField T639_SHORT_DECIMAL() { + return T_639NumbersTable.SHORT_DECIMAL; + } + + @Override + protected TableField T639_INTEGER() { + return T_639NumbersTable.INTEGER; + } + + @Override + protected TableField T639_INTEGER_DECIMAL() { + return T_639NumbersTable.INTEGER_DECIMAL; + } + + @Override + protected TableField T639_LONG() { + return T_639NumbersTable.LONG; + } + + @Override + protected TableField T639_LONG_DECIMAL() { + return T_639NumbersTable.LONG_DECIMAL; + } + + @Override + protected TableField T639_DOUBLE() { + return T_639NumbersTable.DOUBLE; + } + + @Override + protected TableField T639_FLOAT() { + return null; + } + + @Override + protected Table TArrays() { + return null; + } + + @Override + protected TableField TArrays_ID() { + return null; + } + + @Override + protected TableField TArrays_STRING() { + return null; + } + + @Override + protected TableField TArrays_NUMBER() { + return null; + } + + @Override + protected TableField TArrays_DATE() { + return null; + } + + @Override + protected TableField> TArrays_STRING_R() { + return null; + } + + @Override + protected TableField> TArrays_NUMBER_R() { + return null; + } + + @Override + protected TableField> TArrays_DATE_R() { + return null; + } + + @Override + protected TableField> TArrays_NUMBER_LONG_R() { + return null; + } + + @Override + protected TableField TBook_LANGUAGE_ID() { + return TBook.LANGUAGE_ID; + } + + @Override + protected TableField TBook_PUBLISHED_IN() { + return TBook.PUBLISHED_IN; + } + + @Override + protected TableField TBook_CONTENT_TEXT() { + return TBook.CONTENT_TEXT; + } + + @Override + protected TableField TBook_CONTENT_PDF() { + return TBook.CONTENT_PDF; + } + + @Override + protected TableField> TBook_STATUS() { + return null; + } + + @Override + protected Table VLibrary() { + return VLibrary.V_LIBRARY; + } + + @Override + protected TableField VLibrary_TITLE() { + return VLibrary.TITLE; + } + + @Override + protected TableField VLibrary_AUTHOR() { + return VLibrary.AUTHOR; + } + + @Override + protected Table VAuthor() { + return V_AUTHOR; + } + + @Override + protected Table VBook() { + return V_BOOK; + } + + @Override + protected Table TDirectory() { + return null; + } + + @Override + protected TableField TDirectory_ID() { + return null; + } + + @Override + protected TableField TDirectory_PARENT_ID() { + return null; + } + + @Override + protected TableField TDirectory_IS_DIRECTORY() { + return null; + } + + @Override + protected TableField TDirectory_NAME() { + return null; + } + + @Override + protected Table TTriggers() { + return TTriggers.T_TRIGGERS; + } + + @Override + protected TableField TTriggers_ID_GENERATED() { + return TTriggers.ID_GENERATED; + } + + @Override + protected TableField TTriggers_ID() { + return TTriggers.ID; + } + + @Override + protected TableField TTriggers_COUNTER() { + return TTriggers.COUNTER; + } + + @Override + protected Table TIdentity() { + return T_IDENTITY; + } + + @Override + protected TableField TIdentity_ID() { + return TIdentity.ID; + } + + @Override + protected TableField TIdentity_VAL() { + return TIdentity.VAL; + } + + @Override + protected Table TIdentityPK() { + return T_IDENTITY_PK; + } + + @Override + protected TableField TIdentityPK_ID() { + return TIdentityPk.ID; + } + + @Override + protected TableField TIdentityPK_VAL() { + return TIdentityPk.VAL; + } + + @Override + protected Field FAuthorExistsField(String authorName) { + return null; + } + + @Override + protected Field FOneField() { + return null; + } + + @Override + protected Field FNumberField(Number n) { + return null; + } + + @Override + protected Field FNumberField(Field n) { + return null; + } + + @Override + protected Field F317Field(Number n1, Number n2, Number n3, Number n4) { + return null; + } + + @Override + protected Field F317Field(Field n1, Field n2, + Field n3, Field n4) { + return null; + } + + @Override + protected Field> FGetOneCursorField(Integer[] array) { + return null; + } + + @Override + protected Field FArrays1Field(Field array) { + return null; + } + + + @Override + protected Field FArrays2Field(Field array) { + return null; + } + + + @Override + protected Field FArrays3Field(Field array) { + return null; + } + + + @Override + protected > Field FArrays1Field_R(Field array) { + return null; + } + + + @Override + protected > Field FArrays2Field_R(Field array) { + return null; + } + + + @Override + protected > Field FArrays3Field_R(Field array) { + return null; + } + + + @Override + protected Class> cUAddressType() { + return null; + } + + @Override + protected Class> cUStreetType() { + return null; + } + + @Override + protected Class cRoutines() { + return null; + } + + @Override + protected boolean supportsOUTParameters() { + return false; + } + + @Override + protected boolean supportsReferences() { + return true; + } + + @Override + protected boolean supportsRecursiveQueries() { + return false; + } + + @Override + protected Class cLibrary() { + return null; + } + + @Override + protected Class cSequences() { + return null; + } + + @Override + protected TableField[]> TArrays_UDT() { + return null; + } + + @Override + protected DataType[] getCastableDataTypes() { + return new DataType[] { + AccessDataType.BIGINT, + AccessDataType.BINARY, + AccessDataType.BINARYLARGEOBJECT, + AccessDataType.BIT, + AccessDataType.BOOLEAN, + AccessDataType.CHAR, + AccessDataType.CHARACTER, + AccessDataType.CHARACTERLARGEOBJECT, + AccessDataType.CHARACTERVARYING, + AccessDataType.CHARLARGEOBJECT, + AccessDataType.DATE, + AccessDataType.DATETIME, + AccessDataType.DECIMAL, + AccessDataType.DOUBLE, + AccessDataType.DOUBLEPRECISION, + AccessDataType.FLOAT, + AccessDataType.INT, + AccessDataType.INTEGER, + AccessDataType.LONGVARBINARY, + AccessDataType.LONGVARCHAR, + AccessDataType.NUMERIC, + AccessDataType.OBJECT, + AccessDataType.OTHER, + AccessDataType.REAL, + AccessDataType.SMALLINT, + AccessDataType.TIME, + AccessDataType.TIMESTAMP, + AccessDataType.TINYINT, + AccessDataType.VARBINARY, + AccessDataType.VARCHAR, + AccessDataType.VARCHARIGNORECASE, + }; + } +} diff --git a/jOOQ-test/src/org/jooq/test/access/create.sql b/jOOQ-test/src/org/jooq/test/access/create.sql new file mode 100644 index 0000000000..315542b25b --- /dev/null +++ b/jOOQ-test/src/org/jooq/test/access/create.sql @@ -0,0 +1,197 @@ +GRANT SELECT ON MSysObjects TO Admin/ + +DROP TABLE t_dates/ +DROP TABLE t_triggers/ +DROP TABLE t_book_to_book_store/ +DROP TABLE t_book_store/ +DROP TABLE t_book/ +DROP TABLE t_book_details/ +DROP TABLE t_author/ +DROP TABLE t_language/ +DROP TABLE x_test_case_2025/ +DROP TABLE x_test_case_85/ +DROP TABLE x_test_case_71/ +DROP TABLE x_test_case_64_69/ +DROP TABLE t_986_1/ +DROP TABLE t_986_2/ +DROP TABLE x_unused/ +DROP TABLE t_exotic_types/ +DROP TABLE t_639_numbers_table/ +DROP TABLE t_658_ref/ +DROP TABLE t_658_11/ +DROP TABLE t_658_21/ +DROP TABLE t_658_31/ +DROP TABLE t_658_12/ +DROP TABLE t_658_22/ +DROP TABLE t_658_32/ +DROP TABLE t_725_lob_test/ +DROP TABLE t_785/ +DROP TABLE t_unsigned/ +DROP TABLE t_booleans/ +DROP TABLE t_identity/ +DROP TABLE t_identity_pk/ + +CREATE TABLE t_identity_pk ( + id INTEGER IDENTITY NOT NULL, + val int +) +/ + +CREATE TABLE t_identity ( + id INTEGER IDENTITY NOT NULL, + val int +) +/ + +CREATE TABLE t_dates ( + id int, + d date null, + t time null, + ts datetime null, + d_int int null, + ts_bigint bigint null, + + CONSTRAINT pk_t_dates PRIMARY KEY (id) +) +/ + +CREATE TABLE t_booleans ( + id int, + one_zero int null, + true_false_lc varchar(5) null, + true_false_uc varchar(5) null, + yes_no_lc varchar(3) null, + yes_no_uc varchar(3) null, + y_n_lc char(1) null, + y_n_uc char(1) null, + vc_boolean varchar(1) null, + c_boolean char(1) null, + n_boolean int null, + + CONSTRAINT pk_t_booleans PRIMARY KEY (id) +) +/ + +CREATE TABLE t_unsigned ( + u_byte smallint, + u_short int, + u_int bigint, + u_long decimal(20) +) +/ + +CREATE TABLE t_triggers ( + id_generated int IDENTITY not null, + id int null, + counter int null +) +/ + +CREATE TABLE t_language ( + cd CHAR(2) NOT NULL, + description VARCHAR(50) NULL, + description_english VARCHAR(50) NULL, + id INTEGER NOT NULL, + + CONSTRAINT pk_t_language PRIMARY KEY (id) +) +/ + +CREATE TABLE t_725_lob_test ( + id int NOT NULL, + lob VARBINARY(500) NULL, + + CONSTRAINT pk_t_725_lob_test PRIMARY KEY (id) +) +/ + +CREATE TABLE t_785 ( + ID int NULL, + NAME varchar(50) NULL, + VALUE varchar(50) NULL +) +/ + +CREATE TABLE t_author ( + id INT NOT NULL, + first_name VARCHAR(50) NULL, + last_name VARCHAR(50) NOT NULL, + date_of_birth DATE NULL, + year_of_birth INT NULL, + address VARCHAR(200) NULL, + + CONSTRAINT pk_t_author PRIMARY KEY (id) +) +/ + +CREATE TABLE t_book_details ( + id INT NOT NULL, + + CONSTRAINT pk_t_book_details PRIMARY KEY (id) +) +/ + +CREATE TABLE t_book ( + id INT NOT NULL, + author_id INT NOT NULL, + co_author_id INT NULL, + details_id INT NULL, + title VARCHAR(400) NOT NULL, + published_in INT NOT NULL, + language_id INT NOT NULL, + content_text CLOB NULL, + content_pdf BINARY(400) NULL, + + CONSTRAINT pk_t_book PRIMARY KEY (id), + CONSTRAINT fk_t_book_author_id FOREIGN KEY (author_id) REFERENCES t_author(id), + CONSTRAINT fk_t_book_co_author_id FOREIGN KEY (co_author_id) REFERENCES t_author(id), + CONSTRAINT fk_t_book_details_id FOREIGN KEY (details_id) REFERENCES t_book_details(id), + CONSTRAINT fk_t_book_language_id FOREIGN KEY (language_id) REFERENCES t_language(id) +) +/ + +CREATE TABLE t_book_store ( + name VARCHAR(400) NOT NULL, + + CONSTRAINT uk_t_book_store_name PRIMARY KEY(name) +) +/ + +CREATE TABLE t_book_to_book_store ( + book_store_name VARCHAR(400) NOT NULL, + book_id INTEGER NOT NULL, + stock INTEGER, + + CONSTRAINT fk_b2bs_bs_name FOREIGN KEY (book_store_name) + REFERENCES t_book_store (name), + CONSTRAINT fk_b2bs_b_id FOREIGN KEY (book_id) + REFERENCES t_book (id) +) +/ + +CREATE TABLE t_exotic_types ( + ID INT NOT NULL, + UU CHAR(36), + + CONSTRAINT pk_t_exotic_types PRIMARY KEY(ID) +) +/ + +CREATE TABLE t_639_numbers_table ( + ID INT NOT NULL, + BYTE TINYINT NULL, + SHORT SMALLINT NULL, + [INTEGER] INT NULL, + [LONG] BIGINT NULL, + BYTE_DECIMAL DECIMAL(2, 0) NULL, + SHORT_DECIMAL DECIMAL(4, 0) NULL, + INTEGER_DECIMAL DECIMAL(9, 0) NULL, + LONG_DECIMAL DECIMAL(18, 0) NULL, + BIG_INTEGER DECIMAL(22, 0) NULL, + BIG_DECIMAL DECIMAL(22, 5) NULL, + [FLOAT] REAL NULL, + [DOUBLE] DOUBLE PRECISION NULL, + + CONSTRAINT pk_t_639_numbers_table PRIMARY KEY(ID) +) +/ diff --git a/jOOQ-test/src/org/jooq/test/access/reset.sql b/jOOQ-test/src/org/jooq/test/access/reset.sql new file mode 100644 index 0000000000..808725fb18 --- /dev/null +++ b/jOOQ-test/src/org/jooq/test/access/reset.sql @@ -0,0 +1,36 @@ +DELETE FROM t_exotic_types/ +DELETE FROM t_639_numbers_table/ +DELETE FROM t_book_to_book_store/ +DELETE FROM t_book_store/ +DELETE FROM t_book/ +DELETE FROM t_author/ +DELETE FROM t_language/ +DELETE FROM t_booleans/ +DELETE FROM t_dates/ +DELETE FROM t_identity/ +DELETE FROM t_identity_pk/ +DELETE FROM t_triggers/ + +INSERT INTO t_language (id, cd, description, description_english) VALUES (1, 'en', 'English', 'English')/ +INSERT INTO t_language (id, cd, description, description_english) VALUES (2, 'de', 'Deutsch', 'German')/ +INSERT INTO t_language (id, cd, description, description_english) VALUES (3, 'fr', 'Français', 'French')/ +INSERT INTO t_language (id, cd, description, description_english) VALUES (4, 'pt', null, null)/ +/ + +INSERT INTO t_author VALUES (1, 'George', 'Orwell', '1903-06-25', 1903, null)/ +INSERT INTO t_author VALUES (2, 'Paulo', 'Coelho', '1947-08-24', 1947, null)/ +INSERT INTO t_book VALUES (1, 1, null, null, '1984', 1948, 1, 'To know and not to know, to be conscious of complete truthfulness while telling carefully constructed lies, to hold simultaneously two opinions which cancelled out, knowing them to be contradictory and believing in both of them, to use logic against logic, to repudiate morality while laying claim to it, to believe that democracy was impossible and that the Party was the guardian of democracy, to forget, whatever it was necessary to forget, then to draw it back into memory again at the moment when it was needed, and then promptly to forget it again, and above all, to apply the same process to the process itself -- that was the ultimate subtlety; consciously to induce unconsciousness, and then, once again, to become unconscious of the act of hypnosis you had just performed. Even to understand the word ''doublethink'' involved the use of doublethink..', null)/ +INSERT INTO t_book VALUES (2, 1, null, null, 'Animal Farm', 1945, 1, null, null)/ +INSERT INTO t_book VALUES (3, 2, null, null, 'O Alquimista', 1988, 4, null, null)/ +INSERT INTO t_book VALUES (4, 2, null, null, 'Brida', 1990, 2, null, null)/ + +INSERT INTO t_book_store VALUES ('Orell Füssli')/ +INSERT INTO t_book_store VALUES ('Ex Libris')/ +INSERT INTO t_book_store VALUES ('Buchhandlung im Volkshaus')/ + +INSERT INTO t_book_to_book_store VALUES ('Orell Füssli', 1, 10)/ +INSERT INTO t_book_to_book_store VALUES ('Orell Füssli', 2, 10)/ +INSERT INTO t_book_to_book_store VALUES ('Orell Füssli', 3, 10)/ +INSERT INTO t_book_to_book_store VALUES ('Ex Libris', 1, 1)/ +INSERT INTO t_book_to_book_store VALUES ('Ex Libris', 3, 2)/ +INSERT INTO t_book_to_book_store VALUES ('Buchhandlung im Volkshaus', 3, 1)/ \ No newline at end of file diff --git a/jOOQ-test/src/org/jooq/test/jOOQAbstractTest.java b/jOOQ-test/src/org/jooq/test/jOOQAbstractTest.java index ccf86b8e76..aaed932431 100644 --- a/jOOQ-test/src/org/jooq/test/jOOQAbstractTest.java +++ b/jOOQ-test/src/org/jooq/test/jOOQAbstractTest.java @@ -304,6 +304,12 @@ public abstract class jOOQAbstractTest< } } catch (Exception e) { + + // Ignore all errors on DROP statements + if (sql.trim().startsWith("DROP")) { + continue; + } + // There is no DROP TABLE IF EXISTS statement in Oracle if (e.getMessage().contains("ORA-00942")) { continue; diff --git a/jOOQ/src/main/java/org/jooq/SQLDialect.java b/jOOQ/src/main/java/org/jooq/SQLDialect.java index 2afbfcd273..dd68fa24c2 100644 --- a/jOOQ/src/main/java/org/jooq/SQLDialect.java +++ b/jOOQ/src/main/java/org/jooq/SQLDialect.java @@ -60,6 +60,11 @@ public enum SQLDialect { @Deprecated SQL99(null), + /** + * The MS Access SQL dialect family. + */ + ACCESS("Access"), + /** * The Sybase Adaptive Server SQL dialect family. */ diff --git a/jOOQ/src/main/java/org/jooq/impl/MetaImpl.java b/jOOQ/src/main/java/org/jooq/impl/MetaImpl.java index c8ebb68459..9874e12e1f 100644 --- a/jOOQ/src/main/java/org/jooq/impl/MetaImpl.java +++ b/jOOQ/src/main/java/org/jooq/impl/MetaImpl.java @@ -114,10 +114,21 @@ class MetaImpl implements Meta, Serializable { public final List getCatalogs() { try { List result = new ArrayList(); - Result catalogs = create.fetch(meta().getCatalogs()); + switch (configuration.dialect()) { - for (String name : catalogs.getValues(0, String.class)) { - result.add(new MetaCatalog(name)); + // Some dialects do not support catalogs in their meta data APIs + case ACCESS: + break; + + default: { + Result catalogs = create.fetch(meta().getCatalogs()); + + for (String name : catalogs.getValues(0, String.class)) { + result.add(new MetaCatalog(name)); + } + + break; + } } // There should always be at least one (empty) catalog in a database @@ -169,10 +180,21 @@ class MetaImpl implements Meta, Serializable { public final List getSchemas() { try { List result = new ArrayList(); - Result schemas = create.fetch(meta().getSchemas()); + switch (configuration.dialect()) { - for (String name : schemas.getValues(0, String.class)) { - result.add(new MetaSchema(name)); + // Some dialects do not support schemas in their meta data APIs + case ACCESS: + break; + + default: { + Result schemas = create.fetch(meta().getSchemas()); + + for (String name : schemas.getValues(0, String.class)) { + result.add(new MetaSchema(name)); + } + + break; + } } // There should always be at least one (empty) schema in a database @@ -265,6 +287,8 @@ class MetaImpl implements Meta, Serializable { tableName }); + System.out.println(getColumns0(schema, "%").format(1000)); + columnCache = new LinkedHashMap>(); for (Entry> entry : groups.entrySet()) { diff --git a/jOOQ/src/main/java/org/jooq/impl/SQLDataType.java b/jOOQ/src/main/java/org/jooq/impl/SQLDataType.java index 6c05828ef9..54e92cb46f 100644 --- a/jOOQ/src/main/java/org/jooq/impl/SQLDataType.java +++ b/jOOQ/src/main/java/org/jooq/impl/SQLDataType.java @@ -53,6 +53,7 @@ import org.jooq.types.UInteger; import org.jooq.types.ULong; import org.jooq.types.UShort; import org.jooq.types.YearToMonth; +import org.jooq.util.access.AccessDataType; import org.jooq.util.ase.ASEDataType; import org.jooq.util.cubrid.CUBRIDDataType; import org.jooq.util.db2.DB2DataType; @@ -316,6 +317,7 @@ public final class SQLDataType { // TODO [#650] Make this more reliable using a data type registry try { + Class.forName(AccessDataType.class.getName()); Class.forName(ASEDataType.class.getName()); Class.forName(CUBRIDDataType.class.getName()); Class.forName(DB2DataType.class.getName()); diff --git a/jOOQ/src/main/java/org/jooq/tools/jdbc/JDBCUtils.java b/jOOQ/src/main/java/org/jooq/tools/jdbc/JDBCUtils.java index bc355ea156..52493846fb 100644 --- a/jOOQ/src/main/java/org/jooq/tools/jdbc/JDBCUtils.java +++ b/jOOQ/src/main/java/org/jooq/tools/jdbc/JDBCUtils.java @@ -35,6 +35,7 @@ */ package org.jooq.tools.jdbc; +import static org.jooq.SQLDialect.ACCESS; import static org.jooq.SQLDialect.ASE; import static org.jooq.SQLDialect.CUBRID; import static org.jooq.SQLDialect.DB2; @@ -108,7 +109,10 @@ public class JDBCUtils { // The below list might not be accurate or complete. Feel free to // contribute fixes related to new / different JDBC driver configuraitons - if (url.startsWith("jdbc:jtds:sybase:")) { + if (url.startsWith("jdbc:ucanaccess:")) { + return ACCESS; + } + else if (url.startsWith("jdbc:jtds:sybase:")) { return ASE; } else if (url.startsWith("jdbc:cubrid:")) { diff --git a/jOOQ/src/main/java/org/jooq/util/access/AccessDataType.java b/jOOQ/src/main/java/org/jooq/util/access/AccessDataType.java new file mode 100644 index 0000000000..e9c882aeaa --- /dev/null +++ b/jOOQ/src/main/java/org/jooq/util/access/AccessDataType.java @@ -0,0 +1,128 @@ +/** + * Copyright (c) 2009-2013, Lukas Eder, lukas.eder@gmail.com + * All rights reserved. + * + * 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 of the "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.access; + +import java.math.BigDecimal; +import java.math.BigInteger; +import java.sql.Date; +import java.sql.Time; +import java.sql.Timestamp; +import java.util.UUID; + +import org.jooq.DataType; +import org.jooq.Record; +import org.jooq.Result; +import org.jooq.SQLDialect; +import org.jooq.impl.DefaultDataType; +import org.jooq.impl.SQLDataType; +import org.jooq.types.DayToSecond; +import org.jooq.types.UByte; +import org.jooq.types.UInteger; +import org.jooq.types.ULong; +import org.jooq.types.UShort; +import org.jooq.types.YearToMonth; + +/** + * Supported data types for the {@link SQLDialect#ACCESS} dialect + * + * @see http://msdn.microsoft.com/en-us/library/windows/desktop/ms714540(v=vs.85).aspx + * @author Lukas Eder + */ +public class AccessDataType { + + // ------------------------------------------------------------------------- + // Default SQL data types and synonyms thereof + // ------------------------------------------------------------------------- + + public static final DataType TINYINT = new DefaultDataType(SQLDialect.ACCESS, SQLDataType.TINYINT, "tinyint"); + public static final DataType SMALLINT = new DefaultDataType(SQLDialect.ACCESS, SQLDataType.SMALLINT, "smallint"); + public static final DataType INT = new DefaultDataType(SQLDialect.ACCESS, SQLDataType.INTEGER, "int"); + public static final DataType INTEGER = new DefaultDataType(SQLDialect.ACCESS, SQLDataType.INTEGER, "integer"); + public static final DataType BIGINT = new DefaultDataType(SQLDialect.ACCESS, SQLDataType.BIGINT, "bigint"); + public static final DataType DOUBLE = new DefaultDataType(SQLDialect.ACCESS, SQLDataType.DOUBLE, "double"); + public static final DataType DOUBLEPRECISION = new DefaultDataType(SQLDialect.ACCESS, SQLDataType.DOUBLE, "double precision"); + public static final DataType FLOAT = new DefaultDataType(SQLDialect.ACCESS, SQLDataType.FLOAT, "float"); + public static final DataType REAL = new DefaultDataType(SQLDialect.ACCESS, SQLDataType.REAL, "real"); + public static final DataType BOOLEAN = new DefaultDataType(SQLDialect.ACCESS, SQLDataType.BOOLEAN, "boolean"); + public static final DataType BIT = new DefaultDataType(SQLDialect.ACCESS, SQLDataType.BIT, "bit"); + public static final DataType DECIMAL = new DefaultDataType(SQLDialect.ACCESS, SQLDataType.DECIMAL, "decimal"); + public static final DataType NUMERIC = new DefaultDataType(SQLDialect.ACCESS, SQLDataType.NUMERIC, "numeric"); + public static final DataType VARCHAR = new DefaultDataType(SQLDialect.ACCESS, SQLDataType.VARCHAR, "varchar", "varchar(32672)"); + public static final DataType LONGVARCHAR = new DefaultDataType(SQLDialect.ACCESS, SQLDataType.LONGVARCHAR, "longvarchar"); + public static final DataType CHAR = new DefaultDataType(SQLDialect.ACCESS, SQLDataType.CHAR, "char"); + public static final DataType CHARACTER = new DefaultDataType(SQLDialect.ACCESS, SQLDataType.CHAR, "character"); + public static final DataType CHARACTERVARYING = new DefaultDataType(SQLDialect.ACCESS, SQLDataType.VARCHAR, "character varying", "character varying(32672)"); + public static final DataType CLOB = new DefaultDataType(SQLDialect.ACCESS, SQLDataType.CLOB, "clob"); + public static final DataType CHARLARGEOBJECT = new DefaultDataType(SQLDialect.ACCESS, SQLDataType.CLOB, "char large object", "clob"); + public static final DataType CHARACTERLARGEOBJECT = new DefaultDataType(SQLDialect.ACCESS, SQLDataType.CLOB, "character large object", "clob"); + public static final DataType DATE = new DefaultDataType(SQLDialect.ACCESS, SQLDataType.DATE, "date"); + public static final DataType