diff --git a/docker-compose.yml b/docker-compose.yml index 79e0d0d066..ce7dcbf3e4 100644 --- a/docker-compose.yml +++ b/docker-compose.yml @@ -12,7 +12,7 @@ services: condition: service_healthy mysql: - image: mysql:8 + image: mysql:5.6.38 ports: - "3306:3306" volumes: @@ -21,6 +21,7 @@ services: - MYSQL_ROOT_PASSWORD=querydsl - MYSQL_USER=querydsl - MYSQL_PASSWORD=querydsl + - MYSQL_DATABASE=querydsl postgresql: image: postgis/postgis:16-3.4-alpine diff --git a/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SAccount_.java b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SAccount_.java new file mode 100644 index 0000000000..00b73d5af7 --- /dev/null +++ b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SAccount_.java @@ -0,0 +1,65 @@ +package com.querydsl.jpa.domain.sql; + +import static com.querydsl.core.types.PathMetadataFactory.*; + +import com.querydsl.core.types.Path; +import com.querydsl.core.types.PathMetadata; +import com.querydsl.core.types.dsl.*; +import com.querydsl.sql.ColumnMetadata; +import java.sql.Types; +import javax.annotation.processing.Generated; + +/** SAccount_ is a Querydsl query type for SAccount_ */ +@Generated("com.querydsl.sql.codegen.MetaDataSerializer") +public class SAccount_ extends com.querydsl.sql.RelationalPathBase { + + private static final long serialVersionUID = -2128134054; + + public static final SAccount_ account_ = new SAccount_("account_"); + + public final NumberPath id = createNumber("id", Long.class); + + public final NumberPath ownerI = createNumber("ownerI", Long.class); + + public final StringPath somedata = createString("somedata"); + + public final com.querydsl.sql.PrimaryKey primary = createPrimaryKey(id); + + public final com.querydsl.sql.ForeignKey account_OWNERIFK = + createForeignKey(ownerI, "I"); + + public SAccount_(String variable) { + super(SAccount_.class, forVariable(variable), "null", "account_"); + addMetadata(); + } + + public SAccount_(String variable, String schema, String table) { + super(SAccount_.class, forVariable(variable), schema, table); + addMetadata(); + } + + public SAccount_(String variable, String schema) { + super(SAccount_.class, forVariable(variable), schema, "account_"); + addMetadata(); + } + + public SAccount_(Path path) { + super(path.getType(), path.getMetadata(), "null", "account_"); + addMetadata(); + } + + public SAccount_(PathMetadata metadata) { + super(SAccount_.class, metadata, "null", "account_"); + addMetadata(); + } + + public void addMetadata() { + addMetadata( + id, ColumnMetadata.named("ID").withIndex(1).ofType(Types.BIGINT).withSize(19).notNull()); + addMetadata( + ownerI, ColumnMetadata.named("OWNER_I").withIndex(3).ofType(Types.BIGINT).withSize(19)); + addMetadata( + somedata, + ColumnMetadata.named("SOMEDATA").withIndex(2).ofType(Types.VARCHAR).withSize(255)); + } +} diff --git a/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SAnimal_.java b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SAnimal_.java new file mode 100644 index 0000000000..19b5824ce1 --- /dev/null +++ b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SAnimal_.java @@ -0,0 +1,131 @@ +package com.querydsl.jpa.domain.sql; + +import static com.querydsl.core.types.PathMetadataFactory.*; + +import com.querydsl.core.types.Path; +import com.querydsl.core.types.PathMetadata; +import com.querydsl.core.types.dsl.*; +import com.querydsl.sql.ColumnMetadata; +import java.sql.Types; +import javax.annotation.processing.Generated; + +/** SAnimal_ is a Querydsl query type for SAnimal_ */ +@Generated("com.querydsl.sql.codegen.MetaDataSerializer") +public class SAnimal_ extends com.querydsl.sql.RelationalPathBase { + + private static final long serialVersionUID = 2052848731; + + public static final SAnimal_ animal_ = new SAnimal_("animal_"); + + public final BooleanPath alive = createBoolean("alive"); + + public final DateTimePath birthdate = + createDateTime("birthdate", java.sql.Timestamp.class); + + public final NumberPath bodyweight = createNumber("bodyweight", Double.class); + + public final NumberPath breed = createNumber("breed", Integer.class); + + public final NumberPath color = createNumber("color", Integer.class); + + public final DatePath datefield = createDate("datefield", java.sql.Date.class); + + public final StringPath dtype = createString("dtype"); + + public final NumberPath eyecolor = createNumber("eyecolor", Integer.class); + + public final NumberPath floatproperty = createNumber("floatproperty", Float.class); + + public final NumberPath id = createNumber("id", Integer.class); + + public final NumberPath mateId = createNumber("mateId", Integer.class); + + public final StringPath name = createString("name"); + + public final TimePath timefield = createTime("timefield", java.sql.Time.class); + + public final NumberPath toes = createNumber("toes", Integer.class); + + public final NumberPath weight = createNumber("weight", Integer.class); + + public final com.querydsl.sql.PrimaryKey primary = createPrimaryKey(id); + + public final com.querydsl.sql.ForeignKey animal_MATEIDFK = + createForeignKey(mateId, "ID"); + + public final com.querydsl.sql.ForeignKey _animal_MATEIDFK = + createInvForeignKey(id, "MATE_ID"); + + public final com.querydsl.sql.ForeignKey _kittensCatIdFK = + createInvForeignKey(id, "cat_id"); + + public final com.querydsl.sql.ForeignKey _kittensKittenIdFK = + createInvForeignKey(id, "kitten_id"); + + public final com.querydsl.sql.ForeignKey _kittensSetCatIdFK = + createInvForeignKey(id, "cat_id"); + + public final com.querydsl.sql.ForeignKey _kittensSetKittenIdFK = + createInvForeignKey(id, "kitten_id"); + + public SAnimal_(String variable) { + super(SAnimal_.class, forVariable(variable), "null", "animal_"); + addMetadata(); + } + + public SAnimal_(String variable, String schema, String table) { + super(SAnimal_.class, forVariable(variable), schema, table); + addMetadata(); + } + + public SAnimal_(String variable, String schema) { + super(SAnimal_.class, forVariable(variable), schema, "animal_"); + addMetadata(); + } + + public SAnimal_(Path path) { + super(path.getType(), path.getMetadata(), "null", "animal_"); + addMetadata(); + } + + public SAnimal_(PathMetadata metadata) { + super(SAnimal_.class, metadata, "null", "animal_"); + addMetadata(); + } + + public void addMetadata() { + addMetadata(alive, ColumnMetadata.named("ALIVE").withIndex(3).ofType(Types.BIT).withSize(1)); + addMetadata( + birthdate, + ColumnMetadata.named("BIRTHDATE").withIndex(4).ofType(Types.TIMESTAMP).withSize(19)); + addMetadata( + bodyweight, + ColumnMetadata.named("BODYWEIGHT").withIndex(5).ofType(Types.DOUBLE).withSize(22)); + addMetadata( + breed, ColumnMetadata.named("BREED").withIndex(13).ofType(Types.INTEGER).withSize(10)); + addMetadata( + color, ColumnMetadata.named("COLOR").withIndex(6).ofType(Types.INTEGER).withSize(10)); + addMetadata( + datefield, ColumnMetadata.named("DATEFIELD").withIndex(7).ofType(Types.DATE).withSize(10)); + addMetadata( + dtype, ColumnMetadata.named("DTYPE").withIndex(2).ofType(Types.VARCHAR).withSize(31)); + addMetadata( + eyecolor, + ColumnMetadata.named("EYECOLOR").withIndex(14).ofType(Types.INTEGER).withSize(10)); + addMetadata( + floatproperty, + ColumnMetadata.named("FLOATPROPERTY").withIndex(8).ofType(Types.REAL).withSize(12)); + addMetadata( + id, ColumnMetadata.named("ID").withIndex(1).ofType(Types.INTEGER).withSize(10).notNull()); + addMetadata( + mateId, ColumnMetadata.named("MATE_ID").withIndex(15).ofType(Types.INTEGER).withSize(10)); + addMetadata( + name, ColumnMetadata.named("NAME").withIndex(9).ofType(Types.VARCHAR).withSize(255)); + addMetadata( + timefield, ColumnMetadata.named("TIMEFIELD").withIndex(10).ofType(Types.TIME).withSize(8)); + addMetadata( + toes, ColumnMetadata.named("TOES").withIndex(11).ofType(Types.INTEGER).withSize(10)); + addMetadata( + weight, ColumnMetadata.named("WEIGHT").withIndex(12).ofType(Types.INTEGER).withSize(10)); + } +} diff --git a/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SAuditlog_.java b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SAuditlog_.java new file mode 100644 index 0000000000..e00984d984 --- /dev/null +++ b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SAuditlog_.java @@ -0,0 +1,60 @@ +package com.querydsl.jpa.domain.sql; + +import static com.querydsl.core.types.PathMetadataFactory.*; + +import com.querydsl.core.types.Path; +import com.querydsl.core.types.PathMetadata; +import com.querydsl.core.types.dsl.*; +import com.querydsl.sql.ColumnMetadata; +import java.sql.Types; +import javax.annotation.processing.Generated; + +/** SAuditlog_ is a Querydsl query type for SAuditlog_ */ +@Generated("com.querydsl.sql.codegen.MetaDataSerializer") +public class SAuditlog_ extends com.querydsl.sql.RelationalPathBase { + + private static final long serialVersionUID = 472909934; + + public static final SAuditlog_ auditlog_ = new SAuditlog_("auditlog_"); + + public final NumberPath id = createNumber("id", Integer.class); + + public final NumberPath itemId = createNumber("itemId", Long.class); + + public final com.querydsl.sql.PrimaryKey primary = createPrimaryKey(id); + + public final com.querydsl.sql.ForeignKey auditlog_ITEMIDFK = + createForeignKey(itemId, "ID"); + + public SAuditlog_(String variable) { + super(SAuditlog_.class, forVariable(variable), "null", "auditlog_"); + addMetadata(); + } + + public SAuditlog_(String variable, String schema, String table) { + super(SAuditlog_.class, forVariable(variable), schema, table); + addMetadata(); + } + + public SAuditlog_(String variable, String schema) { + super(SAuditlog_.class, forVariable(variable), schema, "auditlog_"); + addMetadata(); + } + + public SAuditlog_(Path path) { + super(path.getType(), path.getMetadata(), "null", "auditlog_"); + addMetadata(); + } + + public SAuditlog_(PathMetadata metadata) { + super(SAuditlog_.class, metadata, "null", "auditlog_"); + addMetadata(); + } + + public void addMetadata() { + addMetadata( + id, ColumnMetadata.named("ID").withIndex(1).ofType(Types.INTEGER).withSize(10).notNull()); + addMetadata( + itemId, ColumnMetadata.named("ITEM_ID").withIndex(2).ofType(Types.BIGINT).withSize(19)); + } +} diff --git a/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SAuthor_.java b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SAuthor_.java new file mode 100644 index 0000000000..c2d5b04df4 --- /dev/null +++ b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SAuthor_.java @@ -0,0 +1,60 @@ +package com.querydsl.jpa.domain.sql; + +import static com.querydsl.core.types.PathMetadataFactory.*; + +import com.querydsl.core.types.Path; +import com.querydsl.core.types.PathMetadata; +import com.querydsl.core.types.dsl.*; +import com.querydsl.sql.ColumnMetadata; +import java.sql.Types; +import javax.annotation.processing.Generated; + +/** SAuthor_ is a Querydsl query type for SAuthor_ */ +@Generated("com.querydsl.sql.codegen.MetaDataSerializer") +public class SAuthor_ extends com.querydsl.sql.RelationalPathBase { + + private static final long serialVersionUID = -2031691092; + + public static final SAuthor_ author_ = new SAuthor_("author_"); + + public final NumberPath id = createNumber("id", Long.class); + + public final StringPath name = createString("name"); + + public final com.querydsl.sql.PrimaryKey primary = createPrimaryKey(id); + + public final com.querydsl.sql.ForeignKey _book_AUTHORIDFK = + createInvForeignKey(id, "AUTHOR_ID"); + + public SAuthor_(String variable) { + super(SAuthor_.class, forVariable(variable), "null", "author_"); + addMetadata(); + } + + public SAuthor_(String variable, String schema, String table) { + super(SAuthor_.class, forVariable(variable), schema, table); + addMetadata(); + } + + public SAuthor_(String variable, String schema) { + super(SAuthor_.class, forVariable(variable), schema, "author_"); + addMetadata(); + } + + public SAuthor_(Path path) { + super(path.getType(), path.getMetadata(), "null", "author_"); + addMetadata(); + } + + public SAuthor_(PathMetadata metadata) { + super(SAuthor_.class, metadata, "null", "author_"); + addMetadata(); + } + + public void addMetadata() { + addMetadata( + id, ColumnMetadata.named("ID").withIndex(1).ofType(Types.BIGINT).withSize(19).notNull()); + addMetadata( + name, ColumnMetadata.named("NAME").withIndex(2).ofType(Types.VARCHAR).withSize(255)); + } +} diff --git a/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SBar_.java b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SBar_.java new file mode 100644 index 0000000000..0bcebc0ad2 --- /dev/null +++ b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SBar_.java @@ -0,0 +1,56 @@ +package com.querydsl.jpa.domain.sql; + +import static com.querydsl.core.types.PathMetadataFactory.*; + +import com.querydsl.core.types.Path; +import com.querydsl.core.types.PathMetadata; +import com.querydsl.core.types.dsl.*; +import com.querydsl.sql.ColumnMetadata; +import java.sql.Types; +import javax.annotation.processing.Generated; + +/** SBar_ is a Querydsl query type for SBar_ */ +@Generated("com.querydsl.sql.codegen.MetaDataSerializer") +public class SBar_ extends com.querydsl.sql.RelationalPathBase { + + private static final long serialVersionUID = 1493110580; + + public static final SBar_ bar_ = new SBar_("bar_"); + + public final DatePath date = createDate("date", java.sql.Date.class); + + public final NumberPath id = createNumber("id", Integer.class); + + public final com.querydsl.sql.PrimaryKey primary = createPrimaryKey(id); + + public SBar_(String variable) { + super(SBar_.class, forVariable(variable), "null", "bar_"); + addMetadata(); + } + + public SBar_(String variable, String schema, String table) { + super(SBar_.class, forVariable(variable), schema, table); + addMetadata(); + } + + public SBar_(String variable, String schema) { + super(SBar_.class, forVariable(variable), schema, "bar_"); + addMetadata(); + } + + public SBar_(Path path) { + super(path.getType(), path.getMetadata(), "null", "bar_"); + addMetadata(); + } + + public SBar_(PathMetadata metadata) { + super(SBar_.class, metadata, "null", "bar_"); + addMetadata(); + } + + public void addMetadata() { + addMetadata(date, ColumnMetadata.named("DATE").withIndex(2).ofType(Types.DATE).withSize(10)); + addMetadata( + id, ColumnMetadata.named("ID").withIndex(1).ofType(Types.INTEGER).withSize(10).notNull()); + } +} diff --git a/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SBookBookmarks.java b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SBookBookmarks.java index 5b936e0e02..fbaf3a0138 100644 --- a/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SBookBookmarks.java +++ b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SBookBookmarks.java @@ -1,45 +1,40 @@ package com.querydsl.jpa.domain.sql; -import static com.querydsl.core.types.PathMetadataFactory.forVariable; +import static com.querydsl.core.types.PathMetadataFactory.*; import com.querydsl.core.types.Path; import com.querydsl.core.types.PathMetadata; -import com.querydsl.core.types.dsl.NumberPath; -import com.querydsl.core.types.dsl.StringPath; +import com.querydsl.core.types.dsl.*; import com.querydsl.sql.ColumnMetadata; -import jakarta.annotation.Generated; -import java.util.Arrays; +import java.sql.Types; +import java.util.*; +import javax.annotation.processing.Generated; /** SBookBookmarks is a Querydsl query type for SBookBookmarks */ @Generated("com.querydsl.sql.codegen.MetaDataSerializer") public class SBookBookmarks extends com.querydsl.sql.RelationalPathBase { - private static final long serialVersionUID = -312126525; + private static final long serialVersionUID = 1405496716; public static final SBookBookmarks bookBookmarks = new SBookBookmarks("book_bookmarks"); - public final NumberPath bookMarksORDER = createNumber("bookMarksORDER", Integer.class); - - public final NumberPath bookVersionBookIDIdentity = - createNumber("bookVersionBookIDIdentity", Long.class); + public final NumberPath bookidIdentity = createNumber("bookidIdentity", Long.class); - public final NumberPath bookVersionLibraryIdentity = - createNumber("bookVersionLibraryIdentity", Long.class); + public final NumberPath bookMarksORDER = createNumber("bookMarksORDER", Integer.class); public final StringPath comment = createString("comment"); - public final NumberPath page = createNumber("page", Long.class); + public final NumberPath libraryIdentity = createNumber("libraryIdentity", Long.class); - public final com.querydsl.sql.PrimaryKey primary = - createPrimaryKey(bookVersionBookIDIdentity, bookVersionLibraryIdentity, bookMarksORDER); + public final NumberPath page = createNumber("page", Long.class); - public final com.querydsl.sql.ForeignKey fk94026827e33d3be4 = + public final com.querydsl.sql.ForeignKey bookBookmarksBOOKIDIDENTITYFK = createForeignKey( - Arrays.asList(bookVersionBookIDIdentity, bookVersionLibraryIdentity), - Arrays.asList("bookID_identity", "library_identity")); + Arrays.asList(bookidIdentity, libraryIdentity), + Arrays.asList("BOOKID_IDENTITY", "LIBRARY_IDENTITY")); public SBookBookmarks(String variable) { - super(SBookBookmarks.class, forVariable(variable), "", "book_bookmarks"); + super(SBookBookmarks.class, forVariable(variable), "null", "book_bookmarks"); addMetadata(); } @@ -48,35 +43,33 @@ public SBookBookmarks(String variable, String schema, String table) { addMetadata(); } + public SBookBookmarks(String variable, String schema) { + super(SBookBookmarks.class, forVariable(variable), schema, "book_bookmarks"); + addMetadata(); + } + public SBookBookmarks(Path path) { - super(path.getType(), path.getMetadata(), "", "book_bookmarks"); + super(path.getType(), path.getMetadata(), "null", "book_bookmarks"); addMetadata(); } public SBookBookmarks(PathMetadata metadata) { - super(SBookBookmarks.class, metadata, "", "book_bookmarks"); + super(SBookBookmarks.class, metadata, "null", "book_bookmarks"); addMetadata(); } public void addMetadata() { + addMetadata( + bookidIdentity, + ColumnMetadata.named("BOOKID_IDENTITY").withIndex(4).ofType(Types.BIGINT).withSize(19)); addMetadata( bookMarksORDER, - ColumnMetadata.named("bookMarks_ORDER").withIndex(5).ofType(4).withSize(10).notNull()); + ColumnMetadata.named("bookMarks_ORDER").withIndex(5).ofType(Types.INTEGER).withSize(10)); addMetadata( - bookVersionBookIDIdentity, - ColumnMetadata.named("BookVersion_bookID_identity") - .withIndex(1) - .ofType(-5) - .withSize(19) - .notNull()); + comment, ColumnMetadata.named("COMMENT").withIndex(1).ofType(Types.VARCHAR).withSize(255)); addMetadata( - bookVersionLibraryIdentity, - ColumnMetadata.named("BookVersion_library_identity") - .withIndex(2) - .ofType(-5) - .withSize(19) - .notNull()); - addMetadata(comment, ColumnMetadata.named("comment").withIndex(3).ofType(12).withSize(255)); - addMetadata(page, ColumnMetadata.named("page").withIndex(4).ofType(-5).withSize(19)); + libraryIdentity, + ColumnMetadata.named("LIBRARY_IDENTITY").withIndex(3).ofType(Types.BIGINT).withSize(19)); + addMetadata(page, ColumnMetadata.named("PAGE").withIndex(2).ofType(Types.BIGINT).withSize(19)); } } diff --git a/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SBook_.java b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SBook_.java new file mode 100644 index 0000000000..cf64ad1a6f --- /dev/null +++ b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SBook_.java @@ -0,0 +1,68 @@ +package com.querydsl.jpa.domain.sql; + +import static com.querydsl.core.types.PathMetadataFactory.*; + +import com.querydsl.core.types.Path; +import com.querydsl.core.types.PathMetadata; +import com.querydsl.core.types.dsl.*; +import com.querydsl.sql.ColumnMetadata; +import java.sql.Types; +import javax.annotation.processing.Generated; + +/** SBook_ is a Querydsl query type for SBook_ */ +@Generated("com.querydsl.sql.codegen.MetaDataSerializer") +public class SBook_ extends com.querydsl.sql.RelationalPathBase { + + private static final long serialVersionUID = -957797618; + + public static final SBook_ book_ = new SBook_("book_"); + + public final NumberPath authorId = createNumber("authorId", Long.class); + + public final StringPath dtype = createString("dtype"); + + public final NumberPath id = createNumber("id", Long.class); + + public final StringPath title = createString("title"); + + public final com.querydsl.sql.PrimaryKey primary = createPrimaryKey(id); + + public final com.querydsl.sql.ForeignKey book_AUTHORIDFK = + createForeignKey(authorId, "ID"); + + public SBook_(String variable) { + super(SBook_.class, forVariable(variable), "null", "book_"); + addMetadata(); + } + + public SBook_(String variable, String schema, String table) { + super(SBook_.class, forVariable(variable), schema, table); + addMetadata(); + } + + public SBook_(String variable, String schema) { + super(SBook_.class, forVariable(variable), schema, "book_"); + addMetadata(); + } + + public SBook_(Path path) { + super(path.getType(), path.getMetadata(), "null", "book_"); + addMetadata(); + } + + public SBook_(PathMetadata metadata) { + super(SBook_.class, metadata, "null", "book_"); + addMetadata(); + } + + public void addMetadata() { + addMetadata( + authorId, ColumnMetadata.named("AUTHOR_ID").withIndex(4).ofType(Types.BIGINT).withSize(19)); + addMetadata( + dtype, ColumnMetadata.named("DTYPE").withIndex(2).ofType(Types.VARCHAR).withSize(31)); + addMetadata( + id, ColumnMetadata.named("ID").withIndex(1).ofType(Types.BIGINT).withSize(19).notNull()); + addMetadata( + title, ColumnMetadata.named("TITLE").withIndex(3).ofType(Types.VARCHAR).withSize(255)); + } +} diff --git a/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SBookid_.java b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SBookid_.java new file mode 100644 index 0000000000..3433685449 --- /dev/null +++ b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SBookid_.java @@ -0,0 +1,57 @@ +package com.querydsl.jpa.domain.sql; + +import static com.querydsl.core.types.PathMetadataFactory.*; + +import com.querydsl.core.types.Path; +import com.querydsl.core.types.PathMetadata; +import com.querydsl.core.types.dsl.*; +import com.querydsl.sql.ColumnMetadata; +import java.sql.Types; +import javax.annotation.processing.Generated; + +/** SBookid_ is a Querydsl query type for SBookid_ */ +@Generated("com.querydsl.sql.codegen.MetaDataSerializer") +public class SBookid_ extends com.querydsl.sql.RelationalPathBase { + + private static final long serialVersionUID = -1320496749; + + public static final SBookid_ bookid_ = new SBookid_("bookid_"); + + public final NumberPath identity = createNumber("identity", Long.class); + + public final com.querydsl.sql.PrimaryKey primary = createPrimaryKey(identity); + + public final com.querydsl.sql.ForeignKey _bookversion_BOOKIDIDENTITYFK = + createInvForeignKey(identity, "BOOKID_IDENTITY"); + + public SBookid_(String variable) { + super(SBookid_.class, forVariable(variable), "null", "bookid_"); + addMetadata(); + } + + public SBookid_(String variable, String schema, String table) { + super(SBookid_.class, forVariable(variable), schema, table); + addMetadata(); + } + + public SBookid_(String variable, String schema) { + super(SBookid_.class, forVariable(variable), schema, "bookid_"); + addMetadata(); + } + + public SBookid_(Path path) { + super(path.getType(), path.getMetadata(), "null", "bookid_"); + addMetadata(); + } + + public SBookid_(PathMetadata metadata) { + super(SBookid_.class, metadata, "null", "bookid_"); + addMetadata(); + } + + public void addMetadata() { + addMetadata( + identity, + ColumnMetadata.named("IDENTITY").withIndex(1).ofType(Types.BIGINT).withSize(19).notNull()); + } +} diff --git a/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SBookversion_.java b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SBookversion_.java new file mode 100644 index 0000000000..c9fb5bfeb7 --- /dev/null +++ b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SBookversion_.java @@ -0,0 +1,89 @@ +package com.querydsl.jpa.domain.sql; + +import static com.querydsl.core.types.PathMetadataFactory.*; + +import com.querydsl.core.types.Path; +import com.querydsl.core.types.PathMetadata; +import com.querydsl.core.types.dsl.*; +import com.querydsl.sql.ColumnMetadata; +import java.sql.Types; +import java.util.*; +import javax.annotation.processing.Generated; + +/** SBookversion_ is a Querydsl query type for SBookversion_ */ +@Generated("com.querydsl.sql.codegen.MetaDataSerializer") +public class SBookversion_ extends com.querydsl.sql.RelationalPathBase { + + private static final long serialVersionUID = -823148296; + + public static final SBookversion_ bookversion_ = new SBookversion_("bookversion_"); + + public final NumberPath bookidIdentity = createNumber("bookidIdentity", Long.class); + + public final StringPath description = createString("description"); + + public final NumberPath libraryIdentity = createNumber("libraryIdentity", Long.class); + + public final StringPath name = createString("name"); + + public final com.querydsl.sql.PrimaryKey primary = + createPrimaryKey(bookidIdentity, libraryIdentity); + + public final com.querydsl.sql.ForeignKey bookversion_BOOKIDIDENTITYFK = + createForeignKey(bookidIdentity, "IDENTITY"); + + public final com.querydsl.sql.ForeignKey bookversion_LIBRARYIDENTITYFK = + createForeignKey(libraryIdentity, "IDENTITY"); + + public final com.querydsl.sql.ForeignKey _bookBookmarksBOOKIDIDENTITYFK = + createInvForeignKey( + Arrays.asList(bookidIdentity, libraryIdentity), + Arrays.asList("BOOKID_IDENTITY", "LIBRARY_IDENTITY")); + + public SBookversion_(String variable) { + super(SBookversion_.class, forVariable(variable), "null", "bookversion_"); + addMetadata(); + } + + public SBookversion_(String variable, String schema, String table) { + super(SBookversion_.class, forVariable(variable), schema, table); + addMetadata(); + } + + public SBookversion_(String variable, String schema) { + super(SBookversion_.class, forVariable(variable), schema, "bookversion_"); + addMetadata(); + } + + public SBookversion_(Path path) { + super(path.getType(), path.getMetadata(), "null", "bookversion_"); + addMetadata(); + } + + public SBookversion_(PathMetadata metadata) { + super(SBookversion_.class, metadata, "null", "bookversion_"); + addMetadata(); + } + + public void addMetadata() { + addMetadata( + bookidIdentity, + ColumnMetadata.named("BOOKID_IDENTITY") + .withIndex(3) + .ofType(Types.BIGINT) + .withSize(19) + .notNull()); + addMetadata( + description, + ColumnMetadata.named("DESCRIPTION").withIndex(1).ofType(Types.VARCHAR).withSize(255)); + addMetadata( + libraryIdentity, + ColumnMetadata.named("LIBRARY_IDENTITY") + .withIndex(4) + .ofType(Types.BIGINT) + .withSize(19) + .notNull()); + addMetadata( + name, ColumnMetadata.named("NAME").withIndex(2).ofType(Types.VARCHAR).withSize(255)); + } +} diff --git a/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SCalendarHOLIDAYS.java b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SCalendarHOLIDAYS.java new file mode 100644 index 0000000000..c94c7c14bc --- /dev/null +++ b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SCalendarHOLIDAYS.java @@ -0,0 +1,65 @@ +package com.querydsl.jpa.domain.sql; + +import static com.querydsl.core.types.PathMetadataFactory.*; + +import com.querydsl.core.types.Path; +import com.querydsl.core.types.PathMetadata; +import com.querydsl.core.types.dsl.*; +import com.querydsl.sql.ColumnMetadata; +import java.sql.Types; +import javax.annotation.processing.Generated; + +/** SCalendarHOLIDAYS is a Querydsl query type for SCalendarHOLIDAYS */ +@Generated("com.querydsl.sql.codegen.MetaDataSerializer") +public class SCalendarHOLIDAYS extends com.querydsl.sql.RelationalPathBase { + + private static final long serialVersionUID = 1042099425; + + public static final SCalendarHOLIDAYS CalendarHOLIDAYS = + new SCalendarHOLIDAYS("Calendar_HOLIDAYS"); + + public final NumberPath calendarID = createNumber("calendarID", Integer.class); + + public final DatePath holidays = createDate("holidays", java.sql.Date.class); + + public final StringPath holidaysKey = createString("holidaysKey"); + + public final com.querydsl.sql.ForeignKey calendarHOLIDAYSCalendarIDFK = + createForeignKey(calendarID, "ID"); + + public SCalendarHOLIDAYS(String variable) { + super(SCalendarHOLIDAYS.class, forVariable(variable), "null", "Calendar_HOLIDAYS"); + addMetadata(); + } + + public SCalendarHOLIDAYS(String variable, String schema, String table) { + super(SCalendarHOLIDAYS.class, forVariable(variable), schema, table); + addMetadata(); + } + + public SCalendarHOLIDAYS(String variable, String schema) { + super(SCalendarHOLIDAYS.class, forVariable(variable), schema, "Calendar_HOLIDAYS"); + addMetadata(); + } + + public SCalendarHOLIDAYS(Path path) { + super(path.getType(), path.getMetadata(), "null", "Calendar_HOLIDAYS"); + addMetadata(); + } + + public SCalendarHOLIDAYS(PathMetadata metadata) { + super(SCalendarHOLIDAYS.class, metadata, "null", "Calendar_HOLIDAYS"); + addMetadata(); + } + + public void addMetadata() { + addMetadata( + calendarID, + ColumnMetadata.named("Calendar_ID").withIndex(1).ofType(Types.INTEGER).withSize(10)); + addMetadata( + holidays, ColumnMetadata.named("HOLIDAYS").withIndex(2).ofType(Types.DATE).withSize(10)); + addMetadata( + holidaysKey, + ColumnMetadata.named("holidays_key").withIndex(3).ofType(Types.VARCHAR).withSize(255)); + } +} diff --git a/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SCalendar_.java b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SCalendar_.java new file mode 100644 index 0000000000..be9e37148b --- /dev/null +++ b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SCalendar_.java @@ -0,0 +1,59 @@ +package com.querydsl.jpa.domain.sql; + +import static com.querydsl.core.types.PathMetadataFactory.*; + +import com.querydsl.core.types.Path; +import com.querydsl.core.types.PathMetadata; +import com.querydsl.core.types.dsl.*; +import com.querydsl.sql.ColumnMetadata; +import java.sql.Types; +import javax.annotation.processing.Generated; + +/** SCalendar_ is a Querydsl query type for SCalendar_ */ +@Generated("com.querydsl.sql.codegen.MetaDataSerializer") +public class SCalendar_ extends com.querydsl.sql.RelationalPathBase { + + private static final long serialVersionUID = -953714343; + + public static final SCalendar_ calendar_ = new SCalendar_("calendar_"); + + public final NumberPath id = createNumber("id", Integer.class); + + public final com.querydsl.sql.PrimaryKey primary = createPrimaryKey(id); + + public final com.querydsl.sql.ForeignKey _calendarHOLIDAYSCalendarIDFK = + createInvForeignKey(id, "Calendar_ID"); + + public final com.querydsl.sql.ForeignKey _nationality_CALENDARIDFK = + createInvForeignKey(id, "CALENDAR_ID"); + + public SCalendar_(String variable) { + super(SCalendar_.class, forVariable(variable), "null", "calendar_"); + addMetadata(); + } + + public SCalendar_(String variable, String schema, String table) { + super(SCalendar_.class, forVariable(variable), schema, table); + addMetadata(); + } + + public SCalendar_(String variable, String schema) { + super(SCalendar_.class, forVariable(variable), schema, "calendar_"); + addMetadata(); + } + + public SCalendar_(Path path) { + super(path.getType(), path.getMetadata(), "null", "calendar_"); + addMetadata(); + } + + public SCalendar_(PathMetadata metadata) { + super(SCalendar_.class, metadata, "null", "calendar_"); + addMetadata(); + } + + public void addMetadata() { + addMetadata( + id, ColumnMetadata.named("ID").withIndex(1).ofType(Types.INTEGER).withSize(10).notNull()); + } +} diff --git a/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SCatalog_.java b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SCatalog_.java new file mode 100644 index 0000000000..072e5af194 --- /dev/null +++ b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SCatalog_.java @@ -0,0 +1,62 @@ +package com.querydsl.jpa.domain.sql; + +import static com.querydsl.core.types.PathMetadataFactory.*; + +import com.querydsl.core.types.Path; +import com.querydsl.core.types.PathMetadata; +import com.querydsl.core.types.dsl.*; +import com.querydsl.sql.ColumnMetadata; +import java.sql.Types; +import javax.annotation.processing.Generated; + +/** SCatalog_ is a Querydsl query type for SCatalog_ */ +@Generated("com.querydsl.sql.codegen.MetaDataSerializer") +public class SCatalog_ extends com.querydsl.sql.RelationalPathBase { + + private static final long serialVersionUID = 55977966; + + public static final SCatalog_ catalog_ = new SCatalog_("catalog_"); + + public final DatePath effectivedate = + createDate("effectivedate", java.sql.Date.class); + + public final NumberPath id = createNumber("id", Integer.class); + + public final com.querydsl.sql.PrimaryKey primary = createPrimaryKey(id); + + public final com.querydsl.sql.ForeignKey _catalog_price_CatalogIDFK = + createInvForeignKey(id, "Catalog_ID"); + + public SCatalog_(String variable) { + super(SCatalog_.class, forVariable(variable), "null", "catalog_"); + addMetadata(); + } + + public SCatalog_(String variable, String schema, String table) { + super(SCatalog_.class, forVariable(variable), schema, table); + addMetadata(); + } + + public SCatalog_(String variable, String schema) { + super(SCatalog_.class, forVariable(variable), schema, "catalog_"); + addMetadata(); + } + + public SCatalog_(Path path) { + super(path.getType(), path.getMetadata(), "null", "catalog_"); + addMetadata(); + } + + public SCatalog_(PathMetadata metadata) { + super(SCatalog_.class, metadata, "null", "catalog_"); + addMetadata(); + } + + public void addMetadata() { + addMetadata( + effectivedate, + ColumnMetadata.named("EFFECTIVEDATE").withIndex(2).ofType(Types.DATE).withSize(10)); + addMetadata( + id, ColumnMetadata.named("ID").withIndex(1).ofType(Types.INTEGER).withSize(10).notNull()); + } +} diff --git a/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SCatalog_price_.java b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SCatalog_price_.java new file mode 100644 index 0000000000..4419fb93fc --- /dev/null +++ b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SCatalog_price_.java @@ -0,0 +1,70 @@ +package com.querydsl.jpa.domain.sql; + +import static com.querydsl.core.types.PathMetadataFactory.*; + +import com.querydsl.core.types.Path; +import com.querydsl.core.types.PathMetadata; +import com.querydsl.core.types.dsl.*; +import com.querydsl.sql.ColumnMetadata; +import java.sql.Types; +import javax.annotation.processing.Generated; + +/** SCatalog_price_ is a Querydsl query type for SCatalog_price_ */ +@Generated("com.querydsl.sql.codegen.MetaDataSerializer") +public class SCatalog_price_ extends com.querydsl.sql.RelationalPathBase { + + private static final long serialVersionUID = -1317112412; + + public static final SCatalog_price_ catalog_price_ = new SCatalog_price_("catalog__price_"); + + public final NumberPath catalogID = createNumber("catalogID", Integer.class); + + public final NumberPath pricesID = createNumber("pricesID", Long.class); + + public final com.querydsl.sql.PrimaryKey primary = + createPrimaryKey(catalogID, pricesID); + + public final com.querydsl.sql.ForeignKey catalog_price_CatalogIDFK = + createForeignKey(catalogID, "ID"); + + public final com.querydsl.sql.ForeignKey catalog_price_pricesIDFK = + createForeignKey(pricesID, "ID"); + + public SCatalog_price_(String variable) { + super(SCatalog_price_.class, forVariable(variable), "null", "catalog__price_"); + addMetadata(); + } + + public SCatalog_price_(String variable, String schema, String table) { + super(SCatalog_price_.class, forVariable(variable), schema, table); + addMetadata(); + } + + public SCatalog_price_(String variable, String schema) { + super(SCatalog_price_.class, forVariable(variable), schema, "catalog__price_"); + addMetadata(); + } + + public SCatalog_price_(Path path) { + super(path.getType(), path.getMetadata(), "null", "catalog__price_"); + addMetadata(); + } + + public SCatalog_price_(PathMetadata metadata) { + super(SCatalog_price_.class, metadata, "null", "catalog__price_"); + addMetadata(); + } + + public void addMetadata() { + addMetadata( + catalogID, + ColumnMetadata.named("Catalog_ID") + .withIndex(1) + .ofType(Types.INTEGER) + .withSize(10) + .notNull()); + addMetadata( + pricesID, + ColumnMetadata.named("prices_ID").withIndex(2).ofType(Types.BIGINT).withSize(19).notNull()); + } +} diff --git a/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SCategory_.java b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SCategory_.java new file mode 100644 index 0000000000..c33aabc660 --- /dev/null +++ b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SCategory_.java @@ -0,0 +1,111 @@ +package com.querydsl.jpa.domain.sql; + +import static com.querydsl.core.types.PathMetadataFactory.*; + +import com.querydsl.core.types.Path; +import com.querydsl.core.types.PathMetadata; +import com.querydsl.core.types.dsl.*; +import com.querydsl.sql.ColumnMetadata; +import java.sql.Types; +import javax.annotation.processing.Generated; + +/** SCategory_ is a Querydsl query type for SCategory_ */ +@Generated("com.querydsl.sql.codegen.MetaDataSerializer") +public class SCategory_ extends com.querydsl.sql.RelationalPathBase { + + private static final long serialVersionUID = 1845227417; + + public static final SCategory_ category_ = new SCategory_("category_"); + + public final StringPath categorydescription = createString("categorydescription"); + + public final StringPath categoryname = createString("categoryname"); + + public final NumberPath createdby = createNumber("createdby", Double.class); + + public final DateTimePath creationdate = + createDateTime("creationdate", java.sql.Timestamp.class); + + public final DateTimePath deletedate = + createDateTime("deletedate", java.sql.Timestamp.class); + + public final NumberPath deletedby = createNumber("deletedby", Double.class); + + public final NumberPath id = createNumber("id", Long.class); + + public final DateTimePath modificationdate = + createDateTime("modificationdate", java.sql.Timestamp.class); + + public final NumberPath modifiedby = createNumber("modifiedby", Double.class); + + public final com.querydsl.sql.PrimaryKey primary = createPrimaryKey(id); + + public final com.querydsl.sql.ForeignKey _category_category_childIdFK = + createInvForeignKey(id, "childId"); + + public final com.querydsl.sql.ForeignKey _category_category_parentIdFK = + createInvForeignKey(id, "parentId"); + + public final com.querydsl.sql.ForeignKey + _category_categoryprop_CategoryIDFK = createInvForeignKey(id, "Category_ID"); + + public final com.querydsl.sql.ForeignKey + _userprop_category_childCategoriesIDFK = createInvForeignKey(id, "childCategories_ID"); + + public SCategory_(String variable) { + super(SCategory_.class, forVariable(variable), "null", "category_"); + addMetadata(); + } + + public SCategory_(String variable, String schema, String table) { + super(SCategory_.class, forVariable(variable), schema, table); + addMetadata(); + } + + public SCategory_(String variable, String schema) { + super(SCategory_.class, forVariable(variable), schema, "category_"); + addMetadata(); + } + + public SCategory_(Path path) { + super(path.getType(), path.getMetadata(), "null", "category_"); + addMetadata(); + } + + public SCategory_(PathMetadata metadata) { + super(SCategory_.class, metadata, "null", "category_"); + addMetadata(); + } + + public void addMetadata() { + addMetadata( + categorydescription, + ColumnMetadata.named("CATEGORYDESCRIPTION") + .withIndex(2) + .ofType(Types.VARCHAR) + .withSize(255)); + addMetadata( + categoryname, + ColumnMetadata.named("CATEGORYNAME").withIndex(3).ofType(Types.VARCHAR).withSize(255)); + addMetadata( + createdby, + ColumnMetadata.named("CREATEDBY").withIndex(4).ofType(Types.DOUBLE).withSize(22)); + addMetadata( + creationdate, + ColumnMetadata.named("CREATIONDATE").withIndex(5).ofType(Types.TIMESTAMP).withSize(19)); + addMetadata( + deletedate, + ColumnMetadata.named("DELETEDATE").withIndex(6).ofType(Types.TIMESTAMP).withSize(19)); + addMetadata( + deletedby, + ColumnMetadata.named("DELETEDBY").withIndex(7).ofType(Types.DOUBLE).withSize(22)); + addMetadata( + id, ColumnMetadata.named("ID").withIndex(1).ofType(Types.BIGINT).withSize(19).notNull()); + addMetadata( + modificationdate, + ColumnMetadata.named("MODIFICATIONDATE").withIndex(8).ofType(Types.TIMESTAMP).withSize(19)); + addMetadata( + modifiedby, + ColumnMetadata.named("MODIFIEDBY").withIndex(9).ofType(Types.DOUBLE).withSize(22)); + } +} diff --git a/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SCategory_category_.java b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SCategory_category_.java new file mode 100644 index 0000000000..2fa3825e83 --- /dev/null +++ b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SCategory_category_.java @@ -0,0 +1,67 @@ +package com.querydsl.jpa.domain.sql; + +import static com.querydsl.core.types.PathMetadataFactory.*; + +import com.querydsl.core.types.Path; +import com.querydsl.core.types.PathMetadata; +import com.querydsl.core.types.dsl.*; +import com.querydsl.sql.ColumnMetadata; +import java.sql.Types; +import javax.annotation.processing.Generated; + +/** SCategory_category_ is a Querydsl query type for SCategory_category_ */ +@Generated("com.querydsl.sql.codegen.MetaDataSerializer") +public class SCategory_category_ extends com.querydsl.sql.RelationalPathBase { + + private static final long serialVersionUID = 171601832; + + public static final SCategory_category_ category_category_ = + new SCategory_category_("category__category_"); + + public final NumberPath childId = createNumber("childId", Long.class); + + public final NumberPath parentId = createNumber("parentId", Long.class); + + public final com.querydsl.sql.PrimaryKey primary = + createPrimaryKey(childId, parentId); + + public final com.querydsl.sql.ForeignKey category_category_childIdFK = + createForeignKey(childId, "ID"); + + public final com.querydsl.sql.ForeignKey category_category_parentIdFK = + createForeignKey(parentId, "ID"); + + public SCategory_category_(String variable) { + super(SCategory_category_.class, forVariable(variable), "null", "category__category_"); + addMetadata(); + } + + public SCategory_category_(String variable, String schema, String table) { + super(SCategory_category_.class, forVariable(variable), schema, table); + addMetadata(); + } + + public SCategory_category_(String variable, String schema) { + super(SCategory_category_.class, forVariable(variable), schema, "category__category_"); + addMetadata(); + } + + public SCategory_category_(Path path) { + super(path.getType(), path.getMetadata(), "null", "category__category_"); + addMetadata(); + } + + public SCategory_category_(PathMetadata metadata) { + super(SCategory_category_.class, metadata, "null", "category__category_"); + addMetadata(); + } + + public void addMetadata() { + addMetadata( + childId, + ColumnMetadata.named("childId").withIndex(2).ofType(Types.BIGINT).withSize(19).notNull()); + addMetadata( + parentId, + ColumnMetadata.named("parentId").withIndex(1).ofType(Types.BIGINT).withSize(19).notNull()); + } +} diff --git a/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SCategory_categoryprop_.java b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SCategory_categoryprop_.java new file mode 100644 index 0000000000..e6aa773aa5 --- /dev/null +++ b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SCategory_categoryprop_.java @@ -0,0 +1,76 @@ +package com.querydsl.jpa.domain.sql; + +import static com.querydsl.core.types.PathMetadataFactory.*; + +import com.querydsl.core.types.Path; +import com.querydsl.core.types.PathMetadata; +import com.querydsl.core.types.dsl.*; +import com.querydsl.sql.ColumnMetadata; +import java.sql.Types; +import javax.annotation.processing.Generated; + +/** SCategory_categoryprop_ is a Querydsl query type for SCategory_categoryprop_ */ +@Generated("com.querydsl.sql.codegen.MetaDataSerializer") +public class SCategory_categoryprop_ + extends com.querydsl.sql.RelationalPathBase { + + private static final long serialVersionUID = -2083558363; + + public static final SCategory_categoryprop_ category_categoryprop_ = + new SCategory_categoryprop_("category__categoryprop_"); + + public final NumberPath categoryID = createNumber("categoryID", Long.class); + + public final NumberPath propertiesID = createNumber("propertiesID", Long.class); + + public final com.querydsl.sql.PrimaryKey primary = + createPrimaryKey(categoryID, propertiesID); + + public final com.querydsl.sql.ForeignKey category_categoryprop_CategoryIDFK = + createForeignKey(categoryID, "ID"); + + public final com.querydsl.sql.ForeignKey category_categoryprop_propertiesIDFK = + createForeignKey(propertiesID, "ID"); + + public SCategory_categoryprop_(String variable) { + super(SCategory_categoryprop_.class, forVariable(variable), "null", "category__categoryprop_"); + addMetadata(); + } + + public SCategory_categoryprop_(String variable, String schema, String table) { + super(SCategory_categoryprop_.class, forVariable(variable), schema, table); + addMetadata(); + } + + public SCategory_categoryprop_(String variable, String schema) { + super(SCategory_categoryprop_.class, forVariable(variable), schema, "category__categoryprop_"); + addMetadata(); + } + + public SCategory_categoryprop_(Path path) { + super(path.getType(), path.getMetadata(), "null", "category__categoryprop_"); + addMetadata(); + } + + public SCategory_categoryprop_(PathMetadata metadata) { + super(SCategory_categoryprop_.class, metadata, "null", "category__categoryprop_"); + addMetadata(); + } + + public void addMetadata() { + addMetadata( + categoryID, + ColumnMetadata.named("Category_ID") + .withIndex(1) + .ofType(Types.BIGINT) + .withSize(19) + .notNull()); + addMetadata( + propertiesID, + ColumnMetadata.named("properties_ID") + .withIndex(2) + .ofType(Types.BIGINT) + .withSize(19) + .notNull()); + } +} diff --git a/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SCategoryprop_.java b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SCategoryprop_.java new file mode 100644 index 0000000000..eaf3f80f95 --- /dev/null +++ b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SCategoryprop_.java @@ -0,0 +1,74 @@ +package com.querydsl.jpa.domain.sql; + +import static com.querydsl.core.types.PathMetadataFactory.*; + +import com.querydsl.core.types.Path; +import com.querydsl.core.types.PathMetadata; +import com.querydsl.core.types.dsl.*; +import com.querydsl.sql.ColumnMetadata; +import java.sql.Types; +import javax.annotation.processing.Generated; + +/** SCategoryprop_ is a Querydsl query type for SCategoryprop_ */ +@Generated("com.querydsl.sql.codegen.MetaDataSerializer") +public class SCategoryprop_ extends com.querydsl.sql.RelationalPathBase { + + private static final long serialVersionUID = 704482198; + + public static final SCategoryprop_ categoryprop_ = new SCategoryprop_("categoryprop_"); + + public final NumberPath categoryid = createNumber("categoryid", Long.class); + + public final NumberPath id = createNumber("id", Long.class); + + public final StringPath propname = createString("propname"); + + public final StringPath propvalue = createString("propvalue"); + + public final com.querydsl.sql.PrimaryKey primary = createPrimaryKey(id); + + public final com.querydsl.sql.ForeignKey + _category_categoryprop_propertiesIDFK = createInvForeignKey(id, "properties_ID"); + + public final com.querydsl.sql.ForeignKey + _userprop_categoryprop_propertiesIDFK = createInvForeignKey(id, "properties_ID"); + + public SCategoryprop_(String variable) { + super(SCategoryprop_.class, forVariable(variable), "null", "categoryprop_"); + addMetadata(); + } + + public SCategoryprop_(String variable, String schema, String table) { + super(SCategoryprop_.class, forVariable(variable), schema, table); + addMetadata(); + } + + public SCategoryprop_(String variable, String schema) { + super(SCategoryprop_.class, forVariable(variable), schema, "categoryprop_"); + addMetadata(); + } + + public SCategoryprop_(Path path) { + super(path.getType(), path.getMetadata(), "null", "categoryprop_"); + addMetadata(); + } + + public SCategoryprop_(PathMetadata metadata) { + super(SCategoryprop_.class, metadata, "null", "categoryprop_"); + addMetadata(); + } + + public void addMetadata() { + addMetadata( + categoryid, + ColumnMetadata.named("CATEGORYID").withIndex(2).ofType(Types.BIGINT).withSize(19)); + addMetadata( + id, ColumnMetadata.named("ID").withIndex(1).ofType(Types.BIGINT).withSize(19).notNull()); + addMetadata( + propname, + ColumnMetadata.named("PROPNAME").withIndex(3).ofType(Types.VARCHAR).withSize(255)); + addMetadata( + propvalue, + ColumnMetadata.named("PROPVALUE").withIndex(4).ofType(Types.VARCHAR).withSize(255)); + } +} diff --git a/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SChild2.java b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SChild2.java index 6e6dd729b6..188a79872b 100644 --- a/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SChild2.java +++ b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SChild2.java @@ -1,20 +1,21 @@ package com.querydsl.jpa.domain.sql; -import static com.querydsl.core.types.PathMetadataFactory.forVariable; +import static com.querydsl.core.types.PathMetadataFactory.*; import com.querydsl.core.types.Path; import com.querydsl.core.types.PathMetadata; -import com.querydsl.core.types.dsl.NumberPath; +import com.querydsl.core.types.dsl.*; import com.querydsl.sql.ColumnMetadata; -import jakarta.annotation.Generated; +import java.sql.Types; +import javax.annotation.processing.Generated; /** SChild2 is a Querydsl query type for SChild2 */ @Generated("com.querydsl.sql.codegen.MetaDataSerializer") public class SChild2 extends com.querydsl.sql.RelationalPathBase { - private static final long serialVersionUID = 386731719; + private static final long serialVersionUID = 395031838; - public static final SChild2 Child2 = new SChild2("Child2"); + public static final SChild2 child2 = new SChild2("CHILD2"); public final NumberPath id = createNumber("id", Integer.class); @@ -22,11 +23,11 @@ public class SChild2 extends com.querydsl.sql.RelationalPathBase { public final com.querydsl.sql.PrimaryKey primary = createPrimaryKey(id); - public final com.querydsl.sql.ForeignKey fk783f9ab6c2dbacbc = - createForeignKey(parentId, "id"); + public final com.querydsl.sql.ForeignKey child2ParentIdFk = + createForeignKey(parentId, "ID"); public SChild2(String variable) { - super(SChild2.class, forVariable(variable), "", "Child2"); + super(SChild2.class, forVariable(variable), "null", "CHILD2"); addMetadata(); } @@ -35,18 +36,26 @@ public SChild2(String variable, String schema, String table) { addMetadata(); } + public SChild2(String variable, String schema) { + super(SChild2.class, forVariable(variable), schema, "CHILD2"); + addMetadata(); + } + public SChild2(Path path) { - super(path.getType(), path.getMetadata(), "", "Child2"); + super(path.getType(), path.getMetadata(), "null", "CHILD2"); addMetadata(); } public SChild2(PathMetadata metadata) { - super(SChild2.class, metadata, "", "Child2"); + super(SChild2.class, metadata, "null", "CHILD2"); addMetadata(); } public void addMetadata() { - addMetadata(id, ColumnMetadata.named("id").withIndex(1).ofType(4).withSize(10).notNull()); - addMetadata(parentId, ColumnMetadata.named("parent_id").withIndex(2).ofType(4).withSize(10)); + addMetadata( + id, ColumnMetadata.named("ID").withIndex(1).ofType(Types.INTEGER).withSize(10).notNull()); + addMetadata( + parentId, + ColumnMetadata.named("PARENT_ID").withIndex(2).ofType(Types.INTEGER).withSize(10)); } } diff --git a/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SCompany_.java b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SCompany_.java new file mode 100644 index 0000000000..576ee701e5 --- /dev/null +++ b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SCompany_.java @@ -0,0 +1,91 @@ +package com.querydsl.jpa.domain.sql; + +import static com.querydsl.core.types.PathMetadataFactory.*; + +import com.querydsl.core.types.Path; +import com.querydsl.core.types.PathMetadata; +import com.querydsl.core.types.dsl.*; +import com.querydsl.sql.ColumnMetadata; +import java.sql.Types; +import javax.annotation.processing.Generated; + +/** SCompany_ is a Querydsl query type for SCompany_ */ +@Generated("com.querydsl.sql.codegen.MetaDataSerializer") +public class SCompany_ extends com.querydsl.sql.RelationalPathBase { + + private static final long serialVersionUID = -590751734; + + public static final SCompany_ company_ = new SCompany_("company_"); + + public final NumberPath ceoId = createNumber("ceoId", Integer.class); + + public final NumberPath id = createNumber("id", Integer.class); + + public final StringPath name = createString("name"); + + public final StringPath officialName = createString("officialName"); + + public final NumberPath ratingordinal = createNumber("ratingordinal", Integer.class); + + public final StringPath ratingstring = createString("ratingstring"); + + public final com.querydsl.sql.PrimaryKey primary = createPrimaryKey(id); + + public final com.querydsl.sql.ForeignKey company_CEOIDFK = + createForeignKey(ceoId, "ID"); + + public final com.querydsl.sql.ForeignKey _company_department_CompanyIDFK = + createInvForeignKey(id, "Company_ID"); + + public final com.querydsl.sql.ForeignKey _department_COMPANYIDFK = + createInvForeignKey(id, "COMPANY_ID"); + + public final com.querydsl.sql.ForeignKey _employee_COMPANYIDFK = + createInvForeignKey(id, "COMPANY_ID"); + + public final com.querydsl.sql.ForeignKey _user_COMPANYIDFK = + createInvForeignKey(id, "COMPANY_ID"); + + public SCompany_(String variable) { + super(SCompany_.class, forVariable(variable), "null", "company_"); + addMetadata(); + } + + public SCompany_(String variable, String schema, String table) { + super(SCompany_.class, forVariable(variable), schema, table); + addMetadata(); + } + + public SCompany_(String variable, String schema) { + super(SCompany_.class, forVariable(variable), schema, "company_"); + addMetadata(); + } + + public SCompany_(Path path) { + super(path.getType(), path.getMetadata(), "null", "company_"); + addMetadata(); + } + + public SCompany_(PathMetadata metadata) { + super(SCompany_.class, metadata, "null", "company_"); + addMetadata(); + } + + public void addMetadata() { + addMetadata( + ceoId, ColumnMetadata.named("CEO_ID").withIndex(6).ofType(Types.INTEGER).withSize(10)); + addMetadata( + id, ColumnMetadata.named("ID").withIndex(1).ofType(Types.INTEGER).withSize(10).notNull()); + addMetadata( + name, ColumnMetadata.named("NAME").withIndex(2).ofType(Types.VARCHAR).withSize(255)); + addMetadata( + officialName, + ColumnMetadata.named("official_name").withIndex(3).ofType(Types.VARCHAR).withSize(255)); + addMetadata( + ratingordinal, + ColumnMetadata.named("RATINGORDINAL").withIndex(4).ofType(Types.INTEGER).withSize(10)); + addMetadata( + ratingstring, + ColumnMetadata.named("RATINGSTRING").withIndex(5).ofType(Types.VARCHAR).withSize(255)); + } +} diff --git a/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SCompany_department_.java b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SCompany_department_.java new file mode 100644 index 0000000000..53d7d70940 --- /dev/null +++ b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SCompany_department_.java @@ -0,0 +1,76 @@ +package com.querydsl.jpa.domain.sql; + +import static com.querydsl.core.types.PathMetadataFactory.*; + +import com.querydsl.core.types.Path; +import com.querydsl.core.types.PathMetadata; +import com.querydsl.core.types.dsl.*; +import com.querydsl.sql.ColumnMetadata; +import java.sql.Types; +import javax.annotation.processing.Generated; + +/** SCompany_department_ is a Querydsl query type for SCompany_department_ */ +@Generated("com.querydsl.sql.codegen.MetaDataSerializer") +public class SCompany_department_ + extends com.querydsl.sql.RelationalPathBase { + + private static final long serialVersionUID = -884357885; + + public static final SCompany_department_ company_department_ = + new SCompany_department_("company__department_"); + + public final NumberPath companyID = createNumber("companyID", Integer.class); + + public final NumberPath departmentsID = createNumber("departmentsID", Integer.class); + + public final com.querydsl.sql.PrimaryKey primary = + createPrimaryKey(companyID, departmentsID); + + public final com.querydsl.sql.ForeignKey company_department_CompanyIDFK = + createForeignKey(companyID, "ID"); + + public final com.querydsl.sql.ForeignKey company_department_departmentsIDFK = + createForeignKey(departmentsID, "ID"); + + public SCompany_department_(String variable) { + super(SCompany_department_.class, forVariable(variable), "null", "company__department_"); + addMetadata(); + } + + public SCompany_department_(String variable, String schema, String table) { + super(SCompany_department_.class, forVariable(variable), schema, table); + addMetadata(); + } + + public SCompany_department_(String variable, String schema) { + super(SCompany_department_.class, forVariable(variable), schema, "company__department_"); + addMetadata(); + } + + public SCompany_department_(Path path) { + super(path.getType(), path.getMetadata(), "null", "company__department_"); + addMetadata(); + } + + public SCompany_department_(PathMetadata metadata) { + super(SCompany_department_.class, metadata, "null", "company__department_"); + addMetadata(); + } + + public void addMetadata() { + addMetadata( + companyID, + ColumnMetadata.named("Company_ID") + .withIndex(1) + .ofType(Types.INTEGER) + .withSize(10) + .notNull()); + addMetadata( + departmentsID, + ColumnMetadata.named("departments_ID") + .withIndex(2) + .ofType(Types.INTEGER) + .withSize(10) + .notNull()); + } +} diff --git a/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SCustomer_.java b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SCustomer_.java new file mode 100644 index 0000000000..e822f742be --- /dev/null +++ b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SCustomer_.java @@ -0,0 +1,74 @@ +package com.querydsl.jpa.domain.sql; + +import static com.querydsl.core.types.PathMetadataFactory.*; + +import com.querydsl.core.types.Path; +import com.querydsl.core.types.PathMetadata; +import com.querydsl.core.types.dsl.*; +import com.querydsl.sql.ColumnMetadata; +import java.sql.Types; +import javax.annotation.processing.Generated; + +/** SCustomer_ is a Querydsl query type for SCustomer_ */ +@Generated("com.querydsl.sql.codegen.MetaDataSerializer") +public class SCustomer_ extends com.querydsl.sql.RelationalPathBase { + + private static final long serialVersionUID = 1890945209; + + public static final SCustomer_ customer_ = new SCustomer_("customer_"); + + public final NumberPath currentorderId = createNumber("currentorderId", Long.class); + + public final NumberPath id = createNumber("id", Integer.class); + + public final NumberPath nameId = createNumber("nameId", Long.class); + + public final com.querydsl.sql.PrimaryKey primary = createPrimaryKey(id); + + public final com.querydsl.sql.ForeignKey customer_CURRENTORDERIDFK = + createForeignKey(currentorderId, "ID"); + + public final com.querydsl.sql.ForeignKey customer_NAMEIDFK = + createForeignKey(nameId, "ID"); + + public final com.querydsl.sql.ForeignKey _order_CUSTOMERIDFK = + createInvForeignKey(id, "CUSTOMER_ID"); + + public final com.querydsl.sql.ForeignKey _store_customer_customersIDFK = + createInvForeignKey(id, "customers_ID"); + + public SCustomer_(String variable) { + super(SCustomer_.class, forVariable(variable), "null", "customer_"); + addMetadata(); + } + + public SCustomer_(String variable, String schema, String table) { + super(SCustomer_.class, forVariable(variable), schema, table); + addMetadata(); + } + + public SCustomer_(String variable, String schema) { + super(SCustomer_.class, forVariable(variable), schema, "customer_"); + addMetadata(); + } + + public SCustomer_(Path path) { + super(path.getType(), path.getMetadata(), "null", "customer_"); + addMetadata(); + } + + public SCustomer_(PathMetadata metadata) { + super(SCustomer_.class, metadata, "null", "customer_"); + addMetadata(); + } + + public void addMetadata() { + addMetadata( + currentorderId, + ColumnMetadata.named("CURRENTORDER_ID").withIndex(2).ofType(Types.BIGINT).withSize(19)); + addMetadata( + id, ColumnMetadata.named("ID").withIndex(1).ofType(Types.INTEGER).withSize(10).notNull()); + addMetadata( + nameId, ColumnMetadata.named("NAME_ID").withIndex(3).ofType(Types.BIGINT).withSize(19)); + } +} diff --git a/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SDateTest.java b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SDateTest.java index dd62956d76..f95d520414 100644 --- a/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SDateTest.java +++ b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SDateTest.java @@ -1,25 +1,26 @@ package com.querydsl.jpa.domain.sql; -import static com.querydsl.core.types.PathMetadataFactory.forVariable; +import static com.querydsl.core.types.PathMetadataFactory.*; import com.querydsl.core.types.Path; import com.querydsl.core.types.PathMetadata; -import com.querydsl.core.types.dsl.DatePath; +import com.querydsl.core.types.dsl.*; import com.querydsl.sql.ColumnMetadata; -import jakarta.annotation.Generated; +import java.sql.Types; +import javax.annotation.processing.Generated; /** SDateTest is a Querydsl query type for SDateTest */ @Generated("com.querydsl.sql.codegen.MetaDataSerializer") public class SDateTest extends com.querydsl.sql.RelationalPathBase { - private static final long serialVersionUID = -1879688879; + private static final long serialVersionUID = 1801758184; public static final SDateTest dateTest1 = new SDateTest("DATE_TEST"); public final DatePath dateTest = createDate("dateTest", java.sql.Date.class); public SDateTest(String variable) { - super(SDateTest.class, forVariable(variable), "", "DATE_TEST"); + super(SDateTest.class, forVariable(variable), "null", "DATE_TEST"); addMetadata(); } @@ -28,17 +29,23 @@ public SDateTest(String variable, String schema, String table) { addMetadata(); } + public SDateTest(String variable, String schema) { + super(SDateTest.class, forVariable(variable), schema, "DATE_TEST"); + addMetadata(); + } + public SDateTest(Path path) { - super(path.getType(), path.getMetadata(), "", "DATE_TEST"); + super(path.getType(), path.getMetadata(), "null", "DATE_TEST"); addMetadata(); } public SDateTest(PathMetadata metadata) { - super(SDateTest.class, metadata, "", "DATE_TEST"); + super(SDateTest.class, metadata, "null", "DATE_TEST"); addMetadata(); } public void addMetadata() { - addMetadata(dateTest, ColumnMetadata.named("DATE_TEST").withIndex(1).ofType(91).withSize(10)); + addMetadata( + dateTest, ColumnMetadata.named("DATE_TEST").withIndex(1).ofType(Types.DATE).withSize(10)); } } diff --git a/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SDepartment_.java b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SDepartment_.java new file mode 100644 index 0000000000..226072cdb5 --- /dev/null +++ b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SDepartment_.java @@ -0,0 +1,71 @@ +package com.querydsl.jpa.domain.sql; + +import static com.querydsl.core.types.PathMetadataFactory.*; + +import com.querydsl.core.types.Path; +import com.querydsl.core.types.PathMetadata; +import com.querydsl.core.types.dsl.*; +import com.querydsl.sql.ColumnMetadata; +import java.sql.Types; +import javax.annotation.processing.Generated; + +/** SDepartment_ is a Querydsl query type for SDepartment_ */ +@Generated("com.querydsl.sql.codegen.MetaDataSerializer") +public class SDepartment_ extends com.querydsl.sql.RelationalPathBase { + + private static final long serialVersionUID = -1571818043; + + public static final SDepartment_ department_ = new SDepartment_("department_"); + + public final NumberPath companyId = createNumber("companyId", Integer.class); + + public final NumberPath id = createNumber("id", Integer.class); + + public final StringPath name = createString("name"); + + public final com.querydsl.sql.PrimaryKey primary = createPrimaryKey(id); + + public final com.querydsl.sql.ForeignKey department_COMPANYIDFK = + createForeignKey(companyId, "ID"); + + public final com.querydsl.sql.ForeignKey + _company_department_departmentsIDFK = createInvForeignKey(id, "departments_ID"); + + public final com.querydsl.sql.ForeignKey + _department_employee_DepartmentIDFK = createInvForeignKey(id, "Department_ID"); + + public SDepartment_(String variable) { + super(SDepartment_.class, forVariable(variable), "null", "department_"); + addMetadata(); + } + + public SDepartment_(String variable, String schema, String table) { + super(SDepartment_.class, forVariable(variable), schema, table); + addMetadata(); + } + + public SDepartment_(String variable, String schema) { + super(SDepartment_.class, forVariable(variable), schema, "department_"); + addMetadata(); + } + + public SDepartment_(Path path) { + super(path.getType(), path.getMetadata(), "null", "department_"); + addMetadata(); + } + + public SDepartment_(PathMetadata metadata) { + super(SDepartment_.class, metadata, "null", "department_"); + addMetadata(); + } + + public void addMetadata() { + addMetadata( + companyId, + ColumnMetadata.named("COMPANY_ID").withIndex(3).ofType(Types.INTEGER).withSize(10)); + addMetadata( + id, ColumnMetadata.named("ID").withIndex(1).ofType(Types.INTEGER).withSize(10).notNull()); + addMetadata( + name, ColumnMetadata.named("NAME").withIndex(2).ofType(Types.VARCHAR).withSize(255)); + } +} diff --git a/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SDepartment_employee_.java b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SDepartment_employee_.java new file mode 100644 index 0000000000..a82e9f259d --- /dev/null +++ b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SDepartment_employee_.java @@ -0,0 +1,76 @@ +package com.querydsl.jpa.domain.sql; + +import static com.querydsl.core.types.PathMetadataFactory.*; + +import com.querydsl.core.types.Path; +import com.querydsl.core.types.PathMetadata; +import com.querydsl.core.types.dsl.*; +import com.querydsl.sql.ColumnMetadata; +import java.sql.Types; +import javax.annotation.processing.Generated; + +/** SDepartment_employee_ is a Querydsl query type for SDepartment_employee_ */ +@Generated("com.querydsl.sql.codegen.MetaDataSerializer") +public class SDepartment_employee_ + extends com.querydsl.sql.RelationalPathBase { + + private static final long serialVersionUID = 1771153228; + + public static final SDepartment_employee_ department_employee_ = + new SDepartment_employee_("department__employee_"); + + public final NumberPath departmentID = createNumber("departmentID", Integer.class); + + public final NumberPath employeesID = createNumber("employeesID", Integer.class); + + public final com.querydsl.sql.PrimaryKey primary = + createPrimaryKey(departmentID, employeesID); + + public final com.querydsl.sql.ForeignKey department_employee_DepartmentIDFK = + createForeignKey(departmentID, "ID"); + + public final com.querydsl.sql.ForeignKey department_employee_employeesIDFK = + createForeignKey(employeesID, "ID"); + + public SDepartment_employee_(String variable) { + super(SDepartment_employee_.class, forVariable(variable), "null", "department__employee_"); + addMetadata(); + } + + public SDepartment_employee_(String variable, String schema, String table) { + super(SDepartment_employee_.class, forVariable(variable), schema, table); + addMetadata(); + } + + public SDepartment_employee_(String variable, String schema) { + super(SDepartment_employee_.class, forVariable(variable), schema, "department__employee_"); + addMetadata(); + } + + public SDepartment_employee_(Path path) { + super(path.getType(), path.getMetadata(), "null", "department__employee_"); + addMetadata(); + } + + public SDepartment_employee_(PathMetadata metadata) { + super(SDepartment_employee_.class, metadata, "null", "department__employee_"); + addMetadata(); + } + + public void addMetadata() { + addMetadata( + departmentID, + ColumnMetadata.named("Department_ID") + .withIndex(1) + .ofType(Types.INTEGER) + .withSize(10) + .notNull()); + addMetadata( + employeesID, + ColumnMetadata.named("employees_ID") + .withIndex(2) + .ofType(Types.INTEGER) + .withSize(10) + .notNull()); + } +} diff --git a/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SDocument2_.java b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SDocument2_.java new file mode 100644 index 0000000000..35ae065a04 --- /dev/null +++ b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SDocument2_.java @@ -0,0 +1,118 @@ +package com.querydsl.jpa.domain.sql; + +import static com.querydsl.core.types.PathMetadataFactory.*; + +import com.querydsl.core.types.Path; +import com.querydsl.core.types.PathMetadata; +import com.querydsl.core.types.dsl.*; +import com.querydsl.sql.ColumnMetadata; +import java.sql.Types; +import javax.annotation.processing.Generated; + +/** SDocument2_ is a Querydsl query type for SDocument2_ */ +@Generated("com.querydsl.sql.codegen.MetaDataSerializer") +public class SDocument2_ extends com.querydsl.sql.RelationalPathBase { + + private static final long serialVersionUID = -743997616; + + public static final SDocument2_ document2_ = new SDocument2_("document2_"); + + public final NumberPath createdby = createNumber("createdby", Double.class); + + public final DateTimePath creationdate = + createDateTime("creationdate", java.sql.Timestamp.class); + + public final NumberPath deletedby = createNumber("deletedby", Double.class); + + public final DateTimePath deleteddate = + createDateTime("deleteddate", java.sql.Timestamp.class); + + public final StringPath documentbody = createString("documentbody"); + + public final NumberPath documentstatus = createNumber("documentstatus", Double.class); + + public final StringPath documentsummary = createString("documentsummary"); + + public final StringPath documenttitle = createString("documenttitle"); + + public final NumberPath documentversion = createNumber("documentversion", Double.class); + + public final NumberPath entryid = createNumber("entryid", Double.class); + + public final NumberPath id = createNumber("id", Long.class); + + public final DateTimePath modificationdate = + createDateTime("modificationdate", java.sql.Timestamp.class); + + public final NumberPath modifiedby = createNumber("modifiedby", Double.class); + + public final com.querydsl.sql.PrimaryKey primary = createPrimaryKey(id); + + public SDocument2_(String variable) { + super(SDocument2_.class, forVariable(variable), "null", "document2_"); + addMetadata(); + } + + public SDocument2_(String variable, String schema, String table) { + super(SDocument2_.class, forVariable(variable), schema, table); + addMetadata(); + } + + public SDocument2_(String variable, String schema) { + super(SDocument2_.class, forVariable(variable), schema, "document2_"); + addMetadata(); + } + + public SDocument2_(Path path) { + super(path.getType(), path.getMetadata(), "null", "document2_"); + addMetadata(); + } + + public SDocument2_(PathMetadata metadata) { + super(SDocument2_.class, metadata, "null", "document2_"); + addMetadata(); + } + + public void addMetadata() { + addMetadata( + createdby, + ColumnMetadata.named("CREATEDBY").withIndex(2).ofType(Types.DOUBLE).withSize(22)); + addMetadata( + creationdate, + ColumnMetadata.named("CREATIONDATE").withIndex(3).ofType(Types.TIMESTAMP).withSize(19)); + addMetadata( + deletedby, + ColumnMetadata.named("DELETEDBY").withIndex(4).ofType(Types.DOUBLE).withSize(22)); + addMetadata( + deleteddate, + ColumnMetadata.named("DELETEDDATE").withIndex(5).ofType(Types.TIMESTAMP).withSize(19)); + addMetadata( + documentbody, + ColumnMetadata.named("DOCUMENTBODY").withIndex(6).ofType(Types.VARCHAR).withSize(255)); + addMetadata( + documentstatus, + ColumnMetadata.named("DOCUMENTSTATUS").withIndex(7).ofType(Types.DOUBLE).withSize(22)); + addMetadata( + documentsummary, + ColumnMetadata.named("DOCUMENTSUMMARY").withIndex(8).ofType(Types.VARCHAR).withSize(255)); + addMetadata( + documenttitle, + ColumnMetadata.named("DOCUMENTTITLE").withIndex(9).ofType(Types.VARCHAR).withSize(255)); + addMetadata( + documentversion, + ColumnMetadata.named("DOCUMENTVERSION").withIndex(10).ofType(Types.DOUBLE).withSize(22)); + addMetadata( + entryid, ColumnMetadata.named("ENTRYID").withIndex(11).ofType(Types.DOUBLE).withSize(22)); + addMetadata( + id, ColumnMetadata.named("ID").withIndex(1).ofType(Types.BIGINT).withSize(19).notNull()); + addMetadata( + modificationdate, + ColumnMetadata.named("MODIFICATIONDATE") + .withIndex(12) + .ofType(Types.TIMESTAMP) + .withSize(19)); + addMetadata( + modifiedby, + ColumnMetadata.named("MODIFIEDBY").withIndex(13).ofType(Types.DOUBLE).withSize(22)); + } +} diff --git a/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SDocument_.java b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SDocument_.java new file mode 100644 index 0000000000..174f85ee63 --- /dev/null +++ b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SDocument_.java @@ -0,0 +1,61 @@ +package com.querydsl.jpa.domain.sql; + +import static com.querydsl.core.types.PathMetadataFactory.*; + +import com.querydsl.core.types.Path; +import com.querydsl.core.types.PathMetadata; +import com.querydsl.core.types.dsl.*; +import com.querydsl.sql.ColumnMetadata; +import java.sql.Types; +import javax.annotation.processing.Generated; + +/** SDocument_ is a Querydsl query type for SDocument_ */ +@Generated("com.querydsl.sql.codegen.MetaDataSerializer") +public class SDocument_ extends com.querydsl.sql.RelationalPathBase { + + private static final long serialVersionUID = 1222926108; + + public static final SDocument_ document_ = new SDocument_("document_"); + + public final NumberPath id = createNumber("id", Integer.class); + + public final StringPath name = createString("name"); + + public final DatePath validto = createDate("validto", java.sql.Date.class); + + public final com.querydsl.sql.PrimaryKey primary = createPrimaryKey(id); + + public SDocument_(String variable) { + super(SDocument_.class, forVariable(variable), "null", "document_"); + addMetadata(); + } + + public SDocument_(String variable, String schema, String table) { + super(SDocument_.class, forVariable(variable), schema, table); + addMetadata(); + } + + public SDocument_(String variable, String schema) { + super(SDocument_.class, forVariable(variable), schema, "document_"); + addMetadata(); + } + + public SDocument_(Path path) { + super(path.getType(), path.getMetadata(), "null", "document_"); + addMetadata(); + } + + public SDocument_(PathMetadata metadata) { + super(SDocument_.class, metadata, "null", "document_"); + addMetadata(); + } + + public void addMetadata() { + addMetadata( + id, ColumnMetadata.named("ID").withIndex(1).ofType(Types.INTEGER).withSize(10).notNull()); + addMetadata( + name, ColumnMetadata.named("NAME").withIndex(2).ofType(Types.VARCHAR).withSize(255)); + addMetadata( + validto, ColumnMetadata.named("VALIDTO").withIndex(3).ofType(Types.DATE).withSize(10)); + } +} diff --git a/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SDocumentprop_.java b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SDocumentprop_.java new file mode 100644 index 0000000000..fec3663148 --- /dev/null +++ b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SDocumentprop_.java @@ -0,0 +1,73 @@ +package com.querydsl.jpa.domain.sql; + +import static com.querydsl.core.types.PathMetadataFactory.*; + +import com.querydsl.core.types.Path; +import com.querydsl.core.types.PathMetadata; +import com.querydsl.core.types.dsl.*; +import com.querydsl.sql.ColumnMetadata; +import java.sql.Types; +import javax.annotation.processing.Generated; + +/** SDocumentprop_ is a Querydsl query type for SDocumentprop_ */ +@Generated("com.querydsl.sql.codegen.MetaDataSerializer") +public class SDocumentprop_ extends com.querydsl.sql.RelationalPathBase { + + private static final long serialVersionUID = 1951170969; + + public static final SDocumentprop_ documentprop_ = new SDocumentprop_("documentprop_"); + + public final NumberPath documentid = createNumber("documentid", Double.class); + + public final NumberPath id = createNumber("id", Long.class); + + public final StringPath propname = createString("propname"); + + public final StringPath propvalue = createString("propvalue"); + + public final StringPath propvaluedetails = createString("propvaluedetails"); + + public final com.querydsl.sql.PrimaryKey primary = createPrimaryKey(id); + + public SDocumentprop_(String variable) { + super(SDocumentprop_.class, forVariable(variable), "null", "documentprop_"); + addMetadata(); + } + + public SDocumentprop_(String variable, String schema, String table) { + super(SDocumentprop_.class, forVariable(variable), schema, table); + addMetadata(); + } + + public SDocumentprop_(String variable, String schema) { + super(SDocumentprop_.class, forVariable(variable), schema, "documentprop_"); + addMetadata(); + } + + public SDocumentprop_(Path path) { + super(path.getType(), path.getMetadata(), "null", "documentprop_"); + addMetadata(); + } + + public SDocumentprop_(PathMetadata metadata) { + super(SDocumentprop_.class, metadata, "null", "documentprop_"); + addMetadata(); + } + + public void addMetadata() { + addMetadata( + documentid, + ColumnMetadata.named("DOCUMENTID").withIndex(2).ofType(Types.DOUBLE).withSize(22)); + addMetadata( + id, ColumnMetadata.named("ID").withIndex(1).ofType(Types.BIGINT).withSize(19).notNull()); + addMetadata( + propname, + ColumnMetadata.named("PROPNAME").withIndex(3).ofType(Types.VARCHAR).withSize(255)); + addMetadata( + propvalue, + ColumnMetadata.named("PROPVALUE").withIndex(4).ofType(Types.VARCHAR).withSize(255)); + addMetadata( + propvaluedetails, + ColumnMetadata.named("PROPVALUEDETAILS").withIndex(5).ofType(Types.VARCHAR).withSize(255)); + } +} diff --git a/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SEmployee.java b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SEmployee.java index 82868188ae..8dfa8dcd7f 100644 --- a/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SEmployee.java +++ b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SEmployee.java @@ -1,51 +1,46 @@ package com.querydsl.jpa.domain.sql; -import static com.querydsl.core.types.PathMetadataFactory.forVariable; +import static com.querydsl.core.types.PathMetadataFactory.*; import com.querydsl.core.types.Path; import com.querydsl.core.types.PathMetadata; -import com.querydsl.core.types.dsl.NumberPath; -import com.querydsl.core.types.dsl.StringPath; +import com.querydsl.core.types.dsl.*; import com.querydsl.sql.ColumnMetadata; -import jakarta.annotation.Generated; +import java.sql.Types; +import javax.annotation.processing.Generated; /** SEmployee is a Querydsl query type for SEmployee */ @Generated("com.querydsl.sql.codegen.MetaDataSerializer") public class SEmployee extends com.querydsl.sql.RelationalPathBase { - private static final long serialVersionUID = 461493664; + private static final long serialVersionUID = 1202481974; - public static final SEmployee employee_ = new SEmployee("employee_"); + public static final SEmployee employee = new SEmployee("EMPLOYEE"); - public final NumberPath companyId = createNumber("companyId", Integer.class); + public final DatePath datefield = createDate("datefield", java.sql.Date.class); - public final StringPath firstName = createString("firstName"); + public final StringPath firstname = createString("firstname"); public final NumberPath id = createNumber("id", Integer.class); - public final StringPath lastName = createString("lastName"); + public final StringPath lastname = createString("lastname"); - public final NumberPath userId = createNumber("userId", Long.class); + public final NumberPath salary = createNumber("salary", Long.class); - public final com.querydsl.sql.PrimaryKey primary = createPrimaryKey(id); - - public final com.querydsl.sql.ForeignKey fk9d39ef71dc953998 = - createForeignKey(companyId, "id"); + public final NumberPath superiorId = createNumber("superiorId", Integer.class); - public final com.querydsl.sql.ForeignKey fk9d39ef712743b59c = - createForeignKey(userId, "id"); + public final TimePath timefield = createTime("timefield", java.sql.Time.class); - public final com.querydsl.sql.ForeignKey _fkdc405382edf003bd = - createInvForeignKey(id, "ceo_id"); + public final com.querydsl.sql.PrimaryKey primary = createPrimaryKey(id); - public final com.querydsl.sql.ForeignKey _fk49690e2f75b8f5bc = - createInvForeignKey(id, "Employee_id"); + public final com.querydsl.sql.ForeignKey superiorFk = + createForeignKey(superiorId, "ID"); - public final com.querydsl.sql.ForeignKey _fkc33a14ffd846a985 = - createInvForeignKey(id, "employees_id"); + public final com.querydsl.sql.ForeignKey _superiorFk = + createInvForeignKey(id, "SUPERIOR_ID"); public SEmployee(String variable) { - super(SEmployee.class, forVariable(variable), "", "employee_"); + super(SEmployee.class, forVariable(variable), "null", "EMPLOYEE"); addMetadata(); } @@ -54,21 +49,37 @@ public SEmployee(String variable, String schema, String table) { addMetadata(); } + public SEmployee(String variable, String schema) { + super(SEmployee.class, forVariable(variable), schema, "EMPLOYEE"); + addMetadata(); + } + public SEmployee(Path path) { - super(path.getType(), path.getMetadata(), "", "employee_"); + super(path.getType(), path.getMetadata(), "null", "EMPLOYEE"); addMetadata(); } public SEmployee(PathMetadata metadata) { - super(SEmployee.class, metadata, "", "employee_"); + super(SEmployee.class, metadata, "null", "EMPLOYEE"); addMetadata(); } public void addMetadata() { - addMetadata(companyId, ColumnMetadata.named("company_id").withIndex(4).ofType(4).withSize(10)); - addMetadata(firstName, ColumnMetadata.named("firstName").withIndex(2).ofType(12).withSize(255)); - addMetadata(id, ColumnMetadata.named("id").withIndex(1).ofType(4).withSize(10).notNull()); - addMetadata(lastName, ColumnMetadata.named("lastName").withIndex(3).ofType(12).withSize(255)); - addMetadata(userId, ColumnMetadata.named("user_id").withIndex(5).ofType(-5).withSize(19)); + addMetadata( + datefield, ColumnMetadata.named("DATEFIELD").withIndex(5).ofType(Types.DATE).withSize(10)); + addMetadata( + firstname, + ColumnMetadata.named("FIRSTNAME").withIndex(2).ofType(Types.VARCHAR).withSize(50)); + addMetadata( + id, ColumnMetadata.named("ID").withIndex(1).ofType(Types.INTEGER).withSize(10).notNull()); + addMetadata( + lastname, ColumnMetadata.named("LASTNAME").withIndex(3).ofType(Types.VARCHAR).withSize(50)); + addMetadata( + salary, ColumnMetadata.named("SALARY").withIndex(4).ofType(Types.DECIMAL).withSize(10)); + addMetadata( + superiorId, + ColumnMetadata.named("SUPERIOR_ID").withIndex(7).ofType(Types.INTEGER).withSize(10)); + addMetadata( + timefield, ColumnMetadata.named("TIMEFIELD").withIndex(6).ofType(Types.TIME).withSize(8)); } } diff --git a/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SEmployeeJOBFUNCTIONS.java b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SEmployeeJOBFUNCTIONS.java new file mode 100644 index 0000000000..e3dd6c531f --- /dev/null +++ b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SEmployeeJOBFUNCTIONS.java @@ -0,0 +1,62 @@ +package com.querydsl.jpa.domain.sql; + +import static com.querydsl.core.types.PathMetadataFactory.*; + +import com.querydsl.core.types.Path; +import com.querydsl.core.types.PathMetadata; +import com.querydsl.core.types.dsl.*; +import com.querydsl.sql.ColumnMetadata; +import java.sql.Types; +import javax.annotation.processing.Generated; + +/** SEmployeeJOBFUNCTIONS is a Querydsl query type for SEmployeeJOBFUNCTIONS */ +@Generated("com.querydsl.sql.codegen.MetaDataSerializer") +public class SEmployeeJOBFUNCTIONS + extends com.querydsl.sql.RelationalPathBase { + + private static final long serialVersionUID = -40205644; + + public static final SEmployeeJOBFUNCTIONS EmployeeJOBFUNCTIONS = + new SEmployeeJOBFUNCTIONS("Employee_JOBFUNCTIONS"); + + public final NumberPath employeeID = createNumber("employeeID", Integer.class); + + public final StringPath jobfunction = createString("jobfunction"); + + public final com.querydsl.sql.ForeignKey employeeJOBFUNCTIONSEmployeeIDFK = + createForeignKey(employeeID, "ID"); + + public SEmployeeJOBFUNCTIONS(String variable) { + super(SEmployeeJOBFUNCTIONS.class, forVariable(variable), "null", "Employee_JOBFUNCTIONS"); + addMetadata(); + } + + public SEmployeeJOBFUNCTIONS(String variable, String schema, String table) { + super(SEmployeeJOBFUNCTIONS.class, forVariable(variable), schema, table); + addMetadata(); + } + + public SEmployeeJOBFUNCTIONS(String variable, String schema) { + super(SEmployeeJOBFUNCTIONS.class, forVariable(variable), schema, "Employee_JOBFUNCTIONS"); + addMetadata(); + } + + public SEmployeeJOBFUNCTIONS(Path path) { + super(path.getType(), path.getMetadata(), "null", "Employee_JOBFUNCTIONS"); + addMetadata(); + } + + public SEmployeeJOBFUNCTIONS(PathMetadata metadata) { + super(SEmployeeJOBFUNCTIONS.class, metadata, "null", "Employee_JOBFUNCTIONS"); + addMetadata(); + } + + public void addMetadata() { + addMetadata( + employeeID, + ColumnMetadata.named("Employee_ID").withIndex(1).ofType(Types.INTEGER).withSize(10)); + addMetadata( + jobfunction, + ColumnMetadata.named("jobfunction").withIndex(2).ofType(Types.VARCHAR).withSize(255)); + } +} diff --git a/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SEmployee_.java b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SEmployee_.java new file mode 100644 index 0000000000..54e8f41222 --- /dev/null +++ b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SEmployee_.java @@ -0,0 +1,87 @@ +package com.querydsl.jpa.domain.sql; + +import static com.querydsl.core.types.PathMetadataFactory.*; + +import com.querydsl.core.types.Path; +import com.querydsl.core.types.PathMetadata; +import com.querydsl.core.types.dsl.*; +import com.querydsl.sql.ColumnMetadata; +import java.sql.Types; +import javax.annotation.processing.Generated; + +/** SEmployee_ is a Querydsl query type for SEmployee_ */ +@Generated("com.querydsl.sql.codegen.MetaDataSerializer") +public class SEmployee_ extends com.querydsl.sql.RelationalPathBase { + + private static final long serialVersionUID = -1377764375; + + public static final SEmployee_ employee_ = new SEmployee_("employee_"); + + public final NumberPath companyId = createNumber("companyId", Integer.class); + + public final StringPath firstname = createString("firstname"); + + public final NumberPath id = createNumber("id", Integer.class); + + public final StringPath lastname = createString("lastname"); + + public final NumberPath userId = createNumber("userId", Long.class); + + public final com.querydsl.sql.PrimaryKey primary = createPrimaryKey(id); + + public final com.querydsl.sql.ForeignKey employee_COMPANYIDFK = + createForeignKey(companyId, "ID"); + + public final com.querydsl.sql.ForeignKey employee_USERIDFK = + createForeignKey(userId, "ID"); + + public final com.querydsl.sql.ForeignKey + _employeeJOBFUNCTIONSEmployeeIDFK = createInvForeignKey(id, "Employee_ID"); + + public final com.querydsl.sql.ForeignKey _company_CEOIDFK = + createInvForeignKey(id, "CEO_ID"); + + public final com.querydsl.sql.ForeignKey + _department_employee_employeesIDFK = createInvForeignKey(id, "employees_ID"); + + public SEmployee_(String variable) { + super(SEmployee_.class, forVariable(variable), "null", "employee_"); + addMetadata(); + } + + public SEmployee_(String variable, String schema, String table) { + super(SEmployee_.class, forVariable(variable), schema, table); + addMetadata(); + } + + public SEmployee_(String variable, String schema) { + super(SEmployee_.class, forVariable(variable), schema, "employee_"); + addMetadata(); + } + + public SEmployee_(Path path) { + super(path.getType(), path.getMetadata(), "null", "employee_"); + addMetadata(); + } + + public SEmployee_(PathMetadata metadata) { + super(SEmployee_.class, metadata, "null", "employee_"); + addMetadata(); + } + + public void addMetadata() { + addMetadata( + companyId, + ColumnMetadata.named("COMPANY_ID").withIndex(4).ofType(Types.INTEGER).withSize(10)); + addMetadata( + firstname, + ColumnMetadata.named("FIRSTNAME").withIndex(2).ofType(Types.VARCHAR).withSize(255)); + addMetadata( + id, ColumnMetadata.named("ID").withIndex(1).ofType(Types.INTEGER).withSize(10).notNull()); + addMetadata( + lastname, + ColumnMetadata.named("LASTNAME").withIndex(3).ofType(Types.VARCHAR).withSize(255)); + addMetadata( + userId, ColumnMetadata.named("USER_ID").withIndex(5).ofType(Types.BIGINT).withSize(19)); + } +} diff --git a/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SEntity1.java b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SEntity1.java index 6320faa243..fd6d62ed09 100644 --- a/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SEntity1.java +++ b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SEntity1.java @@ -1,21 +1,21 @@ package com.querydsl.jpa.domain.sql; -import static com.querydsl.core.types.PathMetadataFactory.forVariable; +import static com.querydsl.core.types.PathMetadataFactory.*; import com.querydsl.core.types.Path; import com.querydsl.core.types.PathMetadata; -import com.querydsl.core.types.dsl.NumberPath; -import com.querydsl.core.types.dsl.StringPath; +import com.querydsl.core.types.dsl.*; import com.querydsl.sql.ColumnMetadata; -import jakarta.annotation.Generated; +import java.sql.Types; +import javax.annotation.processing.Generated; /** SEntity1 is a Querydsl query type for SEntity1 */ @Generated("com.querydsl.sql.codegen.MetaDataSerializer") public class SEntity1 extends com.querydsl.sql.RelationalPathBase { - private static final long serialVersionUID = 1060650653; + private static final long serialVersionUID = 1317954342; - public static final SEntity1 Entity1 = new SEntity1("Entity1"); + public static final SEntity1 entity1 = new SEntity1("ENTITY1"); public final StringPath dtype = createString("dtype"); @@ -28,7 +28,7 @@ public class SEntity1 extends com.querydsl.sql.RelationalPathBase { public final com.querydsl.sql.PrimaryKey primary = createPrimaryKey(id); public SEntity1(String variable) { - super(SEntity1.class, forVariable(variable), "", "Entity1"); + super(SEntity1.class, forVariable(variable), "null", "ENTITY1"); addMetadata(); } @@ -37,21 +37,31 @@ public SEntity1(String variable, String schema, String table) { addMetadata(); } + public SEntity1(String variable, String schema) { + super(SEntity1.class, forVariable(variable), schema, "ENTITY1"); + addMetadata(); + } + public SEntity1(Path path) { - super(path.getType(), path.getMetadata(), "", "Entity1"); + super(path.getType(), path.getMetadata(), "null", "ENTITY1"); addMetadata(); } public SEntity1(PathMetadata metadata) { - super(SEntity1.class, metadata, "", "Entity1"); + super(SEntity1.class, metadata, "null", "ENTITY1"); addMetadata(); } public void addMetadata() { addMetadata( - dtype, ColumnMetadata.named("DTYPE").withIndex(1).ofType(12).withSize(31).notNull()); - addMetadata(id, ColumnMetadata.named("id").withIndex(2).ofType(4).withSize(10).notNull()); - addMetadata(property, ColumnMetadata.named("property").withIndex(3).ofType(12).withSize(255)); - addMetadata(property2, ColumnMetadata.named("property2").withIndex(4).ofType(12).withSize(255)); + dtype, ColumnMetadata.named("DTYPE").withIndex(2).ofType(Types.VARCHAR).withSize(31)); + addMetadata( + id, ColumnMetadata.named("ID").withIndex(1).ofType(Types.INTEGER).withSize(10).notNull()); + addMetadata( + property, + ColumnMetadata.named("PROPERTY").withIndex(3).ofType(Types.VARCHAR).withSize(255)); + addMetadata( + property2, + ColumnMetadata.named("PROPERTY2").withIndex(4).ofType(Types.VARCHAR).withSize(255)); } } diff --git a/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SEviltype_.java b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SEviltype_.java new file mode 100644 index 0000000000..9d369b3c63 --- /dev/null +++ b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SEviltype_.java @@ -0,0 +1,191 @@ +package com.querydsl.jpa.domain.sql; + +import static com.querydsl.core.types.PathMetadataFactory.*; + +import com.querydsl.core.types.Path; +import com.querydsl.core.types.PathMetadata; +import com.querydsl.core.types.dsl.*; +import com.querydsl.sql.ColumnMetadata; +import java.sql.Types; +import javax.annotation.processing.Generated; + +/** SEviltype_ is a Querydsl query type for SEviltype_ */ +@Generated("com.querydsl.sql.codegen.MetaDataSerializer") +public class SEviltype_ extends com.querydsl.sql.RelationalPathBase { + + private static final long serialVersionUID = -490303543; + + public static final SEviltype_ eviltype_ = new SEviltype_("eviltype_"); + + public final NumberPath _asc = createNumber("_asc", Integer.class); + + public final NumberPath _desc = createNumber("_desc", Integer.class); + + public final NumberPath getclassId = createNumber("getclassId", Integer.class); + + public final NumberPath getId = createNumber("getId", Integer.class); + + public final NumberPath getmetadataId = createNumber("getmetadataId", Integer.class); + + public final NumberPath gettypeId = createNumber("gettypeId", Integer.class); + + public final NumberPath hashcodeId = createNumber("hashcodeId", Integer.class); + + public final NumberPath id = createNumber("id", Integer.class); + + public final NumberPath isnotnullId = createNumber("isnotnullId", Integer.class); + + public final NumberPath isnullId = createNumber("isnullId", Integer.class); + + public final NumberPath notifyallId = createNumber("notifyallId", Integer.class); + + public final NumberPath notifyId = createNumber("notifyId", Integer.class); + + public final NumberPath tostringId = createNumber("tostringId", Integer.class); + + public final NumberPath waitId = createNumber("waitId", Integer.class); + + public final com.querydsl.sql.PrimaryKey primary = createPrimaryKey(id); + + public final com.querydsl.sql.ForeignKey eviltype_GETCLASSIDFK = + createForeignKey(getclassId, "ID"); + + public final com.querydsl.sql.ForeignKey eviltype_GETMETADATAIDFK = + createForeignKey(getmetadataId, "ID"); + + public final com.querydsl.sql.ForeignKey eviltype_GETTYPEIDFK = + createForeignKey(gettypeId, "ID"); + + public final com.querydsl.sql.ForeignKey eviltype_GETIDFK = + createForeignKey(getId, "ID"); + + public final com.querydsl.sql.ForeignKey eviltype_HASHCODEIDFK = + createForeignKey(hashcodeId, "ID"); + + public final com.querydsl.sql.ForeignKey eviltype_ISNOTNULLIDFK = + createForeignKey(isnotnullId, "ID"); + + public final com.querydsl.sql.ForeignKey eviltype_ISNULLIDFK = + createForeignKey(isnullId, "ID"); + + public final com.querydsl.sql.ForeignKey eviltype_NOTIFYALLIDFK = + createForeignKey(notifyallId, "ID"); + + public final com.querydsl.sql.ForeignKey eviltype_NOTIFYIDFK = + createForeignKey(notifyId, "ID"); + + public final com.querydsl.sql.ForeignKey eviltype_TOSTRINGIDFK = + createForeignKey(tostringId, "ID"); + + public final com.querydsl.sql.ForeignKey eviltype_WAITIDFK = + createForeignKey(waitId, "ID"); + + public final com.querydsl.sql.ForeignKey eviltype_AscFK = + createForeignKey(_asc, "ID"); + + public final com.querydsl.sql.ForeignKey eviltype_DescFK = + createForeignKey(_desc, "ID"); + + public final com.querydsl.sql.ForeignKey _eviltype_GETCLASSIDFK = + createInvForeignKey(id, "GETCLASS_ID"); + + public final com.querydsl.sql.ForeignKey _eviltype_GETMETADATAIDFK = + createInvForeignKey(id, "GETMETADATA_ID"); + + public final com.querydsl.sql.ForeignKey _eviltype_GETTYPEIDFK = + createInvForeignKey(id, "GETTYPE_ID"); + + public final com.querydsl.sql.ForeignKey _eviltype_GETIDFK = + createInvForeignKey(id, "GET_ID"); + + public final com.querydsl.sql.ForeignKey _eviltype_HASHCODEIDFK = + createInvForeignKey(id, "HASHCODE_ID"); + + public final com.querydsl.sql.ForeignKey _eviltype_ISNOTNULLIDFK = + createInvForeignKey(id, "ISNOTNULL_ID"); + + public final com.querydsl.sql.ForeignKey _eviltype_ISNULLIDFK = + createInvForeignKey(id, "ISNULL_ID"); + + public final com.querydsl.sql.ForeignKey _eviltype_NOTIFYALLIDFK = + createInvForeignKey(id, "NOTIFYALL_ID"); + + public final com.querydsl.sql.ForeignKey _eviltype_NOTIFYIDFK = + createInvForeignKey(id, "NOTIFY_ID"); + + public final com.querydsl.sql.ForeignKey _eviltype_TOSTRINGIDFK = + createInvForeignKey(id, "TOSTRING_ID"); + + public final com.querydsl.sql.ForeignKey _eviltype_WAITIDFK = + createInvForeignKey(id, "WAIT_ID"); + + public final com.querydsl.sql.ForeignKey _eviltype_AscFK = + createInvForeignKey(id, "_asc"); + + public final com.querydsl.sql.ForeignKey _eviltype_DescFK = + createInvForeignKey(id, "_desc"); + + public SEviltype_(String variable) { + super(SEviltype_.class, forVariable(variable), "null", "eviltype_"); + addMetadata(); + } + + public SEviltype_(String variable, String schema, String table) { + super(SEviltype_.class, forVariable(variable), schema, table); + addMetadata(); + } + + public SEviltype_(String variable, String schema) { + super(SEviltype_.class, forVariable(variable), schema, "eviltype_"); + addMetadata(); + } + + public SEviltype_(Path path) { + super(path.getType(), path.getMetadata(), "null", "eviltype_"); + addMetadata(); + } + + public SEviltype_(PathMetadata metadata) { + super(SEviltype_.class, metadata, "null", "eviltype_"); + addMetadata(); + } + + public void addMetadata() { + addMetadata(_asc, ColumnMetadata.named("_asc").withIndex(2).ofType(Types.INTEGER).withSize(10)); + addMetadata( + _desc, ColumnMetadata.named("_desc").withIndex(3).ofType(Types.INTEGER).withSize(10)); + addMetadata( + getclassId, + ColumnMetadata.named("GETCLASS_ID").withIndex(5).ofType(Types.INTEGER).withSize(10)); + addMetadata( + getId, ColumnMetadata.named("GET_ID").withIndex(4).ofType(Types.INTEGER).withSize(10)); + addMetadata( + getmetadataId, + ColumnMetadata.named("GETMETADATA_ID").withIndex(6).ofType(Types.INTEGER).withSize(10)); + addMetadata( + gettypeId, + ColumnMetadata.named("GETTYPE_ID").withIndex(7).ofType(Types.INTEGER).withSize(10)); + addMetadata( + hashcodeId, + ColumnMetadata.named("HASHCODE_ID").withIndex(8).ofType(Types.INTEGER).withSize(10)); + addMetadata( + id, ColumnMetadata.named("ID").withIndex(1).ofType(Types.INTEGER).withSize(10).notNull()); + addMetadata( + isnotnullId, + ColumnMetadata.named("ISNOTNULL_ID").withIndex(9).ofType(Types.INTEGER).withSize(10)); + addMetadata( + isnullId, + ColumnMetadata.named("ISNULL_ID").withIndex(10).ofType(Types.INTEGER).withSize(10)); + addMetadata( + notifyallId, + ColumnMetadata.named("NOTIFYALL_ID").withIndex(12).ofType(Types.INTEGER).withSize(10)); + addMetadata( + notifyId, + ColumnMetadata.named("NOTIFY_ID").withIndex(11).ofType(Types.INTEGER).withSize(10)); + addMetadata( + tostringId, + ColumnMetadata.named("TOSTRING_ID").withIndex(13).ofType(Types.INTEGER).withSize(10)); + addMetadata( + waitId, ColumnMetadata.named("WAIT_ID").withIndex(14).ofType(Types.INTEGER).withSize(10)); + } +} diff --git a/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SFooNames.java b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SFooNames.java index badeeb7eb6..80ffb1250d 100644 --- a/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SFooNames.java +++ b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SFooNames.java @@ -1,19 +1,19 @@ package com.querydsl.jpa.domain.sql; -import static com.querydsl.core.types.PathMetadataFactory.forVariable; +import static com.querydsl.core.types.PathMetadataFactory.*; import com.querydsl.core.types.Path; import com.querydsl.core.types.PathMetadata; -import com.querydsl.core.types.dsl.NumberPath; -import com.querydsl.core.types.dsl.StringPath; +import com.querydsl.core.types.dsl.*; import com.querydsl.sql.ColumnMetadata; -import jakarta.annotation.Generated; +import java.sql.Types; +import javax.annotation.processing.Generated; /** SFooNames is a Querydsl query type for SFooNames */ @Generated("com.querydsl.sql.codegen.MetaDataSerializer") public class SFooNames extends com.querydsl.sql.RelationalPathBase { - private static final long serialVersionUID = 982089235; + private static final long serialVersionUID = 368569002; public static final SFooNames fooNames = new SFooNames("foo_names"); @@ -21,10 +21,10 @@ public class SFooNames extends com.querydsl.sql.RelationalPathBase { public final StringPath names = createString("names"); - public final com.querydsl.sql.ForeignKey fkb6129a8f94e297f8 = createForeignKey(fooId, "id"); + public final com.querydsl.sql.ForeignKey fooNamesFooIdFK = createForeignKey(fooId, "ID"); public SFooNames(String variable) { - super(SFooNames.class, forVariable(variable), "", "foo_names"); + super(SFooNames.class, forVariable(variable), "null", "foo_names"); addMetadata(); } @@ -33,19 +33,25 @@ public SFooNames(String variable, String schema, String table) { addMetadata(); } + public SFooNames(String variable, String schema) { + super(SFooNames.class, forVariable(variable), schema, "foo_names"); + addMetadata(); + } + public SFooNames(Path path) { - super(path.getType(), path.getMetadata(), "", "foo_names"); + super(path.getType(), path.getMetadata(), "null", "foo_names"); addMetadata(); } public SFooNames(PathMetadata metadata) { - super(SFooNames.class, metadata, "", "foo_names"); + super(SFooNames.class, metadata, "null", "foo_names"); addMetadata(); } public void addMetadata() { addMetadata( - fooId, ColumnMetadata.named("foo_id").withIndex(1).ofType(4).withSize(10).notNull()); - addMetadata(names, ColumnMetadata.named("names").withIndex(2).ofType(12).withSize(255)); + fooId, ColumnMetadata.named("foo_id").withIndex(1).ofType(Types.INTEGER).withSize(10)); + addMetadata( + names, ColumnMetadata.named("NAMES").withIndex(2).ofType(Types.VARCHAR).withSize(255)); } } diff --git a/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SFoo_.java b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SFoo_.java new file mode 100644 index 0000000000..57ef52b89b --- /dev/null +++ b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SFoo_.java @@ -0,0 +1,63 @@ +package com.querydsl.jpa.domain.sql; + +import static com.querydsl.core.types.PathMetadataFactory.*; + +import com.querydsl.core.types.Path; +import com.querydsl.core.types.PathMetadata; +import com.querydsl.core.types.dsl.*; +import com.querydsl.sql.ColumnMetadata; +import java.sql.Types; +import javax.annotation.processing.Generated; + +/** SFoo_ is a Querydsl query type for SFoo_ */ +@Generated("com.querydsl.sql.codegen.MetaDataSerializer") +public class SFoo_ extends com.querydsl.sql.RelationalPathBase { + + private static final long serialVersionUID = 1493243105; + + public static final SFoo_ foo_ = new SFoo_("foo_"); + + public final StringPath bar = createString("bar"); + + public final NumberPath id = createNumber("id", Integer.class); + + public final DatePath startdate = createDate("startdate", java.sql.Date.class); + + public final com.querydsl.sql.PrimaryKey primary = createPrimaryKey(id); + + public final com.querydsl.sql.ForeignKey _fooNamesFooIdFK = + createInvForeignKey(id, "foo_id"); + + public SFoo_(String variable) { + super(SFoo_.class, forVariable(variable), "null", "foo_"); + addMetadata(); + } + + public SFoo_(String variable, String schema, String table) { + super(SFoo_.class, forVariable(variable), schema, table); + addMetadata(); + } + + public SFoo_(String variable, String schema) { + super(SFoo_.class, forVariable(variable), schema, "foo_"); + addMetadata(); + } + + public SFoo_(Path path) { + super(path.getType(), path.getMetadata(), "null", "foo_"); + addMetadata(); + } + + public SFoo_(PathMetadata metadata) { + super(SFoo_.class, metadata, "null", "foo_"); + addMetadata(); + } + + public void addMetadata() { + addMetadata(bar, ColumnMetadata.named("BAR").withIndex(2).ofType(Types.VARCHAR).withSize(255)); + addMetadata( + id, ColumnMetadata.named("ID").withIndex(1).ofType(Types.INTEGER).withSize(10).notNull()); + addMetadata( + startdate, ColumnMetadata.named("STARTDATE").withIndex(3).ofType(Types.DATE).withSize(10)); + } +} diff --git a/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SFormula_.java b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SFormula_.java new file mode 100644 index 0000000000..115b259c79 --- /dev/null +++ b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SFormula_.java @@ -0,0 +1,61 @@ +package com.querydsl.jpa.domain.sql; + +import static com.querydsl.core.types.PathMetadataFactory.*; + +import com.querydsl.core.types.Path; +import com.querydsl.core.types.PathMetadata; +import com.querydsl.core.types.dsl.*; +import com.querydsl.sql.ColumnMetadata; +import java.sql.Types; +import javax.annotation.processing.Generated; + +/** SFormula_ is a Querydsl query type for SFormula_ */ +@Generated("com.querydsl.sql.codegen.MetaDataSerializer") +public class SFormula_ extends com.querydsl.sql.RelationalPathBase { + + private static final long serialVersionUID = 483680321; + + public static final SFormula_ formula_ = new SFormula_("formula_"); + + public final NumberPath id = createNumber("id", Integer.class); + + public final NumberPath parameterId = createNumber("parameterId", Long.class); + + public final com.querydsl.sql.PrimaryKey primary = createPrimaryKey(id); + + public final com.querydsl.sql.ForeignKey formula_PARAMETERIDFK = + createForeignKey(parameterId, "ID"); + + public SFormula_(String variable) { + super(SFormula_.class, forVariable(variable), "null", "formula_"); + addMetadata(); + } + + public SFormula_(String variable, String schema, String table) { + super(SFormula_.class, forVariable(variable), schema, table); + addMetadata(); + } + + public SFormula_(String variable, String schema) { + super(SFormula_.class, forVariable(variable), schema, "formula_"); + addMetadata(); + } + + public SFormula_(Path path) { + super(path.getType(), path.getMetadata(), "null", "formula_"); + addMetadata(); + } + + public SFormula_(PathMetadata metadata) { + super(SFormula_.class, metadata, "null", "formula_"); + addMetadata(); + } + + public void addMetadata() { + addMetadata( + id, ColumnMetadata.named("ID").withIndex(1).ofType(Types.INTEGER).withSize(10).notNull()); + addMetadata( + parameterId, + ColumnMetadata.named("PARAMETER_ID").withIndex(2).ofType(Types.BIGINT).withSize(19)); + } +} diff --git a/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SGeneratedKeys.java b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SGeneratedKeys.java index c29d3cb7aa..a279df955c 100644 --- a/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SGeneratedKeys.java +++ b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SGeneratedKeys.java @@ -1,19 +1,19 @@ package com.querydsl.jpa.domain.sql; -import static com.querydsl.core.types.PathMetadataFactory.forVariable; +import static com.querydsl.core.types.PathMetadataFactory.*; import com.querydsl.core.types.Path; import com.querydsl.core.types.PathMetadata; -import com.querydsl.core.types.dsl.NumberPath; -import com.querydsl.core.types.dsl.StringPath; +import com.querydsl.core.types.dsl.*; import com.querydsl.sql.ColumnMetadata; -import jakarta.annotation.Generated; +import java.sql.Types; +import javax.annotation.processing.Generated; /** SGeneratedKeys is a Querydsl query type for SGeneratedKeys */ @Generated("com.querydsl.sql.codegen.MetaDataSerializer") public class SGeneratedKeys extends com.querydsl.sql.RelationalPathBase { - private static final long serialVersionUID = 379851474; + private static final long serialVersionUID = 2097474715; public static final SGeneratedKeys generatedKeys = new SGeneratedKeys("GENERATED_KEYS"); @@ -24,7 +24,7 @@ public class SGeneratedKeys extends com.querydsl.sql.RelationalPathBase primary = createPrimaryKey(id); public SGeneratedKeys(String variable) { - super(SGeneratedKeys.class, forVariable(variable), "", "GENERATED_KEYS"); + super(SGeneratedKeys.class, forVariable(variable), "null", "GENERATED_KEYS"); addMetadata(); } @@ -33,18 +33,24 @@ public SGeneratedKeys(String variable, String schema, String table) { addMetadata(); } + public SGeneratedKeys(String variable, String schema) { + super(SGeneratedKeys.class, forVariable(variable), schema, "GENERATED_KEYS"); + addMetadata(); + } + public SGeneratedKeys(Path path) { - super(path.getType(), path.getMetadata(), "", "GENERATED_KEYS"); + super(path.getType(), path.getMetadata(), "null", "GENERATED_KEYS"); addMetadata(); } public SGeneratedKeys(PathMetadata metadata) { - super(SGeneratedKeys.class, metadata, "", "GENERATED_KEYS"); + super(SGeneratedKeys.class, metadata, "null", "GENERATED_KEYS"); addMetadata(); } public void addMetadata() { - addMetadata(id, ColumnMetadata.named("ID").withIndex(1).ofType(4).withSize(10).notNull()); - addMetadata(name, ColumnMetadata.named("NAME").withIndex(2).ofType(12).withSize(30)); + addMetadata( + id, ColumnMetadata.named("ID").withIndex(1).ofType(Types.INTEGER).withSize(10).notNull()); + addMetadata(name, ColumnMetadata.named("NAME").withIndex(2).ofType(Types.VARCHAR).withSize(30)); } } diff --git a/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SGroup_.java b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SGroup_.java new file mode 100644 index 0000000000..98c9ee34e2 --- /dev/null +++ b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SGroup_.java @@ -0,0 +1,57 @@ +package com.querydsl.jpa.domain.sql; + +import static com.querydsl.core.types.PathMetadataFactory.*; + +import com.querydsl.core.types.Path; +import com.querydsl.core.types.PathMetadata; +import com.querydsl.core.types.dsl.*; +import com.querydsl.sql.ColumnMetadata; +import java.sql.Types; +import javax.annotation.processing.Generated; + +/** SGroup_ is a Querydsl query type for SGroup_ */ +@Generated("com.querydsl.sql.codegen.MetaDataSerializer") +public class SGroup_ extends com.querydsl.sql.RelationalPathBase { + + private static final long serialVersionUID = 518971464; + + public static final SGroup_ group_ = new SGroup_("group_"); + + public final NumberPath id = createNumber("id", Integer.class); + + public final StringPath name = createString("name"); + + public final com.querydsl.sql.PrimaryKey primary = createPrimaryKey(id); + + public SGroup_(String variable) { + super(SGroup_.class, forVariable(variable), "null", "group_"); + addMetadata(); + } + + public SGroup_(String variable, String schema, String table) { + super(SGroup_.class, forVariable(variable), schema, table); + addMetadata(); + } + + public SGroup_(String variable, String schema) { + super(SGroup_.class, forVariable(variable), schema, "group_"); + addMetadata(); + } + + public SGroup_(Path path) { + super(path.getType(), path.getMetadata(), "null", "group_"); + addMetadata(); + } + + public SGroup_(PathMetadata metadata) { + super(SGroup_.class, metadata, "null", "group_"); + addMetadata(); + } + + public void addMetadata() { + addMetadata( + id, ColumnMetadata.named("ID").withIndex(1).ofType(Types.INTEGER).withSize(10).notNull()); + addMetadata( + name, ColumnMetadata.named("NAME").withIndex(2).ofType(Types.VARCHAR).withSize(255)); + } +} diff --git a/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SHumanHAIRS.java b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SHumanHAIRS.java new file mode 100644 index 0000000000..03eef61dac --- /dev/null +++ b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SHumanHAIRS.java @@ -0,0 +1,58 @@ +package com.querydsl.jpa.domain.sql; + +import static com.querydsl.core.types.PathMetadataFactory.*; + +import com.querydsl.core.types.Path; +import com.querydsl.core.types.PathMetadata; +import com.querydsl.core.types.dsl.*; +import com.querydsl.sql.ColumnMetadata; +import java.sql.Types; +import javax.annotation.processing.Generated; + +/** SHumanHAIRS is a Querydsl query type for SHumanHAIRS */ +@Generated("com.querydsl.sql.codegen.MetaDataSerializer") +public class SHumanHAIRS extends com.querydsl.sql.RelationalPathBase { + + private static final long serialVersionUID = 188619308; + + public static final SHumanHAIRS HumanHAIRS = new SHumanHAIRS("Human_HAIRS"); + + public final NumberPath hairs = createNumber("hairs", Integer.class); + + public final NumberPath humanID = createNumber("humanID", Long.class); + + public final com.querydsl.sql.ForeignKey humanHAIRSHumanIDFK = + createForeignKey(humanID, "ID"); + + public SHumanHAIRS(String variable) { + super(SHumanHAIRS.class, forVariable(variable), "null", "Human_HAIRS"); + addMetadata(); + } + + public SHumanHAIRS(String variable, String schema, String table) { + super(SHumanHAIRS.class, forVariable(variable), schema, table); + addMetadata(); + } + + public SHumanHAIRS(String variable, String schema) { + super(SHumanHAIRS.class, forVariable(variable), schema, "Human_HAIRS"); + addMetadata(); + } + + public SHumanHAIRS(Path path) { + super(path.getType(), path.getMetadata(), "null", "Human_HAIRS"); + addMetadata(); + } + + public SHumanHAIRS(PathMetadata metadata) { + super(SHumanHAIRS.class, metadata, "null", "Human_HAIRS"); + addMetadata(); + } + + public void addMetadata() { + addMetadata( + hairs, ColumnMetadata.named("HAIRS").withIndex(2).ofType(Types.INTEGER).withSize(10)); + addMetadata( + humanID, ColumnMetadata.named("Human_ID").withIndex(1).ofType(Types.BIGINT).withSize(19)); + } +} diff --git a/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SInheritedproperties_.java b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SInheritedproperties_.java new file mode 100644 index 0000000000..54a4c702e6 --- /dev/null +++ b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SInheritedproperties_.java @@ -0,0 +1,73 @@ +package com.querydsl.jpa.domain.sql; + +import static com.querydsl.core.types.PathMetadataFactory.*; + +import com.querydsl.core.types.Path; +import com.querydsl.core.types.PathMetadata; +import com.querydsl.core.types.dsl.*; +import com.querydsl.sql.ColumnMetadata; +import java.sql.Types; +import javax.annotation.processing.Generated; + +/** SInheritedproperties_ is a Querydsl query type for SInheritedproperties_ */ +@Generated("com.querydsl.sql.codegen.MetaDataSerializer") +public class SInheritedproperties_ + extends com.querydsl.sql.RelationalPathBase { + + private static final long serialVersionUID = -515155206; + + public static final SInheritedproperties_ inheritedproperties_ = + new SInheritedproperties_("inheritedproperties_"); + + public final StringPath classproperty = createString("classproperty"); + + public final NumberPath id = createNumber("id", Long.class); + + public final StringPath stringassimple = createString("stringassimple"); + + public final StringPath superclassproperty = createString("superclassproperty"); + + public final com.querydsl.sql.PrimaryKey primary = createPrimaryKey(id); + + public SInheritedproperties_(String variable) { + super(SInheritedproperties_.class, forVariable(variable), "null", "inheritedproperties_"); + addMetadata(); + } + + public SInheritedproperties_(String variable, String schema, String table) { + super(SInheritedproperties_.class, forVariable(variable), schema, table); + addMetadata(); + } + + public SInheritedproperties_(String variable, String schema) { + super(SInheritedproperties_.class, forVariable(variable), schema, "inheritedproperties_"); + addMetadata(); + } + + public SInheritedproperties_(Path path) { + super(path.getType(), path.getMetadata(), "null", "inheritedproperties_"); + addMetadata(); + } + + public SInheritedproperties_(PathMetadata metadata) { + super(SInheritedproperties_.class, metadata, "null", "inheritedproperties_"); + addMetadata(); + } + + public void addMetadata() { + addMetadata( + classproperty, + ColumnMetadata.named("CLASSPROPERTY").withIndex(2).ofType(Types.VARCHAR).withSize(255)); + addMetadata( + id, ColumnMetadata.named("ID").withIndex(1).ofType(Types.BIGINT).withSize(19).notNull()); + addMetadata( + stringassimple, + ColumnMetadata.named("STRINGASSIMPLE").withIndex(3).ofType(Types.VARCHAR).withSize(255)); + addMetadata( + superclassproperty, + ColumnMetadata.named("SUPERCLASSPROPERTY") + .withIndex(4) + .ofType(Types.VARCHAR) + .withSize(255)); + } +} diff --git a/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SItem_.java b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SItem_.java new file mode 100644 index 0000000000..cd6fb34e96 --- /dev/null +++ b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SItem_.java @@ -0,0 +1,110 @@ +package com.querydsl.jpa.domain.sql; + +import static com.querydsl.core.types.PathMetadataFactory.*; + +import com.querydsl.core.types.Path; +import com.querydsl.core.types.PathMetadata; +import com.querydsl.core.types.dsl.*; +import com.querydsl.sql.ColumnMetadata; +import java.sql.Types; +import javax.annotation.processing.Generated; + +/** SItem_ is a Querydsl query type for SItem_ */ +@Generated("com.querydsl.sql.codegen.MetaDataSerializer") +public class SItem_ extends com.querydsl.sql.RelationalPathBase { + + private static final long serialVersionUID = -951193564; + + public static final SItem_ item_ = new SItem_("item_"); + + public final NumberPath currentstatusId = createNumber("currentstatusId", Long.class); + + public final StringPath dtype = createString("dtype"); + + public final NumberPath id = createNumber("id", Long.class); + + public final StringPath name = createString("name"); + + public final NumberPath paymentstatus = createNumber("paymentstatus", Integer.class); + + public final NumberPath productId = createNumber("productId", Long.class); + + public final NumberPath statusId = createNumber("statusId", Long.class); + + public final com.querydsl.sql.PrimaryKey primary = createPrimaryKey(id); + + public final com.querydsl.sql.ForeignKey item_CURRENTSTATUSIDFK = + createForeignKey(currentstatusId, "ID"); + + public final com.querydsl.sql.ForeignKey item_PRODUCTIDFK = + createForeignKey(productId, "ID"); + + public final com.querydsl.sql.ForeignKey item_STATUSIDFK = + createForeignKey(statusId, "ID"); + + public final com.querydsl.sql.ForeignKey _lineItems2LineItemsMapIDFK = + createInvForeignKey(id, "lineItemsMap_ID"); + + public final com.querydsl.sql.ForeignKey _lineItemsLineItemsIDFK = + createInvForeignKey(id, "lineItems_ID"); + + public final com.querydsl.sql.ForeignKey _auditlog_ITEMIDFK = + createInvForeignKey(id, "ITEM_ID"); + + public final com.querydsl.sql.ForeignKey _item_PRODUCTIDFK = + createInvForeignKey(id, "PRODUCT_ID"); + + public final com.querydsl.sql.ForeignKey _item_statuschange_PaymentIDFK = + createInvForeignKey(id, "Payment_ID"); + + public final com.querydsl.sql.ForeignKey _order_item_itemsIDFK = + createInvForeignKey(id, "items_ID"); + + public final com.querydsl.sql.ForeignKey _price_PRODUCTIDFK = + createInvForeignKey(id, "PRODUCT_ID"); + + public SItem_(String variable) { + super(SItem_.class, forVariable(variable), "null", "item_"); + addMetadata(); + } + + public SItem_(String variable, String schema, String table) { + super(SItem_.class, forVariable(variable), schema, table); + addMetadata(); + } + + public SItem_(String variable, String schema) { + super(SItem_.class, forVariable(variable), schema, "item_"); + addMetadata(); + } + + public SItem_(Path path) { + super(path.getType(), path.getMetadata(), "null", "item_"); + addMetadata(); + } + + public SItem_(PathMetadata metadata) { + super(SItem_.class, metadata, "null", "item_"); + addMetadata(); + } + + public void addMetadata() { + addMetadata( + currentstatusId, + ColumnMetadata.named("CURRENTSTATUS_ID").withIndex(6).ofType(Types.BIGINT).withSize(19)); + addMetadata( + dtype, ColumnMetadata.named("DTYPE").withIndex(2).ofType(Types.VARCHAR).withSize(31)); + addMetadata( + id, ColumnMetadata.named("ID").withIndex(1).ofType(Types.BIGINT).withSize(19).notNull()); + addMetadata( + name, ColumnMetadata.named("NAME").withIndex(4).ofType(Types.VARCHAR).withSize(255)); + addMetadata( + paymentstatus, + ColumnMetadata.named("PAYMENTSTATUS").withIndex(5).ofType(Types.INTEGER).withSize(10)); + addMetadata( + productId, + ColumnMetadata.named("PRODUCT_ID").withIndex(3).ofType(Types.BIGINT).withSize(19)); + addMetadata( + statusId, ColumnMetadata.named("STATUS_ID").withIndex(7).ofType(Types.BIGINT).withSize(19)); + } +} diff --git a/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SItem_statuschange_.java b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SItem_statuschange_.java new file mode 100644 index 0000000000..2a38abd0f9 --- /dev/null +++ b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SItem_statuschange_.java @@ -0,0 +1,75 @@ +package com.querydsl.jpa.domain.sql; + +import static com.querydsl.core.types.PathMetadataFactory.*; + +import com.querydsl.core.types.Path; +import com.querydsl.core.types.PathMetadata; +import com.querydsl.core.types.dsl.*; +import com.querydsl.sql.ColumnMetadata; +import java.sql.Types; +import javax.annotation.processing.Generated; + +/** SItem_statuschange_ is a Querydsl query type for SItem_statuschange_ */ +@Generated("com.querydsl.sql.codegen.MetaDataSerializer") +public class SItem_statuschange_ extends com.querydsl.sql.RelationalPathBase { + + private static final long serialVersionUID = 1154189529; + + public static final SItem_statuschange_ item_statuschange_ = + new SItem_statuschange_("item__statuschange_"); + + public final NumberPath paymentID = createNumber("paymentID", Long.class); + + public final NumberPath statusChangesID = createNumber("statusChangesID", Long.class); + + public final com.querydsl.sql.PrimaryKey primary = + createPrimaryKey(paymentID, statusChangesID); + + public final com.querydsl.sql.ForeignKey item_statuschange_PaymentIDFK = + createForeignKey(paymentID, "ID"); + + public final com.querydsl.sql.ForeignKey item_statuschange_statusChangesIDFK = + createForeignKey(statusChangesID, "ID"); + + public SItem_statuschange_(String variable) { + super(SItem_statuschange_.class, forVariable(variable), "null", "item__statuschange_"); + addMetadata(); + } + + public SItem_statuschange_(String variable, String schema, String table) { + super(SItem_statuschange_.class, forVariable(variable), schema, table); + addMetadata(); + } + + public SItem_statuschange_(String variable, String schema) { + super(SItem_statuschange_.class, forVariable(variable), schema, "item__statuschange_"); + addMetadata(); + } + + public SItem_statuschange_(Path path) { + super(path.getType(), path.getMetadata(), "null", "item__statuschange_"); + addMetadata(); + } + + public SItem_statuschange_(PathMetadata metadata) { + super(SItem_statuschange_.class, metadata, "null", "item__statuschange_"); + addMetadata(); + } + + public void addMetadata() { + addMetadata( + paymentID, + ColumnMetadata.named("Payment_ID") + .withIndex(1) + .ofType(Types.BIGINT) + .withSize(19) + .notNull()); + addMetadata( + statusChangesID, + ColumnMetadata.named("statusChanges_ID") + .withIndex(2) + .ofType(Types.BIGINT) + .withSize(19) + .notNull()); + } +} diff --git a/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SKittens.java b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SKittens.java index 713e689b0b..0acc14b1cf 100644 --- a/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SKittens.java +++ b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SKittens.java @@ -1,18 +1,19 @@ package com.querydsl.jpa.domain.sql; -import static com.querydsl.core.types.PathMetadataFactory.forVariable; +import static com.querydsl.core.types.PathMetadataFactory.*; import com.querydsl.core.types.Path; import com.querydsl.core.types.PathMetadata; -import com.querydsl.core.types.dsl.NumberPath; +import com.querydsl.core.types.dsl.*; import com.querydsl.sql.ColumnMetadata; -import jakarta.annotation.Generated; +import java.sql.Types; +import javax.annotation.processing.Generated; /** SKittens is a Querydsl query type for SKittens */ @Generated("com.querydsl.sql.codegen.MetaDataSerializer") public class SKittens extends com.querydsl.sql.RelationalPathBase { - private static final long serialVersionUID = 1947872699; + private static final long serialVersionUID = -2089790908; public static final SKittens kittens = new SKittens("kittens"); @@ -22,16 +23,15 @@ public class SKittens extends com.querydsl.sql.RelationalPathBase { public final NumberPath kittenId = createNumber("kittenId", Integer.class); - public final com.querydsl.sql.PrimaryKey primary = createPrimaryKey(catId, ind); + public final com.querydsl.sql.PrimaryKey primary = createPrimaryKey(catId, kittenId); - public final com.querydsl.sql.ForeignKey fkd60087cc3881aaa7 = - createForeignKey(kittenId, "id"); + public final com.querydsl.sql.ForeignKey kittensCatIdFK = createForeignKey(catId, "ID"); - public final com.querydsl.sql.ForeignKey fkd60087cc8f00fdf8 = - createForeignKey(catId, "id"); + public final com.querydsl.sql.ForeignKey kittensKittenIdFK = + createForeignKey(kittenId, "ID"); public SKittens(String variable) { - super(SKittens.class, forVariable(variable), "", "kittens"); + super(SKittens.class, forVariable(variable), "null", "kittens"); addMetadata(); } @@ -40,21 +40,32 @@ public SKittens(String variable, String schema, String table) { addMetadata(); } + public SKittens(String variable, String schema) { + super(SKittens.class, forVariable(variable), schema, "kittens"); + addMetadata(); + } + public SKittens(Path path) { - super(path.getType(), path.getMetadata(), "", "kittens"); + super(path.getType(), path.getMetadata(), "null", "kittens"); addMetadata(); } public SKittens(PathMetadata metadata) { - super(SKittens.class, metadata, "", "kittens"); + super(SKittens.class, metadata, "null", "kittens"); addMetadata(); } public void addMetadata() { addMetadata( - catId, ColumnMetadata.named("cat_id").withIndex(1).ofType(4).withSize(10).notNull()); - addMetadata(ind, ColumnMetadata.named("ind").withIndex(3).ofType(4).withSize(10).notNull()); + catId, + ColumnMetadata.named("cat_id").withIndex(1).ofType(Types.INTEGER).withSize(10).notNull()); + addMetadata(ind, ColumnMetadata.named("ind").withIndex(3).ofType(Types.INTEGER).withSize(10)); addMetadata( - kittenId, ColumnMetadata.named("kitten_id").withIndex(2).ofType(4).withSize(10).notNull()); + kittenId, + ColumnMetadata.named("kitten_id") + .withIndex(2) + .ofType(Types.INTEGER) + .withSize(10) + .notNull()); } } diff --git a/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SKittensSet.java b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SKittensSet.java index d45b8bce9d..475cb5dbff 100644 --- a/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SKittensSet.java +++ b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SKittensSet.java @@ -1,18 +1,19 @@ package com.querydsl.jpa.domain.sql; -import static com.querydsl.core.types.PathMetadataFactory.forVariable; +import static com.querydsl.core.types.PathMetadataFactory.*; import com.querydsl.core.types.Path; import com.querydsl.core.types.PathMetadata; -import com.querydsl.core.types.dsl.NumberPath; +import com.querydsl.core.types.dsl.*; import com.querydsl.sql.ColumnMetadata; -import jakarta.annotation.Generated; +import java.sql.Types; +import javax.annotation.processing.Generated; /** SKittensSet is a Querydsl query type for SKittensSet */ @Generated("com.querydsl.sql.codegen.MetaDataSerializer") public class SKittensSet extends com.querydsl.sql.RelationalPathBase { - private static final long serialVersionUID = -227477337; + private static final long serialVersionUID = -1409901698; public static final SKittensSet kittensSet = new SKittensSet("kittens_set"); @@ -22,14 +23,14 @@ public class SKittensSet extends com.querydsl.sql.RelationalPathBase primary = createPrimaryKey(catId, kittenId); - public final com.querydsl.sql.ForeignKey fk4fccad6f8f00fdf8 = - createForeignKey(catId, "id"); + public final com.querydsl.sql.ForeignKey kittensSetCatIdFK = + createForeignKey(catId, "ID"); - public final com.querydsl.sql.ForeignKey fk4fccad6f3881aaa7 = - createForeignKey(kittenId, "id"); + public final com.querydsl.sql.ForeignKey kittensSetKittenIdFK = + createForeignKey(kittenId, "ID"); public SKittensSet(String variable) { - super(SKittensSet.class, forVariable(variable), "", "kittens_set"); + super(SKittensSet.class, forVariable(variable), "null", "kittens_set"); addMetadata(); } @@ -38,20 +39,31 @@ public SKittensSet(String variable, String schema, String table) { addMetadata(); } + public SKittensSet(String variable, String schema) { + super(SKittensSet.class, forVariable(variable), schema, "kittens_set"); + addMetadata(); + } + public SKittensSet(Path path) { - super(path.getType(), path.getMetadata(), "", "kittens_set"); + super(path.getType(), path.getMetadata(), "null", "kittens_set"); addMetadata(); } public SKittensSet(PathMetadata metadata) { - super(SKittensSet.class, metadata, "", "kittens_set"); + super(SKittensSet.class, metadata, "null", "kittens_set"); addMetadata(); } public void addMetadata() { addMetadata( - catId, ColumnMetadata.named("cat_id").withIndex(1).ofType(4).withSize(10).notNull()); + catId, + ColumnMetadata.named("cat_id").withIndex(1).ofType(Types.INTEGER).withSize(10).notNull()); addMetadata( - kittenId, ColumnMetadata.named("kitten_id").withIndex(2).ofType(4).withSize(10).notNull()); + kittenId, + ColumnMetadata.named("kitten_id") + .withIndex(2) + .ofType(Types.INTEGER) + .withSize(10) + .notNull()); } } diff --git a/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SLibrary_.java b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SLibrary_.java new file mode 100644 index 0000000000..d407a3d26c --- /dev/null +++ b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SLibrary_.java @@ -0,0 +1,57 @@ +package com.querydsl.jpa.domain.sql; + +import static com.querydsl.core.types.PathMetadataFactory.*; + +import com.querydsl.core.types.Path; +import com.querydsl.core.types.PathMetadata; +import com.querydsl.core.types.dsl.*; +import com.querydsl.sql.ColumnMetadata; +import java.sql.Types; +import javax.annotation.processing.Generated; + +/** SLibrary_ is a Querydsl query type for SLibrary_ */ +@Generated("com.querydsl.sql.codegen.MetaDataSerializer") +public class SLibrary_ extends com.querydsl.sql.RelationalPathBase { + + private static final long serialVersionUID = 866514828; + + public static final SLibrary_ library_ = new SLibrary_("library_"); + + public final NumberPath identity = createNumber("identity", Long.class); + + public final com.querydsl.sql.PrimaryKey primary = createPrimaryKey(identity); + + public final com.querydsl.sql.ForeignKey _bookversion_LIBRARYIDENTITYFK = + createInvForeignKey(identity, "LIBRARY_IDENTITY"); + + public SLibrary_(String variable) { + super(SLibrary_.class, forVariable(variable), "null", "library_"); + addMetadata(); + } + + public SLibrary_(String variable, String schema, String table) { + super(SLibrary_.class, forVariable(variable), schema, table); + addMetadata(); + } + + public SLibrary_(String variable, String schema) { + super(SLibrary_.class, forVariable(variable), schema, "library_"); + addMetadata(); + } + + public SLibrary_(Path path) { + super(path.getType(), path.getMetadata(), "null", "library_"); + addMetadata(); + } + + public SLibrary_(PathMetadata metadata) { + super(SLibrary_.class, metadata, "null", "library_"); + addMetadata(); + } + + public void addMetadata() { + addMetadata( + identity, + ColumnMetadata.named("IDENTITY").withIndex(1).ofType(Types.BIGINT).withSize(19).notNull()); + } +} diff --git a/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SLineItems.java b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SLineItems.java index 429e08460c..4e56b29ce6 100644 --- a/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SLineItems.java +++ b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SLineItems.java @@ -1,37 +1,39 @@ package com.querydsl.jpa.domain.sql; -import static com.querydsl.core.types.PathMetadataFactory.forVariable; +import static com.querydsl.core.types.PathMetadataFactory.*; import com.querydsl.core.types.Path; import com.querydsl.core.types.PathMetadata; -import com.querydsl.core.types.dsl.NumberPath; +import com.querydsl.core.types.dsl.*; import com.querydsl.sql.ColumnMetadata; -import jakarta.annotation.Generated; +import java.sql.Types; +import javax.annotation.processing.Generated; /** SLineItems is a Querydsl query type for SLineItems */ @Generated("com.querydsl.sql.codegen.MetaDataSerializer") public class SLineItems extends com.querydsl.sql.RelationalPathBase { - private static final long serialVersionUID = 302253659; + private static final long serialVersionUID = -1537004380; public static final SLineItems LineItems = new SLineItems("LineItems"); public final NumberPath _index = createNumber("_index", Integer.class); - public final NumberPath lineItemsId = createNumber("lineItemsId", Long.class); + public final NumberPath lineItemsID = createNumber("lineItemsID", Long.class); - public final NumberPath order_id = createNumber("order_id", Long.class); + public final NumberPath orderID = createNumber("orderID", Long.class); - public final com.querydsl.sql.PrimaryKey primary = createPrimaryKey(_index, order_id); + public final com.querydsl.sql.PrimaryKey primary = + createPrimaryKey(orderID, lineItemsID); - public final com.querydsl.sql.ForeignKey fkb2e400cb968f515 = - createForeignKey(order_id, "id"); + public final com.querydsl.sql.ForeignKey lineItemsOrderIDFK = + createForeignKey(orderID, "ID"); - public final com.querydsl.sql.ForeignKey fkb2e400c3d8e44c3 = - createForeignKey(lineItemsId, "id"); + public final com.querydsl.sql.ForeignKey lineItemsLineItemsIDFK = + createForeignKey(lineItemsID, "ID"); public SLineItems(String variable) { - super(SLineItems.class, forVariable(variable), "", "LineItems"); + super(SLineItems.class, forVariable(variable), "null", "LineItems"); addMetadata(); } @@ -40,23 +42,33 @@ public SLineItems(String variable, String schema, String table) { addMetadata(); } + public SLineItems(String variable, String schema) { + super(SLineItems.class, forVariable(variable), schema, "LineItems"); + addMetadata(); + } + public SLineItems(Path path) { - super(path.getType(), path.getMetadata(), "", "LineItems"); + super(path.getType(), path.getMetadata(), "null", "LineItems"); addMetadata(); } public SLineItems(PathMetadata metadata) { - super(SLineItems.class, metadata, "", "LineItems"); + super(SLineItems.class, metadata, "null", "LineItems"); addMetadata(); } public void addMetadata() { addMetadata( - _index, ColumnMetadata.named("_index").withIndex(3).ofType(4).withSize(10).notNull()); + _index, ColumnMetadata.named("_index").withIndex(3).ofType(Types.INTEGER).withSize(10)); addMetadata( - lineItemsId, - ColumnMetadata.named("lineItems_id").withIndex(2).ofType(-5).withSize(19).notNull()); + lineItemsID, + ColumnMetadata.named("lineItems_ID") + .withIndex(2) + .ofType(Types.BIGINT) + .withSize(19) + .notNull()); addMetadata( - order_id, ColumnMetadata.named("order__id").withIndex(1).ofType(-5).withSize(19).notNull()); + orderID, + ColumnMetadata.named("Order_ID").withIndex(1).ofType(Types.BIGINT).withSize(19).notNull()); } } diff --git a/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SLineItems2.java b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SLineItems2.java new file mode 100644 index 0000000000..385f41ae66 --- /dev/null +++ b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SLineItems2.java @@ -0,0 +1,70 @@ +package com.querydsl.jpa.domain.sql; + +import static com.querydsl.core.types.PathMetadataFactory.*; + +import com.querydsl.core.types.Path; +import com.querydsl.core.types.PathMetadata; +import com.querydsl.core.types.dsl.*; +import com.querydsl.sql.ColumnMetadata; +import java.sql.Types; +import javax.annotation.processing.Generated; + +/** SLineItems2 is a Querydsl query type for SLineItems2 */ +@Generated("com.querydsl.sql.codegen.MetaDataSerializer") +public class SLineItems2 extends com.querydsl.sql.RelationalPathBase { + + private static final long serialVersionUID = -402495474; + + public static final SLineItems2 LineItems2 = new SLineItems2("LineItems2"); + + public final NumberPath lineItemsMapID = createNumber("lineItemsMapID", Long.class); + + public final NumberPath orderID = createNumber("orderID", Long.class); + + public final com.querydsl.sql.PrimaryKey primary = + createPrimaryKey(orderID, lineItemsMapID); + + public final com.querydsl.sql.ForeignKey lineItems2OrderIDFK = + createForeignKey(orderID, "ID"); + + public final com.querydsl.sql.ForeignKey lineItems2LineItemsMapIDFK = + createForeignKey(lineItemsMapID, "ID"); + + public SLineItems2(String variable) { + super(SLineItems2.class, forVariable(variable), "null", "LineItems2"); + addMetadata(); + } + + public SLineItems2(String variable, String schema, String table) { + super(SLineItems2.class, forVariable(variable), schema, table); + addMetadata(); + } + + public SLineItems2(String variable, String schema) { + super(SLineItems2.class, forVariable(variable), schema, "LineItems2"); + addMetadata(); + } + + public SLineItems2(Path path) { + super(path.getType(), path.getMetadata(), "null", "LineItems2"); + addMetadata(); + } + + public SLineItems2(PathMetadata metadata) { + super(SLineItems2.class, metadata, "null", "LineItems2"); + addMetadata(); + } + + public void addMetadata() { + addMetadata( + lineItemsMapID, + ColumnMetadata.named("lineItemsMap_ID") + .withIndex(2) + .ofType(Types.BIGINT) + .withSize(19) + .notNull()); + addMetadata( + orderID, + ColumnMetadata.named("Order_ID").withIndex(1).ofType(Types.BIGINT).withSize(19).notNull()); + } +} diff --git a/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SLocation_.java b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SLocation_.java new file mode 100644 index 0000000000..bfd999903f --- /dev/null +++ b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SLocation_.java @@ -0,0 +1,60 @@ +package com.querydsl.jpa.domain.sql; + +import static com.querydsl.core.types.PathMetadataFactory.*; + +import com.querydsl.core.types.Path; +import com.querydsl.core.types.PathMetadata; +import com.querydsl.core.types.dsl.*; +import com.querydsl.sql.ColumnMetadata; +import java.sql.Types; +import javax.annotation.processing.Generated; + +/** SLocation_ is a Querydsl query type for SLocation_ */ +@Generated("com.querydsl.sql.codegen.MetaDataSerializer") +public class SLocation_ extends com.querydsl.sql.RelationalPathBase { + + private static final long serialVersionUID = -917806142; + + public static final SLocation_ location_ = new SLocation_("location_"); + + public final NumberPath id = createNumber("id", Long.class); + + public final StringPath name = createString("name"); + + public final com.querydsl.sql.PrimaryKey primary = createPrimaryKey(id); + + public final com.querydsl.sql.ForeignKey _store_LOCATIONIDFK = + createInvForeignKey(id, "LOCATION_ID"); + + public SLocation_(String variable) { + super(SLocation_.class, forVariable(variable), "null", "location_"); + addMetadata(); + } + + public SLocation_(String variable, String schema, String table) { + super(SLocation_.class, forVariable(variable), schema, table); + addMetadata(); + } + + public SLocation_(String variable, String schema) { + super(SLocation_.class, forVariable(variable), schema, "location_"); + addMetadata(); + } + + public SLocation_(Path path) { + super(path.getType(), path.getMetadata(), "null", "location_"); + addMetadata(); + } + + public SLocation_(PathMetadata metadata) { + super(SLocation_.class, metadata, "null", "location_"); + addMetadata(); + } + + public void addMetadata() { + addMetadata( + id, ColumnMetadata.named("ID").withIndex(1).ofType(Types.BIGINT).withSize(19).notNull()); + addMetadata( + name, ColumnMetadata.named("NAME").withIndex(2).ofType(Types.VARCHAR).withSize(255)); + } +} diff --git a/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SMammal.java b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SMammal.java index 6cdda59fd4..4263bf8063 100644 --- a/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SMammal.java +++ b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SMammal.java @@ -1,21 +1,21 @@ package com.querydsl.jpa.domain.sql; -import static com.querydsl.core.types.PathMetadataFactory.forVariable; +import static com.querydsl.core.types.PathMetadataFactory.*; import com.querydsl.core.types.Path; import com.querydsl.core.types.PathMetadata; -import com.querydsl.core.types.dsl.NumberPath; -import com.querydsl.core.types.dsl.StringPath; +import com.querydsl.core.types.dsl.*; import com.querydsl.sql.ColumnMetadata; -import jakarta.annotation.Generated; +import java.sql.Types; +import javax.annotation.processing.Generated; /** SMammal is a Querydsl query type for SMammal */ @Generated("com.querydsl.sql.codegen.MetaDataSerializer") public class SMammal extends com.querydsl.sql.RelationalPathBase { - private static final long serialVersionUID = 666678672; + private static final long serialVersionUID = 674978791; - public static final SMammal Mammal = new SMammal("Mammal"); + public static final SMammal mammal = new SMammal("MAMMAL"); public final StringPath dtype = createString("dtype"); @@ -23,14 +23,14 @@ public class SMammal extends com.querydsl.sql.RelationalPathBase { public final com.querydsl.sql.PrimaryKey primary = createPrimaryKey(id); - public final com.querydsl.sql.ForeignKey _fk6649531ff097e318 = - createInvForeignKey(id, "Human_id"); + public final com.querydsl.sql.ForeignKey _humanHAIRSHumanIDFK = + createInvForeignKey(id, "Human_ID"); - public final com.querydsl.sql.ForeignKey _fk4070aeece01c8ee7 = - createInvForeignKey(id, "mammals_id"); + public final com.querydsl.sql.ForeignKey _wORLDMAMMALMammalsIDFK = + createInvForeignKey(id, "mammals_ID"); public SMammal(String variable) { - super(SMammal.class, forVariable(variable), "", "Mammal"); + super(SMammal.class, forVariable(variable), "null", "MAMMAL"); addMetadata(); } @@ -39,19 +39,25 @@ public SMammal(String variable, String schema, String table) { addMetadata(); } + public SMammal(String variable, String schema) { + super(SMammal.class, forVariable(variable), schema, "MAMMAL"); + addMetadata(); + } + public SMammal(Path path) { - super(path.getType(), path.getMetadata(), "", "Mammal"); + super(path.getType(), path.getMetadata(), "null", "MAMMAL"); addMetadata(); } public SMammal(PathMetadata metadata) { - super(SMammal.class, metadata, "", "Mammal"); + super(SMammal.class, metadata, "null", "MAMMAL"); addMetadata(); } public void addMetadata() { addMetadata( - dtype, ColumnMetadata.named("DTYPE").withIndex(1).ofType(12).withSize(31).notNull()); - addMetadata(id, ColumnMetadata.named("id").withIndex(2).ofType(-5).withSize(19).notNull()); + dtype, ColumnMetadata.named("DTYPE").withIndex(2).ofType(Types.VARCHAR).withSize(31)); + addMetadata( + id, ColumnMetadata.named("ID").withIndex(1).ofType(Types.BIGINT).withSize(19).notNull()); } } diff --git a/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SMyentity.java b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SMyentity.java new file mode 100644 index 0000000000..05643131aa --- /dev/null +++ b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SMyentity.java @@ -0,0 +1,65 @@ +package com.querydsl.jpa.domain.sql; + +import static com.querydsl.core.types.PathMetadataFactory.*; + +import com.querydsl.core.types.Path; +import com.querydsl.core.types.PathMetadata; +import com.querydsl.core.types.dsl.*; +import com.querydsl.sql.ColumnMetadata; +import java.sql.Types; +import javax.annotation.processing.Generated; + +/** SMyentity is a Querydsl query type for SMyentity */ +@Generated("com.querydsl.sql.codegen.MetaDataSerializer") +public class SMyentity extends com.querydsl.sql.RelationalPathBase { + + private static final long serialVersionUID = -287734505; + + public static final SMyentity myentity = new SMyentity("MYENTITY"); + + public final NumberPath attributewithinitproblemId = + createNumber("attributewithinitproblemId", Integer.class); + + public final NumberPath id = createNumber("id", Integer.class); + + public final com.querydsl.sql.PrimaryKey primary = createPrimaryKey(id); + + public final com.querydsl.sql.ForeignKey myentityAttributewithinitproblemIdFk = + createForeignKey(attributewithinitproblemId, "ID"); + + public SMyentity(String variable) { + super(SMyentity.class, forVariable(variable), "null", "MYENTITY"); + addMetadata(); + } + + public SMyentity(String variable, String schema, String table) { + super(SMyentity.class, forVariable(variable), schema, table); + addMetadata(); + } + + public SMyentity(String variable, String schema) { + super(SMyentity.class, forVariable(variable), schema, "MYENTITY"); + addMetadata(); + } + + public SMyentity(Path path) { + super(path.getType(), path.getMetadata(), "null", "MYENTITY"); + addMetadata(); + } + + public SMyentity(PathMetadata metadata) { + super(SMyentity.class, metadata, "null", "MYENTITY"); + addMetadata(); + } + + public void addMetadata() { + addMetadata( + attributewithinitproblemId, + ColumnMetadata.named("ATTRIBUTEWITHINITPROBLEM_ID") + .withIndex(2) + .ofType(Types.INTEGER) + .withSize(10)); + addMetadata( + id, ColumnMetadata.named("ID").withIndex(1).ofType(Types.INTEGER).withSize(10).notNull()); + } +} diff --git a/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SMyotherentity.java b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SMyotherentity.java new file mode 100644 index 0000000000..de964930c2 --- /dev/null +++ b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SMyotherentity.java @@ -0,0 +1,56 @@ +package com.querydsl.jpa.domain.sql; + +import static com.querydsl.core.types.PathMetadataFactory.*; + +import com.querydsl.core.types.Path; +import com.querydsl.core.types.PathMetadata; +import com.querydsl.core.types.dsl.*; +import com.querydsl.sql.ColumnMetadata; +import java.sql.Types; +import javax.annotation.processing.Generated; + +/** SMyotherentity is a Querydsl query type for SMyotherentity */ +@Generated("com.querydsl.sql.codegen.MetaDataSerializer") +public class SMyotherentity extends com.querydsl.sql.RelationalPathBase { + + private static final long serialVersionUID = -19540417; + + public static final SMyotherentity myotherentity = new SMyotherentity("MYOTHERENTITY"); + + public final NumberPath id = createNumber("id", Integer.class); + + public final com.querydsl.sql.PrimaryKey primary = createPrimaryKey(id); + + public final com.querydsl.sql.ForeignKey _myentityAttributewithinitproblemIdFk = + createInvForeignKey(id, "ATTRIBUTEWITHINITPROBLEM_ID"); + + public SMyotherentity(String variable) { + super(SMyotherentity.class, forVariable(variable), "null", "MYOTHERENTITY"); + addMetadata(); + } + + public SMyotherentity(String variable, String schema, String table) { + super(SMyotherentity.class, forVariable(variable), schema, table); + addMetadata(); + } + + public SMyotherentity(String variable, String schema) { + super(SMyotherentity.class, forVariable(variable), schema, "MYOTHERENTITY"); + addMetadata(); + } + + public SMyotherentity(Path path) { + super(path.getType(), path.getMetadata(), "null", "MYOTHERENTITY"); + addMetadata(); + } + + public SMyotherentity(PathMetadata metadata) { + super(SMyotherentity.class, metadata, "null", "MYOTHERENTITY"); + addMetadata(); + } + + public void addMetadata() { + addMetadata( + id, ColumnMetadata.named("ID").withIndex(1).ofType(Types.INTEGER).withSize(10).notNull()); + } +} diff --git a/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SNameListNAMES.java b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SNameListNAMES.java new file mode 100644 index 0000000000..4a0c91a2e6 --- /dev/null +++ b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SNameListNAMES.java @@ -0,0 +1,59 @@ +package com.querydsl.jpa.domain.sql; + +import static com.querydsl.core.types.PathMetadataFactory.*; + +import com.querydsl.core.types.Path; +import com.querydsl.core.types.PathMetadata; +import com.querydsl.core.types.dsl.*; +import com.querydsl.sql.ColumnMetadata; +import java.sql.Types; +import javax.annotation.processing.Generated; + +/** SNameListNAMES is a Querydsl query type for SNameListNAMES */ +@Generated("com.querydsl.sql.codegen.MetaDataSerializer") +public class SNameListNAMES extends com.querydsl.sql.RelationalPathBase { + + private static final long serialVersionUID = 1866941303; + + public static final SNameListNAMES NameListNAMES = new SNameListNAMES("NameList_NAMES"); + + public final NumberPath nameListID = createNumber("nameListID", Long.class); + + public final StringPath names = createString("names"); + + public final com.querydsl.sql.ForeignKey nameListNAMESNameListIDFK = + createForeignKey(nameListID, "ID"); + + public SNameListNAMES(String variable) { + super(SNameListNAMES.class, forVariable(variable), "null", "NameList_NAMES"); + addMetadata(); + } + + public SNameListNAMES(String variable, String schema, String table) { + super(SNameListNAMES.class, forVariable(variable), schema, table); + addMetadata(); + } + + public SNameListNAMES(String variable, String schema) { + super(SNameListNAMES.class, forVariable(variable), schema, "NameList_NAMES"); + addMetadata(); + } + + public SNameListNAMES(Path path) { + super(path.getType(), path.getMetadata(), "null", "NameList_NAMES"); + addMetadata(); + } + + public SNameListNAMES(PathMetadata metadata) { + super(SNameListNAMES.class, metadata, "null", "NameList_NAMES"); + addMetadata(); + } + + public void addMetadata() { + addMetadata( + nameListID, + ColumnMetadata.named("NameList_ID").withIndex(1).ofType(Types.BIGINT).withSize(19)); + addMetadata( + names, ColumnMetadata.named("NAMES").withIndex(2).ofType(Types.VARCHAR).withSize(255)); + } +} diff --git a/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SName_.java b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SName_.java new file mode 100644 index 0000000000..11f21cb2f8 --- /dev/null +++ b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SName_.java @@ -0,0 +1,71 @@ +package com.querydsl.jpa.domain.sql; + +import static com.querydsl.core.types.PathMetadataFactory.*; + +import com.querydsl.core.types.Path; +import com.querydsl.core.types.PathMetadata; +import com.querydsl.core.types.dsl.*; +import com.querydsl.sql.ColumnMetadata; +import java.sql.Types; +import javax.annotation.processing.Generated; + +/** SName_ is a Querydsl query type for SName_ */ +@Generated("com.querydsl.sql.codegen.MetaDataSerializer") +public class SName_ extends com.querydsl.sql.RelationalPathBase { + + private static final long serialVersionUID = -947134548; + + public static final SName_ name_ = new SName_("name_"); + + public final StringPath firstname = createString("firstname"); + + public final NumberPath id = createNumber("id", Long.class); + + public final StringPath lastname = createString("lastname"); + + public final StringPath nickname = createString("nickname"); + + public final com.querydsl.sql.PrimaryKey primary = createPrimaryKey(id); + + public final com.querydsl.sql.ForeignKey _customer_NAMEIDFK = + createInvForeignKey(id, "NAME_ID"); + + public SName_(String variable) { + super(SName_.class, forVariable(variable), "null", "name_"); + addMetadata(); + } + + public SName_(String variable, String schema, String table) { + super(SName_.class, forVariable(variable), schema, table); + addMetadata(); + } + + public SName_(String variable, String schema) { + super(SName_.class, forVariable(variable), schema, "name_"); + addMetadata(); + } + + public SName_(Path path) { + super(path.getType(), path.getMetadata(), "null", "name_"); + addMetadata(); + } + + public SName_(PathMetadata metadata) { + super(SName_.class, metadata, "null", "name_"); + addMetadata(); + } + + public void addMetadata() { + addMetadata( + firstname, + ColumnMetadata.named("FIRSTNAME").withIndex(2).ofType(Types.VARCHAR).withSize(255)); + addMetadata( + id, ColumnMetadata.named("ID").withIndex(1).ofType(Types.BIGINT).withSize(19).notNull()); + addMetadata( + lastname, + ColumnMetadata.named("LASTNAME").withIndex(3).ofType(Types.VARCHAR).withSize(255)); + addMetadata( + nickname, + ColumnMetadata.named("NICKNAME").withIndex(4).ofType(Types.VARCHAR).withSize(255)); + } +} diff --git a/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SNamed_.java b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SNamed_.java new file mode 100644 index 0000000000..f8bfd4494e --- /dev/null +++ b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SNamed_.java @@ -0,0 +1,57 @@ +package com.querydsl.jpa.domain.sql; + +import static com.querydsl.core.types.PathMetadataFactory.*; + +import com.querydsl.core.types.Path; +import com.querydsl.core.types.PathMetadata; +import com.querydsl.core.types.dsl.*; +import com.querydsl.sql.ColumnMetadata; +import java.sql.Types; +import javax.annotation.processing.Generated; + +/** SNamed_ is a Querydsl query type for SNamed_ */ +@Generated("com.querydsl.sql.codegen.MetaDataSerializer") +public class SNamed_ extends com.querydsl.sql.RelationalPathBase { + + private static final long serialVersionUID = 703600334; + + public static final SNamed_ named_ = new SNamed_("named_"); + + public final NumberPath id = createNumber("id", Long.class); + + public final StringPath name = createString("name"); + + public final com.querydsl.sql.PrimaryKey primary = createPrimaryKey(id); + + public SNamed_(String variable) { + super(SNamed_.class, forVariable(variable), "null", "named_"); + addMetadata(); + } + + public SNamed_(String variable, String schema, String table) { + super(SNamed_.class, forVariable(variable), schema, table); + addMetadata(); + } + + public SNamed_(String variable, String schema) { + super(SNamed_.class, forVariable(variable), schema, "named_"); + addMetadata(); + } + + public SNamed_(Path path) { + super(path.getType(), path.getMetadata(), "null", "named_"); + addMetadata(); + } + + public SNamed_(PathMetadata metadata) { + super(SNamed_.class, metadata, "null", "named_"); + addMetadata(); + } + + public void addMetadata() { + addMetadata( + id, ColumnMetadata.named("ID").withIndex(1).ofType(Types.BIGINT).withSize(19).notNull()); + addMetadata( + name, ColumnMetadata.named("NAME").withIndex(2).ofType(Types.VARCHAR).withSize(255)); + } +} diff --git a/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SNamelist_.java b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SNamelist_.java new file mode 100644 index 0000000000..54b985a0fe --- /dev/null +++ b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SNamelist_.java @@ -0,0 +1,56 @@ +package com.querydsl.jpa.domain.sql; + +import static com.querydsl.core.types.PathMetadataFactory.*; + +import com.querydsl.core.types.Path; +import com.querydsl.core.types.PathMetadata; +import com.querydsl.core.types.dsl.*; +import com.querydsl.sql.ColumnMetadata; +import java.sql.Types; +import javax.annotation.processing.Generated; + +/** SNamelist_ is a Querydsl query type for SNamelist_ */ +@Generated("com.querydsl.sql.codegen.MetaDataSerializer") +public class SNamelist_ extends com.querydsl.sql.RelationalPathBase { + + private static final long serialVersionUID = 1524945998; + + public static final SNamelist_ namelist_ = new SNamelist_("namelist_"); + + public final NumberPath id = createNumber("id", Long.class); + + public final com.querydsl.sql.PrimaryKey primary = createPrimaryKey(id); + + public final com.querydsl.sql.ForeignKey _nameListNAMESNameListIDFK = + createInvForeignKey(id, "NameList_ID"); + + public SNamelist_(String variable) { + super(SNamelist_.class, forVariable(variable), "null", "namelist_"); + addMetadata(); + } + + public SNamelist_(String variable, String schema, String table) { + super(SNamelist_.class, forVariable(variable), schema, table); + addMetadata(); + } + + public SNamelist_(String variable, String schema) { + super(SNamelist_.class, forVariable(variable), schema, "namelist_"); + addMetadata(); + } + + public SNamelist_(Path path) { + super(path.getType(), path.getMetadata(), "null", "namelist_"); + addMetadata(); + } + + public SNamelist_(PathMetadata metadata) { + super(SNamelist_.class, metadata, "null", "namelist_"); + addMetadata(); + } + + public void addMetadata() { + addMetadata( + id, ColumnMetadata.named("ID").withIndex(1).ofType(Types.BIGINT).withSize(19).notNull()); + } +} diff --git a/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SNationality_.java b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SNationality_.java new file mode 100644 index 0000000000..8d9b541d34 --- /dev/null +++ b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SNationality_.java @@ -0,0 +1,64 @@ +package com.querydsl.jpa.domain.sql; + +import static com.querydsl.core.types.PathMetadataFactory.*; + +import com.querydsl.core.types.Path; +import com.querydsl.core.types.PathMetadata; +import com.querydsl.core.types.dsl.*; +import com.querydsl.sql.ColumnMetadata; +import java.sql.Types; +import javax.annotation.processing.Generated; + +/** SNationality_ is a Querydsl query type for SNationality_ */ +@Generated("com.querydsl.sql.codegen.MetaDataSerializer") +public class SNationality_ extends com.querydsl.sql.RelationalPathBase { + + private static final long serialVersionUID = -1959593301; + + public static final SNationality_ nationality_ = new SNationality_("nationality_"); + + public final NumberPath calendarId = createNumber("calendarId", Integer.class); + + public final NumberPath id = createNumber("id", Long.class); + + public final com.querydsl.sql.PrimaryKey primary = createPrimaryKey(id); + + public final com.querydsl.sql.ForeignKey nationality_CALENDARIDFK = + createForeignKey(calendarId, "ID"); + + public final com.querydsl.sql.ForeignKey _person_NATIONALITYIDFK = + createInvForeignKey(id, "NATIONALITY_ID"); + + public SNationality_(String variable) { + super(SNationality_.class, forVariable(variable), "null", "nationality_"); + addMetadata(); + } + + public SNationality_(String variable, String schema, String table) { + super(SNationality_.class, forVariable(variable), schema, table); + addMetadata(); + } + + public SNationality_(String variable, String schema) { + super(SNationality_.class, forVariable(variable), schema, "nationality_"); + addMetadata(); + } + + public SNationality_(Path path) { + super(path.getType(), path.getMetadata(), "null", "nationality_"); + addMetadata(); + } + + public SNationality_(PathMetadata metadata) { + super(SNationality_.class, metadata, "null", "nationality_"); + addMetadata(); + } + + public void addMetadata() { + addMetadata( + calendarId, + ColumnMetadata.named("CALENDAR_ID").withIndex(2).ofType(Types.INTEGER).withSize(10)); + addMetadata( + id, ColumnMetadata.named("ID").withIndex(1).ofType(Types.BIGINT).withSize(19).notNull()); + } +} diff --git a/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SNumberTest.java b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SNumberTest.java new file mode 100644 index 0000000000..0f5e8d8e80 --- /dev/null +++ b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SNumberTest.java @@ -0,0 +1,50 @@ +package com.querydsl.jpa.domain.sql; + +import static com.querydsl.core.types.PathMetadataFactory.*; + +import com.querydsl.core.types.Path; +import com.querydsl.core.types.PathMetadata; +import com.querydsl.core.types.dsl.*; +import com.querydsl.sql.ColumnMetadata; +import java.sql.Types; +import javax.annotation.processing.Generated; + +/** SNumberTest is a Querydsl query type for SNumberTest */ +@Generated("com.querydsl.sql.codegen.MetaDataSerializer") +public class SNumberTest extends com.querydsl.sql.RelationalPathBase { + + private static final long serialVersionUID = -321238525; + + public static final SNumberTest numberTest = new SNumberTest("NUMBER_TEST"); + + public final BooleanPath col1 = createBoolean("col1"); + + public SNumberTest(String variable) { + super(SNumberTest.class, forVariable(variable), "null", "NUMBER_TEST"); + addMetadata(); + } + + public SNumberTest(String variable, String schema, String table) { + super(SNumberTest.class, forVariable(variable), schema, table); + addMetadata(); + } + + public SNumberTest(String variable, String schema) { + super(SNumberTest.class, forVariable(variable), schema, "NUMBER_TEST"); + addMetadata(); + } + + public SNumberTest(Path path) { + super(path.getType(), path.getMetadata(), "null", "NUMBER_TEST"); + addMetadata(); + } + + public SNumberTest(PathMetadata metadata) { + super(SNumberTest.class, metadata, "null", "NUMBER_TEST"); + addMetadata(); + } + + public void addMetadata() { + addMetadata(col1, ColumnMetadata.named("col1").withIndex(1).ofType(Types.BIT).withSize(1)); + } +} diff --git a/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SNumeric_.java b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SNumeric_.java new file mode 100644 index 0000000000..b9afaa9397 --- /dev/null +++ b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SNumeric_.java @@ -0,0 +1,58 @@ +package com.querydsl.jpa.domain.sql; + +import static com.querydsl.core.types.PathMetadataFactory.*; + +import com.querydsl.core.types.Path; +import com.querydsl.core.types.PathMetadata; +import com.querydsl.core.types.dsl.*; +import com.querydsl.sql.ColumnMetadata; +import java.sql.Types; +import javax.annotation.processing.Generated; + +/** SNumeric_ is a Querydsl query type for SNumeric_ */ +@Generated("com.querydsl.sql.codegen.MetaDataSerializer") +public class SNumeric_ extends com.querydsl.sql.RelationalPathBase { + + private static final long serialVersionUID = -1874277510; + + public static final SNumeric_ numeric_ = new SNumeric_("numeric_"); + + public final NumberPath id = createNumber("id", Long.class); + + public final NumberPath value_ = + createNumber("value_", java.math.BigInteger.class); + + public final com.querydsl.sql.PrimaryKey primary = createPrimaryKey(id); + + public SNumeric_(String variable) { + super(SNumeric_.class, forVariable(variable), "null", "numeric_"); + addMetadata(); + } + + public SNumeric_(String variable, String schema, String table) { + super(SNumeric_.class, forVariable(variable), schema, table); + addMetadata(); + } + + public SNumeric_(String variable, String schema) { + super(SNumeric_.class, forVariable(variable), schema, "numeric_"); + addMetadata(); + } + + public SNumeric_(Path path) { + super(path.getType(), path.getMetadata(), "null", "numeric_"); + addMetadata(); + } + + public SNumeric_(PathMetadata metadata) { + super(SNumeric_.class, metadata, "null", "numeric_"); + addMetadata(); + } + + public void addMetadata() { + addMetadata( + id, ColumnMetadata.named("ID").withIndex(1).ofType(Types.BIGINT).withSize(19).notNull()); + addMetadata( + value_, ColumnMetadata.named("value_").withIndex(2).ofType(Types.DECIMAL).withSize(38)); + } +} diff --git a/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SOrderDELIVEREDITEMINDICES.java b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SOrderDELIVEREDITEMINDICES.java new file mode 100644 index 0000000000..a20fa2f2cc --- /dev/null +++ b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SOrderDELIVEREDITEMINDICES.java @@ -0,0 +1,77 @@ +package com.querydsl.jpa.domain.sql; + +import static com.querydsl.core.types.PathMetadataFactory.*; + +import com.querydsl.core.types.Path; +import com.querydsl.core.types.PathMetadata; +import com.querydsl.core.types.dsl.*; +import com.querydsl.sql.ColumnMetadata; +import java.sql.Types; +import javax.annotation.processing.Generated; + +/** SOrderDELIVEREDITEMINDICES is a Querydsl query type for SOrderDELIVEREDITEMINDICES */ +@Generated("com.querydsl.sql.codegen.MetaDataSerializer") +public class SOrderDELIVEREDITEMINDICES + extends com.querydsl.sql.RelationalPathBase { + + private static final long serialVersionUID = 1275589366; + + public static final SOrderDELIVEREDITEMINDICES OrderDELIVEREDITEMINDICES = + new SOrderDELIVEREDITEMINDICES("Order_DELIVEREDITEMINDICES"); + + public final NumberPath _index = createNumber("_index", Integer.class); + + public final NumberPath delivereditemindices = + createNumber("delivereditemindices", Integer.class); + + public final NumberPath orderID = createNumber("orderID", Long.class); + + public final com.querydsl.sql.ForeignKey orderDELIVEREDITEMINDICESOrderIDFK = + createForeignKey(orderID, "ID"); + + public SOrderDELIVEREDITEMINDICES(String variable) { + super( + SOrderDELIVEREDITEMINDICES.class, + forVariable(variable), + "null", + "Order_DELIVEREDITEMINDICES"); + addMetadata(); + } + + public SOrderDELIVEREDITEMINDICES(String variable, String schema, String table) { + super(SOrderDELIVEREDITEMINDICES.class, forVariable(variable), schema, table); + addMetadata(); + } + + public SOrderDELIVEREDITEMINDICES(String variable, String schema) { + super( + SOrderDELIVEREDITEMINDICES.class, + forVariable(variable), + schema, + "Order_DELIVEREDITEMINDICES"); + addMetadata(); + } + + public SOrderDELIVEREDITEMINDICES(Path path) { + super(path.getType(), path.getMetadata(), "null", "Order_DELIVEREDITEMINDICES"); + addMetadata(); + } + + public SOrderDELIVEREDITEMINDICES(PathMetadata metadata) { + super(SOrderDELIVEREDITEMINDICES.class, metadata, "null", "Order_DELIVEREDITEMINDICES"); + addMetadata(); + } + + public void addMetadata() { + addMetadata( + _index, ColumnMetadata.named("_index").withIndex(3).ofType(Types.INTEGER).withSize(10)); + addMetadata( + delivereditemindices, + ColumnMetadata.named("DELIVEREDITEMINDICES") + .withIndex(2) + .ofType(Types.INTEGER) + .withSize(10)); + addMetadata( + orderID, ColumnMetadata.named("Order_ID").withIndex(1).ofType(Types.BIGINT).withSize(19)); + } +} diff --git a/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SOrder_.java b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SOrder_.java new file mode 100644 index 0000000000..7ea98eb535 --- /dev/null +++ b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SOrder_.java @@ -0,0 +1,79 @@ +package com.querydsl.jpa.domain.sql; + +import static com.querydsl.core.types.PathMetadataFactory.*; + +import com.querydsl.core.types.Path; +import com.querydsl.core.types.PathMetadata; +import com.querydsl.core.types.dsl.*; +import com.querydsl.sql.ColumnMetadata; +import java.sql.Types; +import javax.annotation.processing.Generated; + +/** SOrder_ is a Querydsl query type for SOrder_ */ +@Generated("com.querydsl.sql.codegen.MetaDataSerializer") +public class SOrder_ extends com.querydsl.sql.RelationalPathBase { + + private static final long serialVersionUID = 747661657; + + public static final SOrder_ order_ = new SOrder_("order_"); + + public final NumberPath customerId = createNumber("customerId", Integer.class); + + public final NumberPath id = createNumber("id", Long.class); + + public final BooleanPath paid = createBoolean("paid"); + + public final com.querydsl.sql.PrimaryKey primary = createPrimaryKey(id); + + public final com.querydsl.sql.ForeignKey order_CUSTOMERIDFK = + createForeignKey(customerId, "ID"); + + public final com.querydsl.sql.ForeignKey _lineItems2OrderIDFK = + createInvForeignKey(id, "Order_ID"); + + public final com.querydsl.sql.ForeignKey _lineItemsOrderIDFK = + createInvForeignKey(id, "Order_ID"); + + public final com.querydsl.sql.ForeignKey + _orderDELIVEREDITEMINDICESOrderIDFK = createInvForeignKey(id, "Order_ID"); + + public final com.querydsl.sql.ForeignKey _customer_CURRENTORDERIDFK = + createInvForeignKey(id, "CURRENTORDER_ID"); + + public final com.querydsl.sql.ForeignKey _order_item_OrderIDFK = + createInvForeignKey(id, "Order_ID"); + + public SOrder_(String variable) { + super(SOrder_.class, forVariable(variable), "null", "order_"); + addMetadata(); + } + + public SOrder_(String variable, String schema, String table) { + super(SOrder_.class, forVariable(variable), schema, table); + addMetadata(); + } + + public SOrder_(String variable, String schema) { + super(SOrder_.class, forVariable(variable), schema, "order_"); + addMetadata(); + } + + public SOrder_(Path path) { + super(path.getType(), path.getMetadata(), "null", "order_"); + addMetadata(); + } + + public SOrder_(PathMetadata metadata) { + super(SOrder_.class, metadata, "null", "order_"); + addMetadata(); + } + + public void addMetadata() { + addMetadata( + customerId, + ColumnMetadata.named("CUSTOMER_ID").withIndex(3).ofType(Types.INTEGER).withSize(10)); + addMetadata( + id, ColumnMetadata.named("ID").withIndex(1).ofType(Types.BIGINT).withSize(19).notNull()); + addMetadata(paid, ColumnMetadata.named("PAID").withIndex(2).ofType(Types.BIT).withSize(1)); + } +} diff --git a/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SOrder_item_.java b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SOrder_item_.java new file mode 100644 index 0000000000..3d19c19aa3 --- /dev/null +++ b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SOrder_item_.java @@ -0,0 +1,70 @@ +package com.querydsl.jpa.domain.sql; + +import static com.querydsl.core.types.PathMetadataFactory.*; + +import com.querydsl.core.types.Path; +import com.querydsl.core.types.PathMetadata; +import com.querydsl.core.types.dsl.*; +import com.querydsl.sql.ColumnMetadata; +import java.sql.Types; +import javax.annotation.processing.Generated; + +/** SOrder_item_ is a Querydsl query type for SOrder_item_ */ +@Generated("com.querydsl.sql.codegen.MetaDataSerializer") +public class SOrder_item_ extends com.querydsl.sql.RelationalPathBase { + + private static final long serialVersionUID = -131699213; + + public static final SOrder_item_ order_item_ = new SOrder_item_("order__item_"); + + public final NumberPath _index = createNumber("_index", Integer.class); + + public final NumberPath itemsID = createNumber("itemsID", Long.class); + + public final NumberPath orderID = createNumber("orderID", Long.class); + + public final com.querydsl.sql.PrimaryKey primary = + createPrimaryKey(orderID, itemsID); + + public final com.querydsl.sql.ForeignKey order_item_OrderIDFK = + createForeignKey(orderID, "ID"); + + public final com.querydsl.sql.ForeignKey order_item_itemsIDFK = + createForeignKey(itemsID, "ID"); + + public SOrder_item_(String variable) { + super(SOrder_item_.class, forVariable(variable), "null", "order__item_"); + addMetadata(); + } + + public SOrder_item_(String variable, String schema, String table) { + super(SOrder_item_.class, forVariable(variable), schema, table); + addMetadata(); + } + + public SOrder_item_(String variable, String schema) { + super(SOrder_item_.class, forVariable(variable), schema, "order__item_"); + addMetadata(); + } + + public SOrder_item_(Path path) { + super(path.getType(), path.getMetadata(), "null", "order__item_"); + addMetadata(); + } + + public SOrder_item_(PathMetadata metadata) { + super(SOrder_item_.class, metadata, "null", "order__item_"); + addMetadata(); + } + + public void addMetadata() { + addMetadata( + _index, ColumnMetadata.named("_index").withIndex(3).ofType(Types.INTEGER).withSize(10)); + addMetadata( + itemsID, + ColumnMetadata.named("items_ID").withIndex(2).ofType(Types.BIGINT).withSize(19).notNull()); + addMetadata( + orderID, + ColumnMetadata.named("Order_ID").withIndex(1).ofType(Types.BIGINT).withSize(19).notNull()); + } +} diff --git a/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SParameter_.java b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SParameter_.java new file mode 100644 index 0000000000..c137a17677 --- /dev/null +++ b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SParameter_.java @@ -0,0 +1,56 @@ +package com.querydsl.jpa.domain.sql; + +import static com.querydsl.core.types.PathMetadataFactory.*; + +import com.querydsl.core.types.Path; +import com.querydsl.core.types.PathMetadata; +import com.querydsl.core.types.dsl.*; +import com.querydsl.sql.ColumnMetadata; +import java.sql.Types; +import javax.annotation.processing.Generated; + +/** SParameter_ is a Querydsl query type for SParameter_ */ +@Generated("com.querydsl.sql.codegen.MetaDataSerializer") +public class SParameter_ extends com.querydsl.sql.RelationalPathBase { + + private static final long serialVersionUID = 529679454; + + public static final SParameter_ parameter_ = new SParameter_("parameter_"); + + public final NumberPath id = createNumber("id", Long.class); + + public final com.querydsl.sql.PrimaryKey primary = createPrimaryKey(id); + + public final com.querydsl.sql.ForeignKey _formula_PARAMETERIDFK = + createInvForeignKey(id, "PARAMETER_ID"); + + public SParameter_(String variable) { + super(SParameter_.class, forVariable(variable), "null", "parameter_"); + addMetadata(); + } + + public SParameter_(String variable, String schema, String table) { + super(SParameter_.class, forVariable(variable), schema, table); + addMetadata(); + } + + public SParameter_(String variable, String schema) { + super(SParameter_.class, forVariable(variable), schema, "parameter_"); + addMetadata(); + } + + public SParameter_(Path path) { + super(path.getType(), path.getMetadata(), "null", "parameter_"); + addMetadata(); + } + + public SParameter_(PathMetadata metadata) { + super(SParameter_.class, metadata, "null", "parameter_"); + addMetadata(); + } + + public void addMetadata() { + addMetadata( + id, ColumnMetadata.named("ID").withIndex(1).ofType(Types.BIGINT).withSize(19).notNull()); + } +} diff --git a/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SParent2.java b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SParent2.java index 2eeb006d4e..680ef1ca41 100644 --- a/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SParent2.java +++ b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SParent2.java @@ -1,30 +1,31 @@ package com.querydsl.jpa.domain.sql; -import static com.querydsl.core.types.PathMetadataFactory.forVariable; +import static com.querydsl.core.types.PathMetadataFactory.*; import com.querydsl.core.types.Path; import com.querydsl.core.types.PathMetadata; -import com.querydsl.core.types.dsl.NumberPath; +import com.querydsl.core.types.dsl.*; import com.querydsl.sql.ColumnMetadata; -import jakarta.annotation.Generated; +import java.sql.Types; +import javax.annotation.processing.Generated; /** SParent2 is a Querydsl query type for SParent2 */ @Generated("com.querydsl.sql.codegen.MetaDataSerializer") public class SParent2 extends com.querydsl.sql.RelationalPathBase { - private static final long serialVersionUID = 1859105463; + private static final long serialVersionUID = 2116409152; - public static final SParent2 Parent2 = new SParent2("Parent2"); + public static final SParent2 parent2 = new SParent2("PARENT2"); public final NumberPath id = createNumber("id", Integer.class); public final com.querydsl.sql.PrimaryKey primary = createPrimaryKey(id); - public final com.querydsl.sql.ForeignKey _fk783f9ab6c2dbacbc = - createInvForeignKey(id, "parent_id"); + public final com.querydsl.sql.ForeignKey _child2ParentIdFk = + createInvForeignKey(id, "PARENT_ID"); public SParent2(String variable) { - super(SParent2.class, forVariable(variable), "", "Parent2"); + super(SParent2.class, forVariable(variable), "null", "PARENT2"); addMetadata(); } @@ -33,17 +34,23 @@ public SParent2(String variable, String schema, String table) { addMetadata(); } + public SParent2(String variable, String schema) { + super(SParent2.class, forVariable(variable), schema, "PARENT2"); + addMetadata(); + } + public SParent2(Path path) { - super(path.getType(), path.getMetadata(), "", "Parent2"); + super(path.getType(), path.getMetadata(), "null", "PARENT2"); addMetadata(); } public SParent2(PathMetadata metadata) { - super(SParent2.class, metadata, "", "Parent2"); + super(SParent2.class, metadata, "null", "PARENT2"); addMetadata(); } public void addMetadata() { - addMetadata(id, ColumnMetadata.named("id").withIndex(1).ofType(4).withSize(10).notNull()); + addMetadata( + id, ColumnMetadata.named("ID").withIndex(1).ofType(Types.INTEGER).withSize(10).notNull()); } } diff --git a/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SParent_.java b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SParent_.java new file mode 100644 index 0000000000..763673e73b --- /dev/null +++ b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SParent_.java @@ -0,0 +1,62 @@ +package com.querydsl.jpa.domain.sql; + +import static com.querydsl.core.types.PathMetadataFactory.*; + +import com.querydsl.core.types.Path; +import com.querydsl.core.types.PathMetadata; +import com.querydsl.core.types.dsl.*; +import com.querydsl.sql.ColumnMetadata; +import java.sql.Types; +import javax.annotation.processing.Generated; + +/** SParent_ is a Querydsl query type for SParent_ */ +@Generated("com.querydsl.sql.codegen.MetaDataSerializer") +public class SParent_ extends com.querydsl.sql.RelationalPathBase { + + private static final long serialVersionUID = 2116409197; + + public static final SParent_ parent_ = new SParent_("parent_"); + + public final StringPath childname = createString("childname"); + + public final NumberPath id = createNumber("id", Long.class); + + public final StringPath name = createString("name"); + + public final com.querydsl.sql.PrimaryKey primary = createPrimaryKey(id); + + public SParent_(String variable) { + super(SParent_.class, forVariable(variable), "null", "parent_"); + addMetadata(); + } + + public SParent_(String variable, String schema, String table) { + super(SParent_.class, forVariable(variable), schema, table); + addMetadata(); + } + + public SParent_(String variable, String schema) { + super(SParent_.class, forVariable(variable), schema, "parent_"); + addMetadata(); + } + + public SParent_(Path path) { + super(path.getType(), path.getMetadata(), "null", "parent_"); + addMetadata(); + } + + public SParent_(PathMetadata metadata) { + super(SParent_.class, metadata, "null", "parent_"); + addMetadata(); + } + + public void addMetadata() { + addMetadata( + childname, + ColumnMetadata.named("CHILDNAME").withIndex(3).ofType(Types.VARCHAR).withSize(255)); + addMetadata( + id, ColumnMetadata.named("ID").withIndex(1).ofType(Types.BIGINT).withSize(19).notNull()); + addMetadata( + name, ColumnMetadata.named("NAME").withIndex(2).ofType(Types.VARCHAR).withSize(255)); + } +} diff --git a/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SPerson_.java b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SPerson_.java new file mode 100644 index 0000000000..beddeb298a --- /dev/null +++ b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SPerson_.java @@ -0,0 +1,79 @@ +package com.querydsl.jpa.domain.sql; + +import static com.querydsl.core.types.PathMetadataFactory.*; + +import com.querydsl.core.types.Path; +import com.querydsl.core.types.PathMetadata; +import com.querydsl.core.types.dsl.*; +import com.querydsl.sql.ColumnMetadata; +import java.sql.Types; +import javax.annotation.processing.Generated; + +/** SPerson_ is a Querydsl query type for SPerson_ */ +@Generated("com.querydsl.sql.codegen.MetaDataSerializer") +public class SPerson_ extends com.querydsl.sql.RelationalPathBase { + + private static final long serialVersionUID = -2063623646; + + public static final SPerson_ person_ = new SPerson_("person_"); + + public final DatePath birthday = createDate("birthday", java.sql.Date.class); + + public final NumberPath i = createNumber("i", Long.class); + + public final StringPath name = createString("name"); + + public final NumberPath nationalityId = createNumber("nationalityId", Long.class); + + public final NumberPath pidId = createNumber("pidId", Long.class); + + public final com.querydsl.sql.PrimaryKey primary = createPrimaryKey(i); + + public final com.querydsl.sql.ForeignKey person_NATIONALITYIDFK = + createForeignKey(nationalityId, "ID"); + + public final com.querydsl.sql.ForeignKey person_PIDIDFK = + createForeignKey(pidId, "ID"); + + public final com.querydsl.sql.ForeignKey _account_OWNERIFK = + createInvForeignKey(i, "OWNER_I"); + + public SPerson_(String variable) { + super(SPerson_.class, forVariable(variable), "null", "person_"); + addMetadata(); + } + + public SPerson_(String variable, String schema, String table) { + super(SPerson_.class, forVariable(variable), schema, table); + addMetadata(); + } + + public SPerson_(String variable, String schema) { + super(SPerson_.class, forVariable(variable), schema, "person_"); + addMetadata(); + } + + public SPerson_(Path path) { + super(path.getType(), path.getMetadata(), "null", "person_"); + addMetadata(); + } + + public SPerson_(PathMetadata metadata) { + super(SPerson_.class, metadata, "null", "person_"); + addMetadata(); + } + + public void addMetadata() { + addMetadata( + birthday, ColumnMetadata.named("BIRTHDAY").withIndex(2).ofType(Types.DATE).withSize(10)); + addMetadata( + i, ColumnMetadata.named("I").withIndex(1).ofType(Types.BIGINT).withSize(19).notNull()); + addMetadata( + name, ColumnMetadata.named("NAME").withIndex(3).ofType(Types.VARCHAR).withSize(255)); + addMetadata( + nationalityId, + ColumnMetadata.named("NATIONALITY_ID").withIndex(4).ofType(Types.BIGINT).withSize(19)); + addMetadata( + pidId, ColumnMetadata.named("PID_ID").withIndex(5).ofType(Types.BIGINT).withSize(19)); + } +} diff --git a/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SPersonid_.java b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SPersonid_.java new file mode 100644 index 0000000000..d2390539e2 --- /dev/null +++ b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SPersonid_.java @@ -0,0 +1,65 @@ +package com.querydsl.jpa.domain.sql; + +import static com.querydsl.core.types.PathMetadataFactory.*; + +import com.querydsl.core.types.Path; +import com.querydsl.core.types.PathMetadata; +import com.querydsl.core.types.dsl.*; +import com.querydsl.sql.ColumnMetadata; +import java.sql.Types; +import javax.annotation.processing.Generated; + +/** SPersonid_ is a Querydsl query type for SPersonid_ */ +@Generated("com.querydsl.sql.codegen.MetaDataSerializer") +public class SPersonid_ extends com.querydsl.sql.RelationalPathBase { + + private static final long serialVersionUID = 1132579751; + + public static final SPersonid_ personid_ = new SPersonid_("personid_"); + + public final StringPath country = createString("country"); + + public final NumberPath id = createNumber("id", Long.class); + + public final NumberPath medicarenumber = createNumber("medicarenumber", Integer.class); + + public final com.querydsl.sql.PrimaryKey primary = createPrimaryKey(id); + + public final com.querydsl.sql.ForeignKey _person_PIDIDFK = + createInvForeignKey(id, "PID_ID"); + + public SPersonid_(String variable) { + super(SPersonid_.class, forVariable(variable), "null", "personid_"); + addMetadata(); + } + + public SPersonid_(String variable, String schema, String table) { + super(SPersonid_.class, forVariable(variable), schema, table); + addMetadata(); + } + + public SPersonid_(String variable, String schema) { + super(SPersonid_.class, forVariable(variable), schema, "personid_"); + addMetadata(); + } + + public SPersonid_(Path path) { + super(path.getType(), path.getMetadata(), "null", "personid_"); + addMetadata(); + } + + public SPersonid_(PathMetadata metadata) { + super(SPersonid_.class, metadata, "null", "personid_"); + addMetadata(); + } + + public void addMetadata() { + addMetadata( + country, ColumnMetadata.named("COUNTRY").withIndex(2).ofType(Types.VARCHAR).withSize(255)); + addMetadata( + id, ColumnMetadata.named("ID").withIndex(1).ofType(Types.BIGINT).withSize(19).notNull()); + addMetadata( + medicarenumber, + ColumnMetadata.named("MEDICARENUMBER").withIndex(3).ofType(Types.INTEGER).withSize(10)); + } +} diff --git a/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SPlayerSCORES.java b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SPlayerSCORES.java new file mode 100644 index 0000000000..1ee7aac4af --- /dev/null +++ b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SPlayerSCORES.java @@ -0,0 +1,58 @@ +package com.querydsl.jpa.domain.sql; + +import static com.querydsl.core.types.PathMetadataFactory.*; + +import com.querydsl.core.types.Path; +import com.querydsl.core.types.PathMetadata; +import com.querydsl.core.types.dsl.*; +import com.querydsl.sql.ColumnMetadata; +import java.sql.Types; +import javax.annotation.processing.Generated; + +/** SPlayerSCORES is a Querydsl query type for SPlayerSCORES */ +@Generated("com.querydsl.sql.codegen.MetaDataSerializer") +public class SPlayerSCORES extends com.querydsl.sql.RelationalPathBase { + + private static final long serialVersionUID = -841435446; + + public static final SPlayerSCORES PlayerSCORES = new SPlayerSCORES("Player_SCORES"); + + public final NumberPath playerID = createNumber("playerID", Long.class); + + public final NumberPath scores = createNumber("scores", Integer.class); + + public final com.querydsl.sql.ForeignKey playerSCORESPlayerIDFK = + createForeignKey(playerID, "ID"); + + public SPlayerSCORES(String variable) { + super(SPlayerSCORES.class, forVariable(variable), "null", "Player_SCORES"); + addMetadata(); + } + + public SPlayerSCORES(String variable, String schema, String table) { + super(SPlayerSCORES.class, forVariable(variable), schema, table); + addMetadata(); + } + + public SPlayerSCORES(String variable, String schema) { + super(SPlayerSCORES.class, forVariable(variable), schema, "Player_SCORES"); + addMetadata(); + } + + public SPlayerSCORES(Path path) { + super(path.getType(), path.getMetadata(), "null", "Player_SCORES"); + addMetadata(); + } + + public SPlayerSCORES(PathMetadata metadata) { + super(SPlayerSCORES.class, metadata, "null", "Player_SCORES"); + addMetadata(); + } + + public void addMetadata() { + addMetadata( + playerID, ColumnMetadata.named("Player_ID").withIndex(1).ofType(Types.BIGINT).withSize(19)); + addMetadata( + scores, ColumnMetadata.named("SCORES").withIndex(2).ofType(Types.INTEGER).withSize(10)); + } +} diff --git a/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SPlayer_.java b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SPlayer_.java new file mode 100644 index 0000000000..99dbc3cf2a --- /dev/null +++ b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SPlayer_.java @@ -0,0 +1,56 @@ +package com.querydsl.jpa.domain.sql; + +import static com.querydsl.core.types.PathMetadataFactory.*; + +import com.querydsl.core.types.Path; +import com.querydsl.core.types.PathMetadata; +import com.querydsl.core.types.dsl.*; +import com.querydsl.sql.ColumnMetadata; +import java.sql.Types; +import javax.annotation.processing.Generated; + +/** SPlayer_ is a Querydsl query type for SPlayer_ */ +@Generated("com.querydsl.sql.codegen.MetaDataSerializer") +public class SPlayer_ extends com.querydsl.sql.RelationalPathBase { + + private static final long serialVersionUID = -1878750186; + + public static final SPlayer_ player_ = new SPlayer_("player_"); + + public final NumberPath id = createNumber("id", Long.class); + + public final com.querydsl.sql.PrimaryKey primary = createPrimaryKey(id); + + public final com.querydsl.sql.ForeignKey _playerSCORESPlayerIDFK = + createInvForeignKey(id, "Player_ID"); + + public SPlayer_(String variable) { + super(SPlayer_.class, forVariable(variable), "null", "player_"); + addMetadata(); + } + + public SPlayer_(String variable, String schema, String table) { + super(SPlayer_.class, forVariable(variable), schema, table); + addMetadata(); + } + + public SPlayer_(String variable, String schema) { + super(SPlayer_.class, forVariable(variable), schema, "player_"); + addMetadata(); + } + + public SPlayer_(Path path) { + super(path.getType(), path.getMetadata(), "null", "player_"); + addMetadata(); + } + + public SPlayer_(PathMetadata metadata) { + super(SPlayer_.class, metadata, "null", "player_"); + addMetadata(); + } + + public void addMetadata() { + addMetadata( + id, ColumnMetadata.named("ID").withIndex(1).ofType(Types.BIGINT).withSize(19).notNull()); + } +} diff --git a/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SPrice_.java b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SPrice_.java new file mode 100644 index 0000000000..310fdbd23a --- /dev/null +++ b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SPrice_.java @@ -0,0 +1,68 @@ +package com.querydsl.jpa.domain.sql; + +import static com.querydsl.core.types.PathMetadataFactory.*; + +import com.querydsl.core.types.Path; +import com.querydsl.core.types.PathMetadata; +import com.querydsl.core.types.dsl.*; +import com.querydsl.sql.ColumnMetadata; +import java.sql.Types; +import javax.annotation.processing.Generated; + +/** SPrice_ is a Querydsl query type for SPrice_ */ +@Generated("com.querydsl.sql.codegen.MetaDataSerializer") +public class SPrice_ extends com.querydsl.sql.RelationalPathBase { + + private static final long serialVersionUID = 776437438; + + public static final SPrice_ price_ = new SPrice_("price_"); + + public final NumberPath amount = createNumber("amount", Long.class); + + public final NumberPath id = createNumber("id", Long.class); + + public final NumberPath productId = createNumber("productId", Long.class); + + public final com.querydsl.sql.PrimaryKey primary = createPrimaryKey(id); + + public final com.querydsl.sql.ForeignKey price_PRODUCTIDFK = + createForeignKey(productId, "ID"); + + public final com.querydsl.sql.ForeignKey _catalog_price_pricesIDFK = + createInvForeignKey(id, "prices_ID"); + + public SPrice_(String variable) { + super(SPrice_.class, forVariable(variable), "null", "price_"); + addMetadata(); + } + + public SPrice_(String variable, String schema, String table) { + super(SPrice_.class, forVariable(variable), schema, table); + addMetadata(); + } + + public SPrice_(String variable, String schema) { + super(SPrice_.class, forVariable(variable), schema, "price_"); + addMetadata(); + } + + public SPrice_(Path path) { + super(path.getType(), path.getMetadata(), "null", "price_"); + addMetadata(); + } + + public SPrice_(PathMetadata metadata) { + super(SPrice_.class, metadata, "null", "price_"); + addMetadata(); + } + + public void addMetadata() { + addMetadata( + amount, ColumnMetadata.named("AMOUNT").withIndex(2).ofType(Types.BIGINT).withSize(19)); + addMetadata( + id, ColumnMetadata.named("ID").withIndex(1).ofType(Types.BIGINT).withSize(19).notNull()); + addMetadata( + productId, + ColumnMetadata.named("PRODUCT_ID").withIndex(3).ofType(Types.BIGINT).withSize(19)); + } +} diff --git a/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SSequence.java b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SSequence.java new file mode 100644 index 0000000000..5cf2953a6a --- /dev/null +++ b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SSequence.java @@ -0,0 +1,60 @@ +package com.querydsl.jpa.domain.sql; + +import static com.querydsl.core.types.PathMetadataFactory.*; + +import com.querydsl.core.types.Path; +import com.querydsl.core.types.PathMetadata; +import com.querydsl.core.types.dsl.*; +import com.querydsl.sql.ColumnMetadata; +import java.sql.Types; +import javax.annotation.processing.Generated; + +/** SSequence is a Querydsl query type for SSequence */ +@Generated("com.querydsl.sql.codegen.MetaDataSerializer") +public class SSequence extends com.querydsl.sql.RelationalPathBase { + + private static final long serialVersionUID = 1358560329; + + public static final SSequence sequence = new SSequence("SEQUENCE"); + + public final NumberPath seqCount = + createNumber("seqCount", java.math.BigInteger.class); + + public final StringPath seqName = createString("seqName"); + + public final com.querydsl.sql.PrimaryKey primary = createPrimaryKey(seqName); + + public SSequence(String variable) { + super(SSequence.class, forVariable(variable), "null", "SEQUENCE"); + addMetadata(); + } + + public SSequence(String variable, String schema, String table) { + super(SSequence.class, forVariable(variable), schema, table); + addMetadata(); + } + + public SSequence(String variable, String schema) { + super(SSequence.class, forVariable(variable), schema, "SEQUENCE"); + addMetadata(); + } + + public SSequence(Path path) { + super(path.getType(), path.getMetadata(), "null", "SEQUENCE"); + addMetadata(); + } + + public SSequence(PathMetadata metadata) { + super(SSequence.class, metadata, "null", "SEQUENCE"); + addMetadata(); + } + + public void addMetadata() { + addMetadata( + seqCount, + ColumnMetadata.named("SEQ_COUNT").withIndex(2).ofType(Types.DECIMAL).withSize(38)); + addMetadata( + seqName, + ColumnMetadata.named("SEQ_NAME").withIndex(1).ofType(Types.VARCHAR).withSize(50).notNull()); + } +} diff --git a/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SShapes.java b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SShapes.java index 0e2138c5f9..8698a54d74 100644 --- a/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SShapes.java +++ b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SShapes.java @@ -1,19 +1,19 @@ package com.querydsl.jpa.domain.sql; -import static com.querydsl.core.types.PathMetadataFactory.forVariable; +import static com.querydsl.core.types.PathMetadataFactory.*; import com.querydsl.core.types.Path; import com.querydsl.core.types.PathMetadata; -import com.querydsl.core.types.dsl.NumberPath; -import com.querydsl.core.types.dsl.SimplePath; +import com.querydsl.core.types.dsl.*; import com.querydsl.sql.ColumnMetadata; -import jakarta.annotation.Generated; +import java.sql.Types; +import javax.annotation.processing.Generated; /** SShapes is a Querydsl query type for SShapes */ @Generated("com.querydsl.sql.codegen.MetaDataSerializer") public class SShapes extends com.querydsl.sql.RelationalPathBase { - private static final long serialVersionUID = 844563747; + private static final long serialVersionUID = 852863866; public static final SShapes shapes = new SShapes("SHAPES"); @@ -24,7 +24,7 @@ public class SShapes extends com.querydsl.sql.RelationalPathBase { public final com.querydsl.sql.PrimaryKey primary = createPrimaryKey(id); public SShapes(String variable) { - super(SShapes.class, forVariable(variable), "", "SHAPES"); + super(SShapes.class, forVariable(variable), "null", "SHAPES"); addMetadata(); } @@ -33,18 +33,26 @@ public SShapes(String variable, String schema, String table) { addMetadata(); } + public SShapes(String variable, String schema) { + super(SShapes.class, forVariable(variable), schema, "SHAPES"); + addMetadata(); + } + public SShapes(Path path) { - super(path.getType(), path.getMetadata(), "", "SHAPES"); + super(path.getType(), path.getMetadata(), "null", "SHAPES"); addMetadata(); } public SShapes(PathMetadata metadata) { - super(SShapes.class, metadata, "", "SHAPES"); + super(SShapes.class, metadata, "null", "SHAPES"); addMetadata(); } public void addMetadata() { - addMetadata(geometry, ColumnMetadata.named("GEOMETRY").withIndex(2).ofType(-2)); - addMetadata(id, ColumnMetadata.named("ID").withIndex(1).ofType(4).withSize(10).notNull()); + addMetadata( + geometry, + ColumnMetadata.named("GEOMETRY").withIndex(2).ofType(Types.BINARY).withSize(65535)); + addMetadata( + id, ColumnMetadata.named("ID").withIndex(1).ofType(Types.INTEGER).withSize(10).notNull()); } } diff --git a/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SShowACTS.java b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SShowACTS.java new file mode 100644 index 0000000000..c6d90355ad --- /dev/null +++ b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SShowACTS.java @@ -0,0 +1,62 @@ +package com.querydsl.jpa.domain.sql; + +import static com.querydsl.core.types.PathMetadataFactory.*; + +import com.querydsl.core.types.Path; +import com.querydsl.core.types.PathMetadata; +import com.querydsl.core.types.dsl.*; +import com.querydsl.sql.ColumnMetadata; +import java.sql.Types; +import javax.annotation.processing.Generated; + +/** SShowACTS is a Querydsl query type for SShowACTS */ +@Generated("com.querydsl.sql.codegen.MetaDataSerializer") +public class SShowACTS extends com.querydsl.sql.RelationalPathBase { + + private static final long serialVersionUID = -330421466; + + public static final SShowACTS ShowACTS = new SShowACTS("Show_ACTS"); + + public final StringPath acts = createString("acts"); + + public final StringPath actsKey = createString("actsKey"); + + public final NumberPath showID = createNumber("showID", Long.class); + + public final com.querydsl.sql.ForeignKey showACTSShowIDFK = + createForeignKey(showID, "ID"); + + public SShowACTS(String variable) { + super(SShowACTS.class, forVariable(variable), "null", "Show_ACTS"); + addMetadata(); + } + + public SShowACTS(String variable, String schema, String table) { + super(SShowACTS.class, forVariable(variable), schema, table); + addMetadata(); + } + + public SShowACTS(String variable, String schema) { + super(SShowACTS.class, forVariable(variable), schema, "Show_ACTS"); + addMetadata(); + } + + public SShowACTS(Path path) { + super(path.getType(), path.getMetadata(), "null", "Show_ACTS"); + addMetadata(); + } + + public SShowACTS(PathMetadata metadata) { + super(SShowACTS.class, metadata, "null", "Show_ACTS"); + addMetadata(); + } + + public void addMetadata() { + addMetadata( + acts, ColumnMetadata.named("ACTS").withIndex(2).ofType(Types.VARCHAR).withSize(255)); + addMetadata( + actsKey, ColumnMetadata.named("acts_key").withIndex(3).ofType(Types.VARCHAR).withSize(255)); + addMetadata( + showID, ColumnMetadata.named("Show_ID").withIndex(1).ofType(Types.BIGINT).withSize(19)); + } +} diff --git a/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SShow_.java b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SShow_.java new file mode 100644 index 0000000000..d7ee518956 --- /dev/null +++ b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SShow_.java @@ -0,0 +1,66 @@ +package com.querydsl.jpa.domain.sql; + +import static com.querydsl.core.types.PathMetadataFactory.*; + +import com.querydsl.core.types.Path; +import com.querydsl.core.types.PathMetadata; +import com.querydsl.core.types.dsl.*; +import com.querydsl.sql.ColumnMetadata; +import java.sql.Types; +import javax.annotation.processing.Generated; + +/** SShow_ is a Querydsl query type for SShow_ */ +@Generated("com.querydsl.sql.codegen.MetaDataSerializer") +public class SShow_ extends com.querydsl.sql.RelationalPathBase { + + private static final long serialVersionUID = -942305926; + + public static final SShow_ show_ = new SShow_("show_"); + + public final NumberPath id = createNumber("id", Long.class); + + public final NumberPath parentId = createNumber("parentId", Long.class); + + public final com.querydsl.sql.PrimaryKey primary = createPrimaryKey(id); + + public final com.querydsl.sql.ForeignKey show_PARENTIDFK = + createForeignKey(parentId, "ID"); + + public final com.querydsl.sql.ForeignKey _showACTSShowIDFK = + createInvForeignKey(id, "Show_ID"); + + public final com.querydsl.sql.ForeignKey _show_PARENTIDFK = + createInvForeignKey(id, "PARENT_ID"); + + public SShow_(String variable) { + super(SShow_.class, forVariable(variable), "null", "show_"); + addMetadata(); + } + + public SShow_(String variable, String schema, String table) { + super(SShow_.class, forVariable(variable), schema, table); + addMetadata(); + } + + public SShow_(String variable, String schema) { + super(SShow_.class, forVariable(variable), schema, "show_"); + addMetadata(); + } + + public SShow_(Path path) { + super(path.getType(), path.getMetadata(), "null", "show_"); + addMetadata(); + } + + public SShow_(PathMetadata metadata) { + super(SShow_.class, metadata, "null", "show_"); + addMetadata(); + } + + public void addMetadata() { + addMetadata( + id, ColumnMetadata.named("ID").withIndex(1).ofType(Types.BIGINT).withSize(19).notNull()); + addMetadata( + parentId, ColumnMetadata.named("PARENT_ID").withIndex(2).ofType(Types.BIGINT).withSize(19)); + } +} diff --git a/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SSimpletypes_.java b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SSimpletypes_.java new file mode 100644 index 0000000000..b3c182560d --- /dev/null +++ b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SSimpletypes_.java @@ -0,0 +1,137 @@ +package com.querydsl.jpa.domain.sql; + +import static com.querydsl.core.types.PathMetadataFactory.*; + +import com.querydsl.core.types.Path; +import com.querydsl.core.types.PathMetadata; +import com.querydsl.core.types.dsl.*; +import com.querydsl.sql.ColumnMetadata; +import java.sql.Types; +import javax.annotation.processing.Generated; + +/** SSimpletypes_ is a Querydsl query type for SSimpletypes_ */ +@Generated("com.querydsl.sql.codegen.MetaDataSerializer") +public class SSimpletypes_ extends com.querydsl.sql.RelationalPathBase { + + private static final long serialVersionUID = -971482176; + + public static final SSimpletypes_ simpletypes_ = new SSimpletypes_("simpletypes_"); + + public final NumberPath bbyte = createNumber("bbyte", Byte.class); + + public final NumberPath bbyte2 = createNumber("bbyte2", Byte.class); + + public final NumberPath bigdecimal = + createNumber("bigdecimal", java.math.BigInteger.class); + + public final SimplePath bytearray = createSimple("bytearray", byte[].class); + + public final StringPath cchar = createString("cchar"); + + public final StringPath cchar2 = createString("cchar2"); + + public final DatePath date = createDate("date", java.sql.Date.class); + + public final NumberPath ddouble = createNumber("ddouble", Double.class); + + public final NumberPath ddouble2 = createNumber("ddouble2", Double.class); + + public final NumberPath ffloat = createNumber("ffloat", Float.class); + + public final NumberPath ffloat2 = createNumber("ffloat2", Float.class); + + public final NumberPath id = createNumber("id", Long.class); + + public final NumberPath iint = createNumber("iint", Integer.class); + + public final NumberPath iint2 = createNumber("iint2", Integer.class); + + public final SimplePath llocale = createSimple("llocale", byte[].class); + + public final NumberPath llong = createNumber("llong", Long.class); + + public final NumberPath llong2 = createNumber("llong2", Long.class); + + public final StringPath sstring = createString("sstring"); + + public final TimePath time = createTime("time", java.sql.Time.class); + + public final DateTimePath timestamp = + createDateTime("timestamp", java.sql.Timestamp.class); + + public final com.querydsl.sql.PrimaryKey primary = createPrimaryKey(id); + + public SSimpletypes_(String variable) { + super(SSimpletypes_.class, forVariable(variable), "null", "simpletypes_"); + addMetadata(); + } + + public SSimpletypes_(String variable, String schema, String table) { + super(SSimpletypes_.class, forVariable(variable), schema, table); + addMetadata(); + } + + public SSimpletypes_(String variable, String schema) { + super(SSimpletypes_.class, forVariable(variable), schema, "simpletypes_"); + addMetadata(); + } + + public SSimpletypes_(Path path) { + super(path.getType(), path.getMetadata(), "null", "simpletypes_"); + addMetadata(); + } + + public SSimpletypes_(PathMetadata metadata) { + super(SSimpletypes_.class, metadata, "null", "simpletypes_"); + addMetadata(); + } + + public void addMetadata() { + addMetadata( + bbyte, ColumnMetadata.named("BBYTE").withIndex(2).ofType(Types.TINYINT).withSize(3)); + addMetadata( + bbyte2, ColumnMetadata.named("BBYTE2").withIndex(3).ofType(Types.TINYINT).withSize(3)); + addMetadata( + bigdecimal, + ColumnMetadata.named("BIGDECIMAL").withIndex(4).ofType(Types.DECIMAL).withSize(38)); + addMetadata( + bytearray, + ColumnMetadata.named("BYTEARRAY") + .withIndex(5) + .ofType(Types.LONGVARBINARY) + .withSize(2147483647)); + addMetadata(cchar, ColumnMetadata.named("CCHAR").withIndex(6).ofType(Types.CHAR).withSize(1)); + addMetadata(cchar2, ColumnMetadata.named("CCHAR2").withIndex(7).ofType(Types.CHAR).withSize(1)); + addMetadata(date, ColumnMetadata.named("DATE").withIndex(8).ofType(Types.DATE).withSize(10)); + addMetadata( + ddouble, ColumnMetadata.named("DDOUBLE").withIndex(9).ofType(Types.DOUBLE).withSize(22)); + addMetadata( + ddouble2, ColumnMetadata.named("DDOUBLE2").withIndex(10).ofType(Types.DOUBLE).withSize(22)); + addMetadata( + ffloat, ColumnMetadata.named("FFLOAT").withIndex(11).ofType(Types.REAL).withSize(12)); + addMetadata( + ffloat2, ColumnMetadata.named("FFLOAT2").withIndex(12).ofType(Types.REAL).withSize(12)); + addMetadata( + id, ColumnMetadata.named("ID").withIndex(1).ofType(Types.BIGINT).withSize(19).notNull()); + addMetadata( + iint, ColumnMetadata.named("IINT").withIndex(13).ofType(Types.INTEGER).withSize(10)); + addMetadata( + iint2, ColumnMetadata.named("IINT2").withIndex(14).ofType(Types.INTEGER).withSize(10)); + addMetadata( + llocale, + ColumnMetadata.named("LLOCALE") + .withIndex(15) + .ofType(Types.LONGVARBINARY) + .withSize(2147483647)); + addMetadata( + llong, ColumnMetadata.named("LLONG").withIndex(16).ofType(Types.BIGINT).withSize(19)); + addMetadata( + llong2, ColumnMetadata.named("LLONG2").withIndex(17).ofType(Types.BIGINT).withSize(19)); + addMetadata( + sstring, ColumnMetadata.named("SSTRING").withIndex(18).ofType(Types.VARCHAR).withSize(255)); + addMetadata(time, ColumnMetadata.named("TIME").withIndex(19).ofType(Types.TIME).withSize(8)); + addMetadata( + timestamp, + ColumnMetadata.named("TIMESTAMP").withIndex(20).ofType(Types.TIMESTAMP).withSize(19)); + } +} diff --git a/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SStatus_.java b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SStatus_.java new file mode 100644 index 0000000000..8d17ad588f --- /dev/null +++ b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SStatus_.java @@ -0,0 +1,63 @@ +package com.querydsl.jpa.domain.sql; + +import static com.querydsl.core.types.PathMetadataFactory.*; + +import com.querydsl.core.types.Path; +import com.querydsl.core.types.PathMetadata; +import com.querydsl.core.types.dsl.*; +import com.querydsl.sql.ColumnMetadata; +import java.sql.Types; +import javax.annotation.processing.Generated; + +/** SStatus_ is a Querydsl query type for SStatus_ */ +@Generated("com.querydsl.sql.codegen.MetaDataSerializer") +public class SStatus_ extends com.querydsl.sql.RelationalPathBase { + + private static final long serialVersionUID = 1012660517; + + public static final SStatus_ status_ = new SStatus_("status_"); + + public final NumberPath id = createNumber("id", Long.class); + + public final StringPath name = createString("name"); + + public final com.querydsl.sql.PrimaryKey primary = createPrimaryKey(id); + + public final com.querydsl.sql.ForeignKey _item_CURRENTSTATUSIDFK = + createInvForeignKey(id, "CURRENTSTATUS_ID"); + + public final com.querydsl.sql.ForeignKey _item_STATUSIDFK = + createInvForeignKey(id, "STATUS_ID"); + + public SStatus_(String variable) { + super(SStatus_.class, forVariable(variable), "null", "status_"); + addMetadata(); + } + + public SStatus_(String variable, String schema, String table) { + super(SStatus_.class, forVariable(variable), schema, table); + addMetadata(); + } + + public SStatus_(String variable, String schema) { + super(SStatus_.class, forVariable(variable), schema, "status_"); + addMetadata(); + } + + public SStatus_(Path path) { + super(path.getType(), path.getMetadata(), "null", "status_"); + addMetadata(); + } + + public SStatus_(PathMetadata metadata) { + super(SStatus_.class, metadata, "null", "status_"); + addMetadata(); + } + + public void addMetadata() { + addMetadata( + id, ColumnMetadata.named("ID").withIndex(1).ofType(Types.BIGINT).withSize(19).notNull()); + addMetadata( + name, ColumnMetadata.named("NAME").withIndex(2).ofType(Types.VARCHAR).withSize(255)); + } +} diff --git a/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SStatuschange_.java b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SStatuschange_.java new file mode 100644 index 0000000000..3c396780e9 --- /dev/null +++ b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SStatuschange_.java @@ -0,0 +1,62 @@ +package com.querydsl.jpa.domain.sql; + +import static com.querydsl.core.types.PathMetadataFactory.*; + +import com.querydsl.core.types.Path; +import com.querydsl.core.types.PathMetadata; +import com.querydsl.core.types.dsl.*; +import com.querydsl.sql.ColumnMetadata; +import java.sql.Types; +import javax.annotation.processing.Generated; + +/** SStatuschange_ is a Querydsl query type for SStatuschange_ */ +@Generated("com.querydsl.sql.codegen.MetaDataSerializer") +public class SStatuschange_ extends com.querydsl.sql.RelationalPathBase { + + private static final long serialVersionUID = 1805594357; + + public static final SStatuschange_ statuschange_ = new SStatuschange_("statuschange_"); + + public final NumberPath id = createNumber("id", Long.class); + + public final DateTimePath timestamp = + createDateTime("timestamp", java.sql.Timestamp.class); + + public final com.querydsl.sql.PrimaryKey primary = createPrimaryKey(id); + + public final com.querydsl.sql.ForeignKey + _item_statuschange_statusChangesIDFK = createInvForeignKey(id, "statusChanges_ID"); + + public SStatuschange_(String variable) { + super(SStatuschange_.class, forVariable(variable), "null", "statuschange_"); + addMetadata(); + } + + public SStatuschange_(String variable, String schema, String table) { + super(SStatuschange_.class, forVariable(variable), schema, table); + addMetadata(); + } + + public SStatuschange_(String variable, String schema) { + super(SStatuschange_.class, forVariable(variable), schema, "statuschange_"); + addMetadata(); + } + + public SStatuschange_(Path path) { + super(path.getType(), path.getMetadata(), "null", "statuschange_"); + addMetadata(); + } + + public SStatuschange_(PathMetadata metadata) { + super(SStatuschange_.class, metadata, "null", "statuschange_"); + addMetadata(); + } + + public void addMetadata() { + addMetadata( + id, ColumnMetadata.named("ID").withIndex(1).ofType(Types.BIGINT).withSize(19).notNull()); + addMetadata( + timestamp, + ColumnMetadata.named("TIMESTAMP").withIndex(2).ofType(Types.TIMESTAMP).withSize(19)); + } +} diff --git a/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SStore_.java b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SStore_.java new file mode 100644 index 0000000000..08b7e0f345 --- /dev/null +++ b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SStore_.java @@ -0,0 +1,64 @@ +package com.querydsl.jpa.domain.sql; + +import static com.querydsl.core.types.PathMetadataFactory.*; + +import com.querydsl.core.types.Path; +import com.querydsl.core.types.PathMetadata; +import com.querydsl.core.types.dsl.*; +import com.querydsl.sql.ColumnMetadata; +import java.sql.Types; +import javax.annotation.processing.Generated; + +/** SStore_ is a Querydsl query type for SStore_ */ +@Generated("com.querydsl.sql.codegen.MetaDataSerializer") +public class SStore_ extends com.querydsl.sql.RelationalPathBase { + + private static final long serialVersionUID = 864365094; + + public static final SStore_ store_ = new SStore_("store_"); + + public final NumberPath id = createNumber("id", Long.class); + + public final NumberPath locationId = createNumber("locationId", Long.class); + + public final com.querydsl.sql.PrimaryKey primary = createPrimaryKey(id); + + public final com.querydsl.sql.ForeignKey store_LOCATIONIDFK = + createForeignKey(locationId, "ID"); + + public final com.querydsl.sql.ForeignKey _store_customer_StoreIDFK = + createInvForeignKey(id, "Store_ID"); + + public SStore_(String variable) { + super(SStore_.class, forVariable(variable), "null", "store_"); + addMetadata(); + } + + public SStore_(String variable, String schema, String table) { + super(SStore_.class, forVariable(variable), schema, table); + addMetadata(); + } + + public SStore_(String variable, String schema) { + super(SStore_.class, forVariable(variable), schema, "store_"); + addMetadata(); + } + + public SStore_(Path path) { + super(path.getType(), path.getMetadata(), "null", "store_"); + addMetadata(); + } + + public SStore_(PathMetadata metadata) { + super(SStore_.class, metadata, "null", "store_"); + addMetadata(); + } + + public void addMetadata() { + addMetadata( + id, ColumnMetadata.named("ID").withIndex(1).ofType(Types.BIGINT).withSize(19).notNull()); + addMetadata( + locationId, + ColumnMetadata.named("LOCATION_ID").withIndex(2).ofType(Types.BIGINT).withSize(19)); + } +} diff --git a/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SStore_customer_.java b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SStore_customer_.java new file mode 100644 index 0000000000..d2869774cb --- /dev/null +++ b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SStore_customer_.java @@ -0,0 +1,70 @@ +package com.querydsl.jpa.domain.sql; + +import static com.querydsl.core.types.PathMetadataFactory.*; + +import com.querydsl.core.types.Path; +import com.querydsl.core.types.PathMetadata; +import com.querydsl.core.types.dsl.*; +import com.querydsl.sql.ColumnMetadata; +import java.sql.Types; +import javax.annotation.processing.Generated; + +/** SStore_customer_ is a Querydsl query type for SStore_customer_ */ +@Generated("com.querydsl.sql.codegen.MetaDataSerializer") +public class SStore_customer_ extends com.querydsl.sql.RelationalPathBase { + + private static final long serialVersionUID = -1583391525; + + public static final SStore_customer_ store_customer_ = new SStore_customer_("store__customer_"); + + public final NumberPath customersID = createNumber("customersID", Integer.class); + + public final NumberPath storeID = createNumber("storeID", Long.class); + + public final com.querydsl.sql.PrimaryKey primary = + createPrimaryKey(storeID, customersID); + + public final com.querydsl.sql.ForeignKey store_customer_StoreIDFK = + createForeignKey(storeID, "ID"); + + public final com.querydsl.sql.ForeignKey store_customer_customersIDFK = + createForeignKey(customersID, "ID"); + + public SStore_customer_(String variable) { + super(SStore_customer_.class, forVariable(variable), "null", "store__customer_"); + addMetadata(); + } + + public SStore_customer_(String variable, String schema, String table) { + super(SStore_customer_.class, forVariable(variable), schema, table); + addMetadata(); + } + + public SStore_customer_(String variable, String schema) { + super(SStore_customer_.class, forVariable(variable), schema, "store__customer_"); + addMetadata(); + } + + public SStore_customer_(Path path) { + super(path.getType(), path.getMetadata(), "null", "store__customer_"); + addMetadata(); + } + + public SStore_customer_(PathMetadata metadata) { + super(SStore_customer_.class, metadata, "null", "store__customer_"); + addMetadata(); + } + + public void addMetadata() { + addMetadata( + customersID, + ColumnMetadata.named("customers_ID") + .withIndex(2) + .ofType(Types.INTEGER) + .withSize(10) + .notNull()); + addMetadata( + storeID, + ColumnMetadata.named("Store_ID").withIndex(1).ofType(Types.BIGINT).withSize(19).notNull()); + } +} diff --git a/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SSurvey.java b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SSurvey.java index 808079a2e1..fe16860be4 100644 --- a/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SSurvey.java +++ b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SSurvey.java @@ -1,19 +1,19 @@ package com.querydsl.jpa.domain.sql; -import static com.querydsl.core.types.PathMetadataFactory.forVariable; +import static com.querydsl.core.types.PathMetadataFactory.*; import com.querydsl.core.types.Path; import com.querydsl.core.types.PathMetadata; -import com.querydsl.core.types.dsl.NumberPath; -import com.querydsl.core.types.dsl.StringPath; +import com.querydsl.core.types.dsl.*; import com.querydsl.sql.ColumnMetadata; -import jakarta.annotation.Generated; +import java.sql.Types; +import javax.annotation.processing.Generated; /** SSurvey is a Querydsl query type for SSurvey */ @Generated("com.querydsl.sql.codegen.MetaDataSerializer") public class SSurvey extends com.querydsl.sql.RelationalPathBase { - private static final long serialVersionUID = 857081739; + private static final long serialVersionUID = 865381858; public static final SSurvey survey = new SSurvey("SURVEY"); @@ -26,7 +26,7 @@ public class SSurvey extends com.querydsl.sql.RelationalPathBase { public final com.querydsl.sql.PrimaryKey primary = createPrimaryKey(id); public SSurvey(String variable) { - super(SSurvey.class, forVariable(variable), "", "SURVEY"); + super(SSurvey.class, forVariable(variable), "null", "SURVEY"); addMetadata(); } @@ -35,19 +35,26 @@ public SSurvey(String variable, String schema, String table) { addMetadata(); } + public SSurvey(String variable, String schema) { + super(SSurvey.class, forVariable(variable), schema, "SURVEY"); + addMetadata(); + } + public SSurvey(Path path) { - super(path.getType(), path.getMetadata(), "", "SURVEY"); + super(path.getType(), path.getMetadata(), "null", "SURVEY"); addMetadata(); } public SSurvey(PathMetadata metadata) { - super(SSurvey.class, metadata, "", "SURVEY"); + super(SSurvey.class, metadata, "null", "SURVEY"); addMetadata(); } public void addMetadata() { - addMetadata(id, ColumnMetadata.named("ID").withIndex(1).ofType(4).withSize(10).notNull()); - addMetadata(name, ColumnMetadata.named("NAME").withIndex(2).ofType(12).withSize(30)); - addMetadata(name2, ColumnMetadata.named("NAME2").withIndex(3).ofType(12).withSize(30)); + addMetadata( + id, ColumnMetadata.named("ID").withIndex(1).ofType(Types.INTEGER).withSize(10).notNull()); + addMetadata(name, ColumnMetadata.named("NAME").withIndex(2).ofType(Types.VARCHAR).withSize(30)); + addMetadata( + name2, ColumnMetadata.named("NAME2").withIndex(3).ofType(Types.VARCHAR).withSize(30)); } } diff --git a/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/STest.java b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/STest.java index 2eac0c30a4..48c400e30e 100644 --- a/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/STest.java +++ b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/STest.java @@ -1,25 +1,26 @@ package com.querydsl.jpa.domain.sql; -import static com.querydsl.core.types.PathMetadataFactory.forVariable; +import static com.querydsl.core.types.PathMetadataFactory.*; import com.querydsl.core.types.Path; import com.querydsl.core.types.PathMetadata; -import com.querydsl.core.types.dsl.StringPath; +import com.querydsl.core.types.dsl.*; import com.querydsl.sql.ColumnMetadata; -import jakarta.annotation.Generated; +import java.sql.Types; +import javax.annotation.processing.Generated; /** STest is a Querydsl query type for STest */ @Generated("com.querydsl.sql.codegen.MetaDataSerializer") public class STest extends com.querydsl.sql.RelationalPathBase { - private static final long serialVersionUID = -1389036285; + private static final long serialVersionUID = 1493650714; public static final STest test = new STest("TEST"); public final StringPath name = createString("name"); public STest(String variable) { - super(STest.class, forVariable(variable), "", "TEST"); + super(STest.class, forVariable(variable), "null", "TEST"); addMetadata(); } @@ -28,17 +29,23 @@ public STest(String variable, String schema, String table) { addMetadata(); } + public STest(String variable, String schema) { + super(STest.class, forVariable(variable), schema, "TEST"); + addMetadata(); + } + public STest(Path path) { - super(path.getType(), path.getMetadata(), "", "TEST"); + super(path.getType(), path.getMetadata(), "null", "TEST"); addMetadata(); } public STest(PathMetadata metadata) { - super(STest.class, metadata, "", "TEST"); + super(STest.class, metadata, "null", "TEST"); addMetadata(); } public void addMetadata() { - addMetadata(name, ColumnMetadata.named("NAME").withIndex(1).ofType(12).withSize(255)); + addMetadata( + name, ColumnMetadata.named("NAME").withIndex(1).ofType(Types.VARCHAR).withSize(255)); } } diff --git a/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/STimeTest.java b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/STimeTest.java index 62a7c2e82b..c2f5e33f53 100644 --- a/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/STimeTest.java +++ b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/STimeTest.java @@ -1,25 +1,26 @@ package com.querydsl.jpa.domain.sql; -import static com.querydsl.core.types.PathMetadataFactory.forVariable; +import static com.querydsl.core.types.PathMetadataFactory.*; import com.querydsl.core.types.Path; import com.querydsl.core.types.PathMetadata; -import com.querydsl.core.types.dsl.TimePath; +import com.querydsl.core.types.dsl.*; import com.querydsl.sql.ColumnMetadata; -import jakarta.annotation.Generated; +import java.sql.Types; +import javax.annotation.processing.Generated; /** STimeTest is a Querydsl query type for STimeTest */ @Generated("com.querydsl.sql.codegen.MetaDataSerializer") public class STimeTest extends com.querydsl.sql.RelationalPathBase { - private static final long serialVersionUID = -1454836496; + private static final long serialVersionUID = -2068356729; public static final STimeTest timeTest1 = new STimeTest("TIME_TEST"); public final TimePath timeTest = createTime("timeTest", java.sql.Time.class); public STimeTest(String variable) { - super(STimeTest.class, forVariable(variable), "", "TIME_TEST"); + super(STimeTest.class, forVariable(variable), "null", "TIME_TEST"); addMetadata(); } @@ -28,17 +29,23 @@ public STimeTest(String variable, String schema, String table) { addMetadata(); } + public STimeTest(String variable, String schema) { + super(STimeTest.class, forVariable(variable), schema, "TIME_TEST"); + addMetadata(); + } + public STimeTest(Path path) { - super(path.getType(), path.getMetadata(), "", "TIME_TEST"); + super(path.getType(), path.getMetadata(), "null", "TIME_TEST"); addMetadata(); } public STimeTest(PathMetadata metadata) { - super(STimeTest.class, metadata, "", "TIME_TEST"); + super(STimeTest.class, metadata, "null", "TIME_TEST"); addMetadata(); } public void addMetadata() { - addMetadata(timeTest, ColumnMetadata.named("TIME_TEST").withIndex(1).ofType(92).withSize(8)); + addMetadata( + timeTest, ColumnMetadata.named("TIME_TEST").withIndex(1).ofType(Types.TIME).withSize(8)); } } diff --git a/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SUser2_.java b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SUser2_.java new file mode 100644 index 0000000000..8012a12703 --- /dev/null +++ b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SUser2_.java @@ -0,0 +1,114 @@ +package com.querydsl.jpa.domain.sql; + +import static com.querydsl.core.types.PathMetadataFactory.*; + +import com.querydsl.core.types.Path; +import com.querydsl.core.types.PathMetadata; +import com.querydsl.core.types.dsl.*; +import com.querydsl.sql.ColumnMetadata; +import java.sql.Types; +import javax.annotation.processing.Generated; + +/** SUser2_ is a Querydsl query type for SUser2_ */ +@Generated("com.querydsl.sql.codegen.MetaDataSerializer") +public class SUser2_ extends com.querydsl.sql.RelationalPathBase { + + private static final long serialVersionUID = 920400384; + + public static final SUser2_ user2_ = new SUser2_("user2_"); + + public final NumberPath createdby = createNumber("createdby", Double.class); + + public final DateTimePath creationdate = + createDateTime("creationdate", java.sql.Timestamp.class); + + public final DateTimePath deletedate = + createDateTime("deletedate", java.sql.Timestamp.class); + + public final NumberPath deletedby = createNumber("deletedby", Double.class); + + public final NumberPath id = createNumber("id", Long.class); + + public final DateTimePath modificationdate = + createDateTime("modificationdate", java.sql.Timestamp.class); + + public final NumberPath modifiedby = createNumber("modifiedby", Double.class); + + public final StringPath useremail = createString("useremail"); + + public final StringPath userfirstname = createString("userfirstname"); + + public final StringPath userlastname = createString("userlastname"); + + public final StringPath username = createString("username"); + + public final StringPath userpassword = createString("userpassword"); + + public final com.querydsl.sql.PrimaryKey primary = createPrimaryKey(id); + + public final com.querydsl.sql.ForeignKey _user2_userprop_User2IDFK = + createInvForeignKey(id, "User2_ID"); + + public SUser2_(String variable) { + super(SUser2_.class, forVariable(variable), "null", "user2_"); + addMetadata(); + } + + public SUser2_(String variable, String schema, String table) { + super(SUser2_.class, forVariable(variable), schema, table); + addMetadata(); + } + + public SUser2_(String variable, String schema) { + super(SUser2_.class, forVariable(variable), schema, "user2_"); + addMetadata(); + } + + public SUser2_(Path path) { + super(path.getType(), path.getMetadata(), "null", "user2_"); + addMetadata(); + } + + public SUser2_(PathMetadata metadata) { + super(SUser2_.class, metadata, "null", "user2_"); + addMetadata(); + } + + public void addMetadata() { + addMetadata( + createdby, + ColumnMetadata.named("CREATEDBY").withIndex(2).ofType(Types.DOUBLE).withSize(22)); + addMetadata( + creationdate, + ColumnMetadata.named("CREATIONDATE").withIndex(3).ofType(Types.TIMESTAMP).withSize(19)); + addMetadata( + deletedate, + ColumnMetadata.named("DELETEDATE").withIndex(4).ofType(Types.TIMESTAMP).withSize(19)); + addMetadata( + deletedby, + ColumnMetadata.named("DELETEDBY").withIndex(5).ofType(Types.DOUBLE).withSize(22)); + addMetadata( + id, ColumnMetadata.named("ID").withIndex(1).ofType(Types.BIGINT).withSize(19).notNull()); + addMetadata( + modificationdate, + ColumnMetadata.named("MODIFICATIONDATE").withIndex(6).ofType(Types.TIMESTAMP).withSize(19)); + addMetadata( + modifiedby, + ColumnMetadata.named("MODIFIEDBY").withIndex(7).ofType(Types.DOUBLE).withSize(22)); + addMetadata( + useremail, + ColumnMetadata.named("USEREMAIL").withIndex(8).ofType(Types.VARCHAR).withSize(255)); + addMetadata( + userfirstname, + ColumnMetadata.named("USERFIRSTNAME").withIndex(9).ofType(Types.VARCHAR).withSize(255)); + addMetadata( + userlastname, + ColumnMetadata.named("USERLASTNAME").withIndex(10).ofType(Types.VARCHAR).withSize(255)); + addMetadata( + username, + ColumnMetadata.named("USERNAME").withIndex(11).ofType(Types.VARCHAR).withSize(255)); + addMetadata( + userpassword, + ColumnMetadata.named("USERPASSWORD").withIndex(12).ofType(Types.VARCHAR).withSize(255)); + } +} diff --git a/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SUser2_userprop_.java b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SUser2_userprop_.java new file mode 100644 index 0000000000..ad934b86b2 --- /dev/null +++ b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SUser2_userprop_.java @@ -0,0 +1,70 @@ +package com.querydsl.jpa.domain.sql; + +import static com.querydsl.core.types.PathMetadataFactory.*; + +import com.querydsl.core.types.Path; +import com.querydsl.core.types.PathMetadata; +import com.querydsl.core.types.dsl.*; +import com.querydsl.sql.ColumnMetadata; +import java.sql.Types; +import javax.annotation.processing.Generated; + +/** SUser2_userprop_ is a Querydsl query type for SUser2_userprop_ */ +@Generated("com.querydsl.sql.codegen.MetaDataSerializer") +public class SUser2_userprop_ extends com.querydsl.sql.RelationalPathBase { + + private static final long serialVersionUID = 770151025; + + public static final SUser2_userprop_ user2_userprop_ = new SUser2_userprop_("user2__userprop_"); + + public final NumberPath propertiesID = createNumber("propertiesID", Long.class); + + public final NumberPath user2ID = createNumber("user2ID", Long.class); + + public final com.querydsl.sql.PrimaryKey primary = + createPrimaryKey(user2ID, propertiesID); + + public final com.querydsl.sql.ForeignKey user2_userprop_User2IDFK = + createForeignKey(user2ID, "ID"); + + public final com.querydsl.sql.ForeignKey user2_userprop_propertiesIDFK = + createForeignKey(propertiesID, "ID"); + + public SUser2_userprop_(String variable) { + super(SUser2_userprop_.class, forVariable(variable), "null", "user2__userprop_"); + addMetadata(); + } + + public SUser2_userprop_(String variable, String schema, String table) { + super(SUser2_userprop_.class, forVariable(variable), schema, table); + addMetadata(); + } + + public SUser2_userprop_(String variable, String schema) { + super(SUser2_userprop_.class, forVariable(variable), schema, "user2__userprop_"); + addMetadata(); + } + + public SUser2_userprop_(Path path) { + super(path.getType(), path.getMetadata(), "null", "user2__userprop_"); + addMetadata(); + } + + public SUser2_userprop_(PathMetadata metadata) { + super(SUser2_userprop_.class, metadata, "null", "user2__userprop_"); + addMetadata(); + } + + public void addMetadata() { + addMetadata( + propertiesID, + ColumnMetadata.named("properties_ID") + .withIndex(2) + .ofType(Types.BIGINT) + .withSize(19) + .notNull()); + addMetadata( + user2ID, + ColumnMetadata.named("User2_ID").withIndex(1).ofType(Types.BIGINT).withSize(19).notNull()); + } +} diff --git a/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SUser_.java b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SUser_.java new file mode 100644 index 0000000000..6711883e15 --- /dev/null +++ b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SUser_.java @@ -0,0 +1,79 @@ +package com.querydsl.jpa.domain.sql; + +import static com.querydsl.core.types.PathMetadataFactory.*; + +import com.querydsl.core.types.Path; +import com.querydsl.core.types.PathMetadata; +import com.querydsl.core.types.dsl.*; +import com.querydsl.sql.ColumnMetadata; +import java.sql.Types; +import javax.annotation.processing.Generated; + +/** SUser_ is a Querydsl query type for SUser_ */ +@Generated("com.querydsl.sql.codegen.MetaDataSerializer") +public class SUser_ extends com.querydsl.sql.RelationalPathBase { + + private static final long serialVersionUID = -940140948; + + public static final SUser_ user_ = new SUser_("user_"); + + public final NumberPath companyId = createNumber("companyId", Integer.class); + + public final StringPath firstname = createString("firstname"); + + public final NumberPath id = createNumber("id", Long.class); + + public final StringPath lastname = createString("lastname"); + + public final StringPath username = createString("username"); + + public final com.querydsl.sql.PrimaryKey primary = createPrimaryKey(id); + + public final com.querydsl.sql.ForeignKey user_COMPANYIDFK = + createForeignKey(companyId, "ID"); + + public final com.querydsl.sql.ForeignKey _employee_USERIDFK = + createInvForeignKey(id, "USER_ID"); + + public SUser_(String variable) { + super(SUser_.class, forVariable(variable), "null", "user_"); + addMetadata(); + } + + public SUser_(String variable, String schema, String table) { + super(SUser_.class, forVariable(variable), schema, table); + addMetadata(); + } + + public SUser_(String variable, String schema) { + super(SUser_.class, forVariable(variable), schema, "user_"); + addMetadata(); + } + + public SUser_(Path path) { + super(path.getType(), path.getMetadata(), "null", "user_"); + addMetadata(); + } + + public SUser_(PathMetadata metadata) { + super(SUser_.class, metadata, "null", "user_"); + addMetadata(); + } + + public void addMetadata() { + addMetadata( + companyId, + ColumnMetadata.named("COMPANY_ID").withIndex(5).ofType(Types.INTEGER).withSize(10)); + addMetadata( + firstname, + ColumnMetadata.named("FIRSTNAME").withIndex(2).ofType(Types.VARCHAR).withSize(255)); + addMetadata( + id, ColumnMetadata.named("ID").withIndex(1).ofType(Types.BIGINT).withSize(19).notNull()); + addMetadata( + lastname, + ColumnMetadata.named("LASTNAME").withIndex(3).ofType(Types.VARCHAR).withSize(255)); + addMetadata( + username, + ColumnMetadata.named("USERNAME").withIndex(4).ofType(Types.VARCHAR).withSize(255)); + } +} diff --git a/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SUserprop_.java b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SUserprop_.java new file mode 100644 index 0000000000..952ce1bd2b --- /dev/null +++ b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SUserprop_.java @@ -0,0 +1,108 @@ +package com.querydsl.jpa.domain.sql; + +import static com.querydsl.core.types.PathMetadataFactory.*; + +import com.querydsl.core.types.Path; +import com.querydsl.core.types.PathMetadata; +import com.querydsl.core.types.dsl.*; +import com.querydsl.sql.ColumnMetadata; +import java.sql.Types; +import javax.annotation.processing.Generated; + +/** SUserprop_ is a Querydsl query type for SUserprop_ */ +@Generated("com.querydsl.sql.codegen.MetaDataSerializer") +public class SUserprop_ extends com.querydsl.sql.RelationalPathBase { + + private static final long serialVersionUID = 634556649; + + public static final SUserprop_ userprop_ = new SUserprop_("userprop_"); + + public final StringPath categorydescription = createString("categorydescription"); + + public final StringPath categoryname = createString("categoryname"); + + public final NumberPath createdby = createNumber("createdby", Double.class); + + public final DateTimePath creationdate = + createDateTime("creationdate", java.sql.Timestamp.class); + + public final DateTimePath deletedate = + createDateTime("deletedate", java.sql.Timestamp.class); + + public final NumberPath deletedby = createNumber("deletedby", Double.class); + + public final NumberPath id = createNumber("id", Long.class); + + public final DateTimePath modificationdate = + createDateTime("modificationdate", java.sql.Timestamp.class); + + public final NumberPath modifiedby = createNumber("modifiedby", Double.class); + + public final com.querydsl.sql.PrimaryKey primary = createPrimaryKey(id); + + public final com.querydsl.sql.ForeignKey _user2_userprop_propertiesIDFK = + createInvForeignKey(id, "properties_ID"); + + public final com.querydsl.sql.ForeignKey _userprop_category_UserPropIDFK = + createInvForeignKey(id, "UserProp_ID"); + + public final com.querydsl.sql.ForeignKey + _userprop_categoryprop_UserPropIDFK = createInvForeignKey(id, "UserProp_ID"); + + public SUserprop_(String variable) { + super(SUserprop_.class, forVariable(variable), "null", "userprop_"); + addMetadata(); + } + + public SUserprop_(String variable, String schema, String table) { + super(SUserprop_.class, forVariable(variable), schema, table); + addMetadata(); + } + + public SUserprop_(String variable, String schema) { + super(SUserprop_.class, forVariable(variable), schema, "userprop_"); + addMetadata(); + } + + public SUserprop_(Path path) { + super(path.getType(), path.getMetadata(), "null", "userprop_"); + addMetadata(); + } + + public SUserprop_(PathMetadata metadata) { + super(SUserprop_.class, metadata, "null", "userprop_"); + addMetadata(); + } + + public void addMetadata() { + addMetadata( + categorydescription, + ColumnMetadata.named("CATEGORYDESCRIPTION") + .withIndex(2) + .ofType(Types.VARCHAR) + .withSize(255)); + addMetadata( + categoryname, + ColumnMetadata.named("CATEGORYNAME").withIndex(3).ofType(Types.VARCHAR).withSize(255)); + addMetadata( + createdby, + ColumnMetadata.named("CREATEDBY").withIndex(4).ofType(Types.DOUBLE).withSize(22)); + addMetadata( + creationdate, + ColumnMetadata.named("CREATIONDATE").withIndex(5).ofType(Types.TIMESTAMP).withSize(19)); + addMetadata( + deletedate, + ColumnMetadata.named("DELETEDATE").withIndex(6).ofType(Types.TIMESTAMP).withSize(19)); + addMetadata( + deletedby, + ColumnMetadata.named("DELETEDBY").withIndex(7).ofType(Types.DOUBLE).withSize(22)); + addMetadata( + id, ColumnMetadata.named("ID").withIndex(1).ofType(Types.BIGINT).withSize(19).notNull()); + addMetadata( + modificationdate, + ColumnMetadata.named("MODIFICATIONDATE").withIndex(8).ofType(Types.TIMESTAMP).withSize(19)); + addMetadata( + modifiedby, + ColumnMetadata.named("MODIFIEDBY").withIndex(9).ofType(Types.DOUBLE).withSize(22)); + } +} diff --git a/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SUserprop_category_.java b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SUserprop_category_.java new file mode 100644 index 0000000000..805a6de19f --- /dev/null +++ b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SUserprop_category_.java @@ -0,0 +1,75 @@ +package com.querydsl.jpa.domain.sql; + +import static com.querydsl.core.types.PathMetadataFactory.*; + +import com.querydsl.core.types.Path; +import com.querydsl.core.types.PathMetadata; +import com.querydsl.core.types.dsl.*; +import com.querydsl.sql.ColumnMetadata; +import java.sql.Types; +import javax.annotation.processing.Generated; + +/** SUserprop_category_ is a Querydsl query type for SUserprop_category_ */ +@Generated("com.querydsl.sql.codegen.MetaDataSerializer") +public class SUserprop_category_ extends com.querydsl.sql.RelationalPathBase { + + private static final long serialVersionUID = 1245464664; + + public static final SUserprop_category_ userprop_category_ = + new SUserprop_category_("userprop__category_"); + + public final NumberPath childCategoriesID = createNumber("childCategoriesID", Long.class); + + public final NumberPath userPropID = createNumber("userPropID", Long.class); + + public final com.querydsl.sql.PrimaryKey primary = + createPrimaryKey(userPropID, childCategoriesID); + + public final com.querydsl.sql.ForeignKey userprop_category_UserPropIDFK = + createForeignKey(userPropID, "ID"); + + public final com.querydsl.sql.ForeignKey userprop_category_childCategoriesIDFK = + createForeignKey(childCategoriesID, "ID"); + + public SUserprop_category_(String variable) { + super(SUserprop_category_.class, forVariable(variable), "null", "userprop__category_"); + addMetadata(); + } + + public SUserprop_category_(String variable, String schema, String table) { + super(SUserprop_category_.class, forVariable(variable), schema, table); + addMetadata(); + } + + public SUserprop_category_(String variable, String schema) { + super(SUserprop_category_.class, forVariable(variable), schema, "userprop__category_"); + addMetadata(); + } + + public SUserprop_category_(Path path) { + super(path.getType(), path.getMetadata(), "null", "userprop__category_"); + addMetadata(); + } + + public SUserprop_category_(PathMetadata metadata) { + super(SUserprop_category_.class, metadata, "null", "userprop__category_"); + addMetadata(); + } + + public void addMetadata() { + addMetadata( + childCategoriesID, + ColumnMetadata.named("childCategories_ID") + .withIndex(2) + .ofType(Types.BIGINT) + .withSize(19) + .notNull()); + addMetadata( + userPropID, + ColumnMetadata.named("UserProp_ID") + .withIndex(1) + .ofType(Types.BIGINT) + .withSize(19) + .notNull()); + } +} diff --git a/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SUserprop_categoryprop_.java b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SUserprop_categoryprop_.java new file mode 100644 index 0000000000..8fe83ab1a1 --- /dev/null +++ b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SUserprop_categoryprop_.java @@ -0,0 +1,76 @@ +package com.querydsl.jpa.domain.sql; + +import static com.querydsl.core.types.PathMetadataFactory.*; + +import com.querydsl.core.types.Path; +import com.querydsl.core.types.PathMetadata; +import com.querydsl.core.types.dsl.*; +import com.querydsl.sql.ColumnMetadata; +import java.sql.Types; +import javax.annotation.processing.Generated; + +/** SUserprop_categoryprop_ is a Querydsl query type for SUserprop_categoryprop_ */ +@Generated("com.querydsl.sql.codegen.MetaDataSerializer") +public class SUserprop_categoryprop_ + extends com.querydsl.sql.RelationalPathBase { + + private static final long serialVersionUID = -925537067; + + public static final SUserprop_categoryprop_ userprop_categoryprop_ = + new SUserprop_categoryprop_("userprop__categoryprop_"); + + public final NumberPath propertiesID = createNumber("propertiesID", Long.class); + + public final NumberPath userPropID = createNumber("userPropID", Long.class); + + public final com.querydsl.sql.PrimaryKey primary = + createPrimaryKey(userPropID, propertiesID); + + public final com.querydsl.sql.ForeignKey userprop_categoryprop_UserPropIDFK = + createForeignKey(userPropID, "ID"); + + public final com.querydsl.sql.ForeignKey userprop_categoryprop_propertiesIDFK = + createForeignKey(propertiesID, "ID"); + + public SUserprop_categoryprop_(String variable) { + super(SUserprop_categoryprop_.class, forVariable(variable), "null", "userprop__categoryprop_"); + addMetadata(); + } + + public SUserprop_categoryprop_(String variable, String schema, String table) { + super(SUserprop_categoryprop_.class, forVariable(variable), schema, table); + addMetadata(); + } + + public SUserprop_categoryprop_(String variable, String schema) { + super(SUserprop_categoryprop_.class, forVariable(variable), schema, "userprop__categoryprop_"); + addMetadata(); + } + + public SUserprop_categoryprop_(Path path) { + super(path.getType(), path.getMetadata(), "null", "userprop__categoryprop_"); + addMetadata(); + } + + public SUserprop_categoryprop_(PathMetadata metadata) { + super(SUserprop_categoryprop_.class, metadata, "null", "userprop__categoryprop_"); + addMetadata(); + } + + public void addMetadata() { + addMetadata( + propertiesID, + ColumnMetadata.named("properties_ID") + .withIndex(2) + .ofType(Types.BIGINT) + .withSize(19) + .notNull()); + addMetadata( + userPropID, + ColumnMetadata.named("UserProp_ID") + .withIndex(1) + .ofType(Types.BIGINT) + .withSize(19) + .notNull()); + } +} diff --git a/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SWorld.java b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SWorld.java index 0ce5138a4d..153d6a89f2 100644 --- a/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SWorld.java +++ b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SWorld.java @@ -1,30 +1,31 @@ package com.querydsl.jpa.domain.sql; -import static com.querydsl.core.types.PathMetadataFactory.forVariable; +import static com.querydsl.core.types.PathMetadataFactory.*; import com.querydsl.core.types.Path; import com.querydsl.core.types.PathMetadata; -import com.querydsl.core.types.dsl.NumberPath; +import com.querydsl.core.types.dsl.*; import com.querydsl.sql.ColumnMetadata; -import jakarta.annotation.Generated; +import java.sql.Types; +import javax.annotation.processing.Generated; /** SWorld is a Querydsl query type for SWorld */ @Generated("com.querydsl.sql.codegen.MetaDataSerializer") public class SWorld extends com.querydsl.sql.RelationalPathBase { - private static final long serialVersionUID = -107384511; + private static final long serialVersionUID = -938400758; - public static final SWorld World = new SWorld("World"); + public static final SWorld world = new SWorld("WORLD"); public final NumberPath id = createNumber("id", Long.class); public final com.querydsl.sql.PrimaryKey primary = createPrimaryKey(id); - public final com.querydsl.sql.ForeignKey _fk4070aeecd3538cf8 = - createInvForeignKey(id, "World_id"); + public final com.querydsl.sql.ForeignKey _wORLDMAMMALWorldIDFK = + createInvForeignKey(id, "World_ID"); public SWorld(String variable) { - super(SWorld.class, forVariable(variable), "", "World"); + super(SWorld.class, forVariable(variable), "null", "WORLD"); addMetadata(); } @@ -33,17 +34,23 @@ public SWorld(String variable, String schema, String table) { addMetadata(); } + public SWorld(String variable, String schema) { + super(SWorld.class, forVariable(variable), schema, "WORLD"); + addMetadata(); + } + public SWorld(Path path) { - super(path.getType(), path.getMetadata(), "", "World"); + super(path.getType(), path.getMetadata(), "null", "WORLD"); addMetadata(); } public SWorld(PathMetadata metadata) { - super(SWorld.class, metadata, "", "World"); + super(SWorld.class, metadata, "null", "WORLD"); addMetadata(); } public void addMetadata() { - addMetadata(id, ColumnMetadata.named("id").withIndex(1).ofType(-5).withSize(19).notNull()); + addMetadata( + id, ColumnMetadata.named("ID").withIndex(1).ofType(Types.BIGINT).withSize(19).notNull()); } } diff --git a/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SWorldMammal.java b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SWorldMammal.java index 57919684f5..1dc0536c76 100644 --- a/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SWorldMammal.java +++ b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SWorldMammal.java @@ -1,36 +1,37 @@ package com.querydsl.jpa.domain.sql; -import static com.querydsl.core.types.PathMetadataFactory.forVariable; +import static com.querydsl.core.types.PathMetadataFactory.*; import com.querydsl.core.types.Path; import com.querydsl.core.types.PathMetadata; -import com.querydsl.core.types.dsl.NumberPath; +import com.querydsl.core.types.dsl.*; import com.querydsl.sql.ColumnMetadata; -import jakarta.annotation.Generated; +import java.sql.Types; +import javax.annotation.processing.Generated; /** SWorldMammal is a Querydsl query type for SWorldMammal */ @Generated("com.querydsl.sql.codegen.MetaDataSerializer") public class SWorldMammal extends com.querydsl.sql.RelationalPathBase { - private static final long serialVersionUID = 979697152; + private static final long serialVersionUID = -1315719671; - public static final SWorldMammal WorldMammal = new SWorldMammal("World_Mammal"); + public static final SWorldMammal worldMammal = new SWorldMammal("WORLD_MAMMAL"); - public final NumberPath mammalsId = createNumber("mammalsId", Long.class); + public final NumberPath mammalsID = createNumber("mammalsID", Long.class); - public final NumberPath worldId = createNumber("worldId", Long.class); + public final NumberPath worldID = createNumber("worldID", Long.class); public final com.querydsl.sql.PrimaryKey primary = - createPrimaryKey(worldId, mammalsId); + createPrimaryKey(worldID, mammalsID); - public final com.querydsl.sql.ForeignKey fk4070aeece01c8ee7 = - createForeignKey(mammalsId, "id"); + public final com.querydsl.sql.ForeignKey wORLDMAMMALWorldIDFK = + createForeignKey(worldID, "ID"); - public final com.querydsl.sql.ForeignKey fk4070aeecd3538cf8 = - createForeignKey(worldId, "id"); + public final com.querydsl.sql.ForeignKey wORLDMAMMALMammalsIDFK = + createForeignKey(mammalsID, "ID"); public SWorldMammal(String variable) { - super(SWorldMammal.class, forVariable(variable), "", "World_Mammal"); + super(SWorldMammal.class, forVariable(variable), "null", "WORLD_MAMMAL"); addMetadata(); } @@ -39,21 +40,31 @@ public SWorldMammal(String variable, String schema, String table) { addMetadata(); } + public SWorldMammal(String variable, String schema) { + super(SWorldMammal.class, forVariable(variable), schema, "WORLD_MAMMAL"); + addMetadata(); + } + public SWorldMammal(Path path) { - super(path.getType(), path.getMetadata(), "", "World_Mammal"); + super(path.getType(), path.getMetadata(), "null", "WORLD_MAMMAL"); addMetadata(); } public SWorldMammal(PathMetadata metadata) { - super(SWorldMammal.class, metadata, "", "World_Mammal"); + super(SWorldMammal.class, metadata, "null", "WORLD_MAMMAL"); addMetadata(); } public void addMetadata() { addMetadata( - mammalsId, - ColumnMetadata.named("mammals_id").withIndex(2).ofType(-5).withSize(19).notNull()); + mammalsID, + ColumnMetadata.named("mammals_ID") + .withIndex(2) + .ofType(Types.BIGINT) + .withSize(19) + .notNull()); addMetadata( - worldId, ColumnMetadata.named("World_id").withIndex(1).ofType(-5).withSize(19).notNull()); + worldID, + ColumnMetadata.named("World_ID").withIndex(1).ofType(Types.BIGINT).withSize(19).notNull()); } } diff --git a/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SXmlTest.java b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SXmlTest.java new file mode 100644 index 0000000000..00ab429548 --- /dev/null +++ b/querydsl-jpa/src/test/java/com/querydsl/jpa/domain/sql/SXmlTest.java @@ -0,0 +1,50 @@ +package com.querydsl.jpa.domain.sql; + +import static com.querydsl.core.types.PathMetadataFactory.*; + +import com.querydsl.core.types.Path; +import com.querydsl.core.types.PathMetadata; +import com.querydsl.core.types.dsl.*; +import com.querydsl.sql.ColumnMetadata; +import java.sql.Types; +import javax.annotation.processing.Generated; + +/** SXmlTest is a Querydsl query type for SXmlTest */ +@Generated("com.querydsl.sql.codegen.MetaDataSerializer") +public class SXmlTest extends com.querydsl.sql.RelationalPathBase { + + private static final long serialVersionUID = 963997633; + + public static final SXmlTest xmlTest = new SXmlTest("XML_TEST"); + + public final StringPath col = createString("col"); + + public SXmlTest(String variable) { + super(SXmlTest.class, forVariable(variable), "null", "XML_TEST"); + addMetadata(); + } + + public SXmlTest(String variable, String schema, String table) { + super(SXmlTest.class, forVariable(variable), schema, table); + addMetadata(); + } + + public SXmlTest(String variable, String schema) { + super(SXmlTest.class, forVariable(variable), schema, "XML_TEST"); + addMetadata(); + } + + public SXmlTest(Path path) { + super(path.getType(), path.getMetadata(), "null", "XML_TEST"); + addMetadata(); + } + + public SXmlTest(PathMetadata metadata) { + super(SXmlTest.class, metadata, "null", "XML_TEST"); + addMetadata(); + } + + public void addMetadata() { + addMetadata(col, ColumnMetadata.named("COL").withIndex(1).ofType(Types.VARCHAR).withSize(128)); + } +}