CodeCow/querydsl
1
0
Fork 0
mirror of https://github.com/querydsl/querydsl.git synced 2026-07-03 21:07:49 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

Merge pull request #1242 from querydsl/scala-fixes

Browse Source 
Improve Scala usage
This commit is contained in:
Timo Westkämper 2015-03-14 16:59:06 +02:00
commit a2b53703a6
28 changed files with 309 additions and 334 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
querydsl-scala/pom.xml
View File

@ -18,7 +18,7 @@
<character.encoding>UTF-8</character.encoding>
<scala.version>2.10</scala.version>
<scala.full.version>2.10.4</scala.full.version>
<scala.full.version>2.10.5</scala.full.version>
<hibernate.version>3.5.1-Final</hibernate.version>
<hibernate.validator.version>4.0.2.GA</hibernate.validator.version>
</properties>
@ -203,7 +203,8 @@
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-surefire-plugin</artifactId>
<configuration>
<argLine>-Xms256m -Xmx512m -Xss2m</argLine>
<argLine>-Xms256m -Xmx512m -Xss2m</argLine>
<printSummary>true</printSummary>
</configuration>
</plugin>

2
querydsl-scala/src/main/scala/com/querydsl/scala/Expressions.scala
View File

@ -21,7 +21,7 @@ import com.querydsl.core.types.PathMetadataFactory._
import com.querydsl.core.types.Ops._
import java.util.Collection
import java.util.Arrays._;
import java.util.Arrays._
import Constants._
import Operations._

2
querydsl-scala/src/main/scala/com/querydsl/scala/ManifestUtils.scala
View File

@ -20,6 +20,6 @@ package com.querydsl.scala
*/
object ManifestUtils {
implicit def toClass[X](mf: Manifest[X]) = mf.runtimeClass.asInstanceOf[Class[X]]
implicit def toClass[X](mf: Manifest[X]): Class[X] = mf.runtimeClass.asInstanceOf[Class[X]]
}

2
querydsl-scala/src/main/scala/com/querydsl/scala/Projections.scala
View File

@ -374,7 +374,7 @@ abstract class FactoryExpressionBase[T](cl: Class[T], args: Ex[_]*)
def accept[R,C](v: Visitor[R,C], context: C): R = v.visit(this, context)
def getArgs(): java.util.List[Ex[_]] = Arrays.asList(args:_*)
def getArgs: java.util.List[Ex[_]] = Arrays.asList(args:_*)
def apply(i: Int): Ex[_] = args(i)

16
querydsl-scala/src/main/scala/com/querydsl/scala/BeanSerializer.scala → querydsl-scala/src/main/scala/com/querydsl/scala/ScalaBeanSerializer.scala
View File

@ -24,7 +24,7 @@ import javax.inject.Inject
import java.util._
import java.io.IOException
import scala.reflect.BeanProperty
import scala.beans.BeanProperty
import scala.collection.JavaConversions._
import scala.collection.mutable.Set
@ -47,9 +47,9 @@ object Serializer {
*/
def writeImports(model: EntityType, javaBeanSupport: Boolean, writer: ScalaWriter) {
val importedClasses = getAnnotationTypes(model)
if (javaBeanSupport) importedClasses.add("scala.reflect.BeanProperty")
if (model.hasLists()) importedClasses.add(classOf[List[_]].getName)
if (model.hasMaps()) importedClasses.add(classOf[Map[_, _]].getName)
if (javaBeanSupport) importedClasses.add("scala.beans.BeanProperty")
if (model.hasLists) importedClasses.add(classOf[List[_]].getName)
if (model.hasMaps) importedClasses.add(classOf[Map[_, _]].getName)
writer.importClasses(importedClasses.toArray: _*)
}
@ -105,12 +105,12 @@ class ScalaBeanSerializer @Inject() (typeMappings: TypeMappings) extends Seriali
def writeClass(model: EntityType, writer: ScalaWriter) = {
writer.javadoc(model.getSimpleName + javadocSuffix)
model.getAnnotations foreach(writer.annotation(_))
model.getAnnotations foreach(writer.annotation)
writer.beginClass(model)
for (property <- model.getProperties) {
property.getAnnotations.foreach(writer.annotation(_))
property.getAnnotations.foreach(writer.annotation)
if (javaBeanSupport) writer.line("@BeanProperty")
writer.publicField(property.getType(), property.getEscapedName, "_")
writer.publicField(property.getType, property.getEscapedName, "_")
}
writer.end()
}
@ -139,7 +139,7 @@ class CaseClassSerializer @Inject() (typeMappings: TypeMappings) extends Seriali
}
def writeClass(model: EntityType, writer: ScalaWriter) = {
model.getAnnotations foreach (writer.annotation(_))
model.getAnnotations foreach writer.annotation
val parameters = model.getProperties
.map(p => new Parameter(p.getEscapedName, p.getType)).toArray
writer.caseClass(model.getSimpleName, parameters:_*)

12
querydsl-scala/src/main/scala/com/querydsl/scala/EntitySerializer.scala → querydsl-scala/src/main/scala/com/querydsl/scala/ScalaEntitySerializer.scala
View File

@ -26,7 +26,7 @@ import com.querydsl.sql.codegen.support._
import com.querydsl.core.types._
import java.util._
import java.io.IOException
import scala.reflect.BeanProperty
import scala.beans.BeanProperty
import scala.collection.JavaConversions._
import scala.collection.mutable.Set
import scala.collection.immutable.Map
@ -57,15 +57,15 @@ class ScalaEntitySerializer @Inject()(val typeMappings: TypeMappings) extends Se
val simpleName: String = model.getSimpleName
// package
if (!model.getPackageName.isEmpty()) writer.packageDecl(model.getPackageName)
if (!model.getPackageName.isEmpty) writer.packageDecl(model.getPackageName)
// imports
writer.importPackages("com.querydsl.core.types","com.querydsl.scala")
writer.staticimports(classOf[PathMetadataFactory])
var importedClasses = getAnnotationTypes(model)
if (model.hasLists()) importedClasses.add(classOf[java.util.List[_]].getName)
if (model.hasMaps()) importedClasses.add(classOf[java.util.Map[_, _]].getName)
if (model.hasLists) importedClasses.add(classOf[java.util.List[_]].getName)
if (model.hasMaps) importedClasses.add(classOf[java.util.Map[_, _]].getName)
writer.importClasses(importedClasses.toArray: _*)
writeHeader(model, scalaWriter)
@ -121,7 +121,7 @@ class ScalaEntitySerializer @Inject()(val typeMappings: TypeMappings) extends Se
}
def writeAnnotations(model: EntityType, queryType: Type, writer: ScalaWriter) = {
model.getAnnotations.foreach(writer.annotation(_))
model.getAnnotations.foreach(writer.annotation)
}
def writeAdditionalCompanionContent(model: EntityType, writer: ScalaWriter) = {}
@ -194,7 +194,7 @@ class ScalaEntitySerializer @Inject()(val typeMappings: TypeMappings) extends Se
}
def getAnnotationTypes(model: EntityType): Set[String] = {
Set() ++ (model.getAnnotations.map(_.annotationType.getName))
Set() ++ model.getAnnotations.map(_.annotationType.getName)
}
private def getRaw(t : Type): Type = {

2
querydsl-scala/src/main/scala/com/querydsl/scala/TypeMappings.scala → querydsl-scala/src/main/scala/com/querydsl/scala/ScalaTypeMappings.scala
View File

@ -27,7 +27,7 @@ import com.querydsl.core.types.Path
*/
object ScalaTypeMappings {
def create: TypeMappings = new ScalaTypeMappings();
def create: TypeMappings = new ScalaTypeMappings()
}

2
querydsl-scala/src/main/scala/com/querydsl/scala/sql/Paths.scala → querydsl-scala/src/main/scala/com/querydsl/scala/sql/RelationalPathImpl.scala
View File

@ -24,7 +24,7 @@ import com.querydsl.core.types._
import com.querydsl.core.types.PathMetadataFactory._
import java.util.{List => JavaList, ArrayList, Map => JavaMap, HashMap}
import java.lang.reflect._
import scala.reflect.BeanProperty
import scala.beans.BeanProperty
/**
* Implementation of RelationalPath for Scala

12
querydsl-scala/src/main/scala/com/querydsl/scala/sql/Serializers.scala → querydsl-scala/src/main/scala/com/querydsl/scala/sql/ScalaMetaDataSerializer.scala
View File

@ -88,10 +88,10 @@ class ScalaMetaDataSerializer @Inject() (typeMappings: TypeMappings, val namingS
columnMeta.append(".named(\"" + metadata.getName + "\")")
columnMeta.append(".ofType(" + metadata.getJdbcType + ")")
if (metadata.hasSize) {
columnMeta.append(".withSize(" + metadata.getSize() + ")")
columnMeta.append(".withSize(" + metadata.getSize + ")")
}
if (metadata.getDigits > 0) {
columnMeta.append(".withDigits(" + metadata.getDigits() + ")")
columnMeta.append(".withDigits(" + metadata.getDigits + ")")
}
if (!metadata.isNullable) {
columnMeta.append(".notNull()")
@ -102,13 +102,13 @@ class ScalaMetaDataSerializer @Inject() (typeMappings: TypeMappings, val namingS
override def writeAnnotations(model: EntityType, queryType: Type, writer: ScalaWriter) = {
if (model == queryType) {
model.getAnnotations.foreach(writer.annotation(_))
model.getAnnotations.foreach(writer.annotation)
}
}
def serializePrimaryKeys(model: EntityType, writer: CodeWriter, primaryKeys: Collection[PrimaryKeyData]) {
primaryKeys.foreach { pk =>
val fieldName = namingStrategy.getPropertyNameForPrimaryKey(pk.getName(), model)
val fieldName = namingStrategy.getPropertyNameForPrimaryKey(pk.getName, model)
val value = pk.getColumns.map(c => escape(namingStrategy.getPropertyName(c, model)))
.mkString("createPrimaryKey(", ", ", ")")
writer.publicFinal(new ClassType(classOf[PrimaryKey[_]], model), fieldName, value)
@ -126,7 +126,7 @@ class ScalaMetaDataSerializer @Inject() (typeMappings: TypeMappings, val namingS
val value = new StringBuilder(if (inverse) "createInvForeignKey(" else "createForeignKey(")
if (fk.getForeignColumns.size == 1) {
value.append(namingStrategy.getPropertyName(fk.getForeignColumns.get(0), model))
value.append(", \"" + fk.getParentColumns().get(0) + "\"")
value.append(", \"" + fk.getParentColumns.get(0) + "\"")
} else {
val local = fk.getForeignColumns.map(c => escape(namingStrategy.getPropertyName(c, model))).mkString(", ")
val foreign = fk.getParentColumns.map("\"" + _ + "\"").mkString(", ")
@ -134,7 +134,7 @@ class ScalaMetaDataSerializer @Inject() (typeMappings: TypeMappings, val namingS
}
value.append(")")
val t = new ClassType(classOf[ForeignKey[_]], fk.getType)
writer.publicFinal(t, fieldName, value.toString())
writer.publicFinal(t, fieldName, value.toString)
}
}

14
querydsl-scala/src/test/scala/com/querydsl/scala/CaseClassSerializerTest.scala
View File

@ -1,17 +1,17 @@
package com.querydsl.scala
import com.mysema.codegen._;
import com.mysema.codegen.model._;
import com.querydsl.codegen._;
import com.mysema.codegen._
import com.mysema.codegen.model._
import com.querydsl.codegen._
import java.io.StringWriter;
import java.io.StringWriter
import org.junit._
import org.junit.Assert._
import scala.collection.JavaConversions._
class CaseClassSerializerTest extends CompileTestUtils {
class CaseClassSerializerTest {
val typeMappings = ScalaTypeMappings.create
@ -34,9 +34,9 @@ class CaseClassSerializerTest extends CompileTestUtils {
serializer.createCompanionObject = false
typeMappings.register(entityType, new QueryTypeFactoryImpl("Q", "", "").create(entityType))
serializer.serialize(entityType, SimpleSerializerConfig.DEFAULT, new ScalaWriter(writer))
val str = writer.toString()
val str = writer.toString
assertCompileSuccess(str)
CompileTestUtils.assertCompileSuccess(str)
}
}

55
querydsl-scala/src/test/scala/com/querydsl/scala/CompileTestUtils.scala
View File

@ -2,52 +2,59 @@ package com.querydsl.scala
import java.io.File._
import com.google.common.base.Charsets
import com.google.common.io.Files
import scala.tools.nsc._
import scala.tools.nsc.interpreter.IR.Success
import scala.io.Source.fromFile
import java.io.File
import java.io.File.pathSeparator
trait CompileTestUtils {
import scala.tools.nsc.reporters.{ConsoleReporter, Reporter}
private object env extends Settings {
object CompileTestUtils {
private def jarPathOfClass(className: String) = {
Class.forName(className).getProtectionDomain.getCodeSource.getLocation
}
private def jarPathOfClass(className: String) = {
Class.forName(className).getProtectionDomain.getCodeSource.getLocation
}
val currentLibraries = (this.getClass.getClassLoader).asInstanceOf[java.net.URLClassLoader].getURLs().toList
val cp = jarPathOfClass("scala.tools.nsc.Interpreter") :: jarPathOfClass("scala.ScalaObject") :: currentLibraries
private val currentLibraries = this.getClass.getClassLoader.asInstanceOf[java.net.URLClassLoader].getURLs.toList
private val cp = jarPathOfClass("scala.tools.nsc.Interpreter") :: jarPathOfClass("scala.ScalaObject") :: currentLibraries
classpath.value = cp.mkString(pathSeparator)
usejavacp.value = true
private val env = new Settings()
env.classpath.value = cp.mkString(pathSeparator)
env.usejavacp.value = true
//env.d.value = "target"
env.stopAfter.value = List("refchecks")
def assertCompileSuccess(file: File): Unit = {
assertCompileSuccess(recursiveFileList(file))
}
def assertCompileSuccess(files: Traversable[File]): Unit = {
assertCompileSuccess(files
map (fromFile(_).mkString)
mkString ("\n"))
val reporter = new ConsoleReporter(env)
val g = new Global(env, reporter)
val run = new g.Run
run.compile(files.map(_.getPath).toList)
if (reporter.hasErrors) {
throw new AssertionError("Compilation failed")
}
}
def assertCompileSuccess(source: String): Unit = {
val out = new java.io.ByteArrayOutputStream
val interpreterWriter = new java.io.PrintWriter(out)
val interpreter = new scala.tools.nsc.interpreter.IMain(env, interpreterWriter)
val file = File.createTempFile("source", ".scala")
try {
val result = interpreter.interpret(source.replaceAll("package [\\w\\.]+", ""))
if (result != Success) {
throw new AssertionError("Compile failed, interpreter output:\n" + out.toString("utf-8"))
}
Files.write(source, file, Charsets.UTF_8)
assertCompileSuccess(file)
} finally {
interpreterWriter.close
interpreter.close
file.delete()
}
}
def recursiveFileList(file: File): Array[File] = {
private def recursiveFileList(file: File): Array[File] = {
if (file.isDirectory) {
file.listFiles.flatMap(recursiveFileList(_))
file.listFiles.flatMap(recursiveFileList)
} else {
Array(file)
}

6
querydsl-scala/src/test/scala/com/querydsl/scala/ExampleDomain.scala
View File

@ -1,7 +1,7 @@
package com.querydsl.scala;
package com.querydsl.scala
import com.querydsl.core.types._;
import com.querydsl.core.types.PathMetadataFactory._;
import com.querydsl.core.types._
import com.querydsl.core.types.PathMetadataFactory._
class Person {
var scalaInt: Int = _

8
querydsl-scala/src/test/scala/com/querydsl/scala/ExpressionTest.scala
View File

@ -1,8 +1,8 @@
package com.querydsl.scala;
package com.querydsl.scala
import com.querydsl.core.types._;
import com.querydsl.core.types._
import org.junit.{ Test, Before, After, Assert };
import org.junit.{ Test, Before, After, Assert }
import Matchers._
@ -16,7 +16,7 @@ class ExpressionTest {
@Test
def Double_Negation {
assertEquals("person.javaInt", person.javaInt.negate.negate);
assertEquals("person.javaInt", person.javaInt.negate.negate)
}
@Test

11
querydsl-scala/src/test/scala/com/querydsl/scala/GenericExporterJPATest.scala
View File

@ -1,11 +1,11 @@
package com.querydsl.scala;
package com.querydsl.scala
import javax.persistence._
import com.querydsl.codegen.GenericExporter
import org.junit.Test
import io.Source.fromFile
class GenericExporterJPATest extends CompileTestUtils {
class GenericExporterJPATest {
@Test
def Export {
@ -22,11 +22,8 @@ class GenericExporterJPATest extends CompileTestUtils {
exporter.export(getClass.getPackage)
val targetFolder = new java.io.File("target/gen1-jpa/com/querydsl/scala/")
val sources = (targetFolder listFiles ()
filter (_.getName.endsWith(".scala"))
map (fromFile(_).mkString)
mkString ("\n"))
assertCompileSuccess(sources)
val sources = targetFolder.listFiles.filter(_.getName.endsWith(".scala"))
CompileTestUtils.assertCompileSuccess(sources)
}
}

21
querydsl-scala/src/test/scala/com/querydsl/scala/GenericExporterTest.scala
View File

@ -1,4 +1,4 @@
package com.querydsl.scala;
package com.querydsl.scala
import com.querydsl.core.annotations._
import com.querydsl.codegen.GenericExporter
@ -6,7 +6,7 @@ import org.junit.Test
import io.Source.fromFile
import java.io.File
class GenericExporterTest extends CompileTestUtils {
class GenericExporterTest {
@Test
def Export {
@ -17,21 +17,8 @@ class GenericExporterTest extends CompileTestUtils {
exporter.setCreateScalaSources(true)
exporter.export(getClass.getPackage)
val targetFolder = new File("target/gen1/com/querydsl/scala/")
// com.querydsl.scala
val sources = (targetFolder.listFiles()
filter (_.getName.endsWith(".scala"))
map (fromFile(_).mkString)
mkString ("\n"))
assertCompileSuccess(sources)
// com.querydsl.scala.ext
val other = (new File(targetFolder, "ext").listFiles()
filter (_.getName.endsWith(".scala"))
map (fromFile(_).mkString)
mkString ("\n"))
assertCompileSuccess("import com.querydsl.scala.ext._\n" + other)
val targetFolder = new File("target/gen1")
CompileTestUtils.assertCompileSuccess(targetFolder)
}
}

13
querydsl-scala/src/test/scala/com/querydsl/scala/QPerson.scala
View File

@ -1,11 +1,10 @@
package com.querydsl.scala;
package com.querydsl.scala
import com.querydsl.core.types._;
import com.querydsl.scala._;
import com.querydsl.core.types.PathMetadataFactory._;
import java.util.List;
import java.util.Map;
import com.querydsl.core.types._
import com.querydsl.scala._
import com.querydsl.core.types.PathMetadataFactory._
import java.util.List
import java.util.Map
object QPerson extends QPerson("person"){
override def as(variable: String) = new QPerson(variable)

6
querydsl-scala/src/test/scala/com/querydsl/scala/QPersonTest.scala
View File

@ -1,8 +1,8 @@
package com.querydsl.scala;
package com.querydsl.scala
import com.querydsl.core.types._;
import com.querydsl.core.types._
import org.junit.{ Test, Before, After, Assert };
import org.junit.{ Test, Before, After, Assert }
import Matchers._

20
querydsl-scala/src/test/scala/com/querydsl/scala/BeanSerializerTest.scala → querydsl-scala/src/test/scala/com/querydsl/scala/ScalaBeanSerializerTest.scala
View File

@ -1,17 +1,17 @@
package com.querydsl.scala
import com.mysema.codegen._;
import com.mysema.codegen.model._;
import com.querydsl.codegen._;
import com.mysema.codegen._
import com.mysema.codegen.model._
import com.querydsl.codegen._
import java.io.StringWriter;
import java.io.StringWriter
import org.junit._
import org.junit.Assert._
import scala.collection.JavaConversions._
class ScalaBeanSerializerTest extends CompileTestUtils {
class ScalaBeanSerializerTest {
val typeMappings = ScalaTypeMappings.create
@ -29,7 +29,7 @@ class ScalaBeanSerializerTest extends CompileTestUtils {
//println(writer.toString)
var toMatch = """package com.querydsl
import scala.reflect.BeanProperty
import scala.beans.BeanProperty
import java.util.List
import java.util.Map
/**
@ -47,11 +47,11 @@ class ScalaBeanSerializerTest extends CompileTestUtils {
@BeanProperty var setField: java.util.Set[DomainClass] = _
@BeanProperty var time: java.sql.Time = _"""
val str = writer.toString().replaceAll("\\s+", " ")
val str = writer.toString.replaceAll("\\s+", " ")
//println(str)
toMatch.split("\\n").map(_.trim).foreach { line =>
assertTrue(line, str.contains(line));
assertTrue(line, str.contains(line))
}
}
@ -62,7 +62,7 @@ class ScalaBeanSerializerTest extends CompileTestUtils {
serializer.createCompanionObject = false
typeMappings.register(entityType, new QueryTypeFactoryImpl("Q", "", "").create(entityType))
serializer.serialize(entityType, SimpleSerializerConfig.DEFAULT, new ScalaWriter(writer))
val str = writer.toString()
assertCompileSuccess(str)
val str = writer.toString
CompileTestUtils.assertCompileSuccess(str)
}
}

8
querydsl-scala/src/test/scala/com/querydsl/scala/EntitySerializerTest.scala → querydsl-scala/src/test/scala/com/querydsl/scala/ScalaEntitySerializerTest.scala
View File

@ -13,7 +13,7 @@ import com.querydsl.sql._
import java.io.StringWriter
class ScalaEntitySerializerTest extends CompileTestUtils {
class ScalaEntitySerializerTest {
var entityType: EntityType = null
@ -51,7 +51,7 @@ class ScalaEntitySerializerTest extends CompileTestUtils {
typeMappings.register(entityType, new QueryTypeFactoryImpl("Q", "", "").create(entityType))
val serializer = new ScalaEntitySerializer(typeMappings)
serializer.serialize(entityType, SimpleSerializerConfig.DEFAULT, new ScalaWriter(writer))
val str = writer.toString()
val str = writer.toString
//System.err.println(str)
assertTrue(str.contains("class QPerson(cl: Class[_ <: Person], md: PathMetadata) " +
"extends EntityPathImpl[Person](cl, md) {"))
@ -67,8 +67,8 @@ class ScalaEntitySerializerTest extends CompileTestUtils {
typeMappings.register(entityType, new QueryTypeFactoryImpl("Q", "", "").create(entityType))
val serializer = new ScalaEntitySerializer(typeMappings)
serializer.serialize(entityType, SimpleSerializerConfig.DEFAULT, new ScalaWriter(writer))
val str = writer.toString()
val str = writer.toString
//System.err.println(str);
assertCompileSuccess(str)
CompileTestUtils.assertCompileSuccess(str)
}
}

2
querydsl-scala/src/test/scala/com/querydsl/scala/Types.scala
View File

@ -1,4 +1,4 @@
package com.querydsl.scala;
package com.querydsl.scala
import com.querydsl.core.annotations._

2
querydsl-scala/src/test/scala/com/querydsl/scala/ext/Types2.scala
View File

@ -1,4 +1,4 @@
package com.querydsl.scala.ext;
package com.querydsl.scala.ext
import com.querydsl.core.annotations._
import scala.runtime.RichChar

103
querydsl-scala/src/test/scala/com/querydsl/scala/sql/JDBCIntegrationTest.scala
View File

@ -24,22 +24,16 @@ import com.querydsl.sql.codegen._
import com.querydsl.sql.dml._
import com.querydsl.scala.Helpers._
class JDBCIntegrationTest extends CompileTestUtils with SQLHelpers {
val survey = QSurvey
val employee = QEmployee
object JDBCIntegrationTest {
val templates = new HSQLDBTemplates()
private var connection: Connection = _
private var statement: Statement = _
var connection: Connection = _
var statement: Statement = _
@Before
def setUp() {
@BeforeClass
def setUpClass() {
Class.forName("org.h2.Driver")
val url = "jdbc:h2:~/dbs/h2-scala"
val url = "jdbc:h2:mem:testdb" + System.currentTimeMillis()
connection = DriverManager.getConnection(url, "sa", "")
statement = connection.createStatement()
statement.execute("drop table employee if exists")
@ -64,46 +58,43 @@ class JDBCIntegrationTest extends CompileTestUtils with SQLHelpers {
statement.execute("insert into employee (firstname, lastname) values ('Bob', 'Smith')")
statement.execute("insert into employee (firstname, lastname) values ('John', 'Doe')")
// TODO : create table with multi column primary key
}
@Test
def Generation_without_Beantypes {
val namingStrategy = new DefaultNamingStrategy()
val exporter = new MetaDataExporter()
exporter.setNamePrefix("Q")
exporter.setPackageName("com.querydsl")
val directory = new File("target/gensql1")
exporter.setTargetFolder(directory)
exporter.setSerializerClass(classOf[ScalaMetaDataSerializer])
exporter.setCreateScalaSources(true)
exporter.setTypeMappings(ScalaTypeMappings.create)
exporter.setSchemaPattern("PUBLIC")
exporter.export(connection.getMetaData)
assertCompileSuccess(recursiveFileList(directory))
@AfterClass
def tearDownClass() {
try {
statement.close()
} finally {
connection.close()
}
}
@Test
def Generation_with_Beantypes {
val namingStrategy = new DefaultNamingStrategy()
//val beanSerializer = new ScalaBeanSerializer()
val exporter = new MetaDataExporter()
exporter.setNamePrefix("Q")
exporter.setPackageName("com.querydsl")
val directory = new File("target/gensql2")
exporter.setTargetFolder(directory)
exporter.setSerializerClass(classOf[ScalaMetaDataSerializer])
exporter.setBeanSerializerClass(classOf[ScalaBeanSerializer])
exporter.setCreateScalaSources(true)
exporter.setTypeMappings(ScalaTypeMappings.create)
exporter.setSchemaPattern("PUBLIC")
exporter.export(connection.getMetaData)
assertCompileSuccess(recursiveFileList(directory))
}
class JDBCIntegrationTest extends SQLHelpers {
import JDBCIntegrationTest._
val survey = QSurvey
val employee = QEmployee
val templates = new HSQLDBTemplates()
val configuration = new Configuration(templates)
def connection = JDBCIntegrationTest.connection
@Before
def setUp(): Unit = {
connection.setAutoCommit(false)
}
@After
def tearDown(): Unit = {
connection.rollback()
connection.setAutoCommit(true)
}
@Test
def Populate_Bean {
assertEquals(2, query.from(survey).list(survey) size ())
@ -235,23 +226,13 @@ class JDBCIntegrationTest extends CompileTestUtils with SQLHelpers {
val count = delete(survey) where(survey.id === id) execute()
assertTrue(count > 0)
}
@After
def tearDown() {
try {
statement.close()
} finally {
connection.close()
}
}
def query = new SQLQuery(connection, configuration)
def query = new SQLQuery(connection, templates)
def delete(path: RelationalPath[_]) = new SQLDeleteClause(connection, templates, path)
def delete(path: RelationalPath[_]) = new SQLDeleteClause(connection, configuration, path)
def insert(path: RelationalPath[_]) = new SQLInsertClause(connection, templates, path)
def insert(path: RelationalPath[_]) = new SQLInsertClause(connection, configuration, path)
def update(path: RelationalPath[_]) = new SQLUpdateClause(connection, templates, path)
def update(path: RelationalPath[_]) = new SQLUpdateClause(connection, configuration, path)
}

239
querydsl-scala/src/test/scala/com/querydsl/scala/sql/MetaDataExporterTest.scala
View File

@ -7,7 +7,7 @@ import com.querydsl.codegen._
import com.querydsl.sql._
import com.querydsl.sql.codegen._
import java.io.StringWriter;
import java.io.StringWriter
import org.junit._
import org.junit.Assert._
@ -16,128 +16,131 @@ import scala.collection.JavaConversions._
import com.querydsl.scala._
class MetaDataExporterTest extends CompileTestUtils {
var connection: java.sql.Connection = _;
@Before
def setUp() {
Class.forName("org.h2.Driver");
val url = "jdbc:h2:mem:testdb" + System.currentTimeMillis();
connection = java.sql.DriverManager.getConnection(url, "sa", "");
object MetaDataExporterTest {
val stmt = connection.createStatement();
private var connection: java.sql.Connection = _
try{
stmt.execute("create table reserved (id int, while int)");
stmt.execute("create table underscore (e_id int, c_id int)");
stmt.execute("create table beangen1 (\"SEP_Order\" int)");
stmt.execute("create table definstance (id int, definstance int, definstance1 int)");
stmt.execute("create table pkfk (id int primary key, pk int, fk int)");
stmt.execute("create table \"camelCase\" (id int)");
stmt.execute("create table \"vwServiceName\" (id int)");
stmt.execute("create table date_test (d date)");
stmt.execute("create table date_time_test (dt datetime)");
stmt.execute("create table survey (id int, name varchar(30))");
stmt.execute("create table typetest (type int, constraint pk_typetest primary key(type))");
stmt.execute("""create table employee(
id INT, firstname VARCHAR(50), lastname VARCHAR(50), salary DECIMAL(10, 2),
datefield DATE, timefield TIME,
superior_id int, survey_id int, survey_name varchar(30),
CONSTRAINT PK_employee PRIMARY KEY (id),
CONSTRAINT FK_superior FOREIGN KEY (superior_id) REFERENCES employee(id))""");
// table with count column
stmt.execute("create table count_table(count int)");
// multi primary key
stmt.execute("create table multikey(id INT, id2 VARCHAR, id3 INT," +
" CONSTRAINT pk_multikey PRIMARY KEY (id, id2, id3) )");
// multi foreign key
stmt.execute("create table multikey2(id INT, id2 INT, id3 INT, id4 INT, id5 INT, id6 INT," +
" CONSTRAINT pk_multikey2 FOREIGN KEY (id4, id5, id6) REFERENCES multikey2(id, id2, id3) )");
} finally {
stmt.close();
}
@BeforeClass
def setUp() {
Class.forName("org.h2.Driver")
val url = "jdbc:h2:mem:testdb" + System.currentTimeMillis()
connection = java.sql.DriverManager.getConnection(url, "sa", "")
val stmt = connection.createStatement()
try {
stmt.execute("create table reserved (id int, while int)")
stmt.execute("create table underscore (e_id int, c_id int)")
stmt.execute("create table beangen1 (\"SEP_Order\" int)")
stmt.execute("create table definstance (id int, definstance int, definstance1 int)")
stmt.execute("create table pkfk (id int primary key, pk int, fk int)")
stmt.execute("create table \"camelCase\" (id int)")
stmt.execute("create table \"vwServiceName\" (id int)")
stmt.execute("create table date_test (d date)")
stmt.execute("create table date_time_test (dt datetime)")
stmt.execute("create table survey (id int, name varchar(30))")
stmt.execute("create table typetest (type int, constraint pk_typetest primary key(type))")
stmt.execute("""create table employee(
id INT, firstname VARCHAR(50), lastname VARCHAR(50), salary DECIMAL(10, 2),
datefield DATE, timefield TIME,
superior_id int, survey_id int, survey_name varchar(30),
CONSTRAINT PK_employee PRIMARY KEY (id),
CONSTRAINT FK_superior FOREIGN KEY (superior_id) REFERENCES employee(id))""")
// table with count column
stmt.execute("create table count_table(count int)")
// multi primary key
stmt.execute("create table multikey(id INT, id2 VARCHAR, id3 INT," +
" CONSTRAINT pk_multikey PRIMARY KEY (id, id2, id3) )")
// multi foreign key
stmt.execute("create table multikey2(id INT, id2 INT, id3 INT, id4 INT, id5 INT, id6 INT," +
" CONSTRAINT pk_multikey2 FOREIGN KEY (id4, id5, id6) REFERENCES multikey2(id, id2, id3) )")
} finally {
stmt.close()
}
}
@AfterClass
def tearDown() {
connection.close()
}
}
class MetaDataExporterTest {
import MetaDataExporterTest._
@Test
def Generate_Without_BeanTypes() {
val directory = new java.io.File("target/jdbcgen1")
val exporter = new MetaDataExporter()
exporter.setNamePrefix("Q")
exporter.setPackageName("com.querydsl")
exporter.setSchemaPattern("PUBLIC")
exporter.setTargetFolder(directory)
exporter.setSerializerClass(classOf[ScalaMetaDataSerializer])
exporter.setCreateScalaSources(true)
exporter.setTypeMappings(ScalaTypeMappings.create)
exporter.export(connection.getMetaData)
CompileTestUtils.assertCompileSuccess(directory)
}
@Test
def Generate_Without_BeanTypes() {
val directory = new java.io.File("target/jdbcgen1");
val namingStrategy = new DefaultNamingStrategy();
val exporter = new MetaDataExporter();
exporter.setNamePrefix("Q");
exporter.setPackageName("com.querydsl");
exporter.setSchemaPattern("PUBLIC");
exporter.setTargetFolder(directory);
exporter.setSerializerClass(classOf[ScalaMetaDataSerializer]);
exporter.setCreateScalaSources(true);
exporter.setTypeMappings(ScalaTypeMappings.create);
exporter.export(connection.getMetaData);
assertCompileSuccess(recursiveFileList(directory))
}
@Test
def Generate_With_BeanTypes() {
val directory = new java.io.File("target/jdbcgen2")
val exporter = new MetaDataExporter()
exporter.setNamePrefix("Q")
exporter.setPackageName("com.querydsl")
exporter.setSchemaPattern("PUBLIC")
exporter.setTargetFolder(directory)
exporter.setSerializerClass(classOf[ScalaMetaDataSerializer])
exporter.setBeanSerializerClass(classOf[ScalaBeanSerializer])
exporter.setCreateScalaSources(true)
exporter.setTypeMappings(ScalaTypeMappings.create)
exporter.export(connection.getMetaData)
CompileTestUtils.assertCompileSuccess(directory)
}
@Test
def Generate_With_BeanTypes() {
val directory = new java.io.File("target/jdbcgen2");
val namingStrategy = new DefaultNamingStrategy();
//val beanSerializer = new ScalaBeanSerializer();
val exporter = new MetaDataExporter();
exporter.setNamePrefix("Q");
exporter.setPackageName("com.querydsl");
exporter.setSchemaPattern("PUBLIC");
exporter.setTargetFolder(directory);
exporter.setSerializerClass(classOf[ScalaMetaDataSerializer]);
exporter.setBeanSerializerClass(classOf[ScalaBeanSerializer]);
exporter.setCreateScalaSources(true);
exporter.setTypeMappings(ScalaTypeMappings.create);
exporter.export(connection.getMetaData);
assertCompileSuccess(recursiveFileList(directory))
}
@Test
def Generate_With_Schema() {
val directory = new java.io.File("target/jdbcgen3")
val exporter = new MetaDataExporter()
exporter.setNamePrefix("Q")
exporter.setPackageName("com.querydsl")
exporter.setSchemaPattern("PUBLIC")
exporter.setSchemaToPackage(true)
exporter.setTargetFolder(directory)
exporter.setSerializerClass(classOf[ScalaMetaDataSerializer])
exporter.setCreateScalaSources(true)
exporter.setTypeMappings(ScalaTypeMappings.create)
exporter.export(connection.getMetaData)
CompileTestUtils.assertCompileSuccess(directory)
}
@Test
def Generate_With_Schema() {
val directory = new java.io.File("target/jdbcgen3");
val namingStrategy = new DefaultNamingStrategy();
//val beanSerializer = new ScalaBeanSerializer();
val exporter = new MetaDataExporter();
exporter.setNamePrefix("Q");
exporter.setPackageName("com.querydsl");
exporter.setSchemaPattern("PUBLIC");
exporter.setSchemaToPackage(true);
exporter.setTargetFolder(directory);
exporter.setSerializerClass(classOf[ScalaMetaDataSerializer]);
exporter.setCreateScalaSources(true);
exporter.setTypeMappings(ScalaTypeMappings.create);
exporter.export(connection.getMetaData);
assertCompileSuccess(recursiveFileList(directory))
}
@Test
def Generate_With_BeanTypes_And_Schema() {
val directory = new java.io.File("target/jdbcgen4");
val namingStrategy = new DefaultNamingStrategy();
//val beanSerializer = new ScalaBeanSerializer();
val exporter = new MetaDataExporter();
exporter.setNamePrefix("Q");
exporter.setPackageName("com.querydsl");
exporter.setSchemaPattern("PUBLIC");
exporter.setSchemaToPackage(true);
exporter.setTargetFolder(directory);
exporter.setSerializerClass(classOf[ScalaMetaDataSerializer]);
exporter.setBeanSerializerClass(classOf[ScalaBeanSerializer]);
exporter.setCreateScalaSources(true);
exporter.setTypeMappings(ScalaTypeMappings.create);
exporter.export(connection.getMetaData);
assertCompileSuccess(recursiveFileList(directory))
}
@Test
def Generate_With_BeanTypes_And_Schema() {
val directory = new java.io.File("target/jdbcgen4")
val exporter = new MetaDataExporter()
exporter.setNamePrefix("Q")
exporter.setPackageName("com.querydsl")
exporter.setSchemaPattern("PUBLIC")
exporter.setSchemaToPackage(true)
exporter.setTargetFolder(directory)
exporter.setSerializerClass(classOf[ScalaMetaDataSerializer])
exporter.setBeanSerializerClass(classOf[ScalaBeanSerializer])
exporter.setCreateScalaSources(true)
exporter.setTypeMappings(ScalaTypeMappings.create)
exporter.export(connection.getMetaData)
CompileTestUtils.assertCompileSuccess(directory)
}
}

12
querydsl-scala/src/test/scala/com/querydsl/scala/sql/MetaDataSerializerTest.scala → querydsl-scala/src/test/scala/com/querydsl/scala/sql/ScalaMetaDataSerializerTest.scala
View File

@ -1,13 +1,13 @@
package com.querydsl.scala.sql
import com.mysema.codegen._;
import com.mysema.codegen.model._;
import com.mysema.codegen._
import com.mysema.codegen.model._
import com.querydsl.codegen._;
import com.querydsl.codegen._
import com.querydsl.sql._
import com.querydsl.sql.codegen._
import java.io.StringWriter;
import java.io.StringWriter
import org.junit._
import org.junit.Assert._
@ -29,7 +29,7 @@ class ScalaMetaDataSerializerTest {
"com.querydsl.DomainClass", "com.querydsl", "DomainClass", false, false)
entityType = new EntityType(typeModel)
//entityType.addAnnotation(new TableImpl("DOMAIN_TYPE"))
entityType.getData().put("table", "DOMAIN_TYPE")
entityType.getData.put("table", "DOMAIN_TYPE")
// properties
List(classOf[java.lang.Boolean], classOf[Comparable[_]], classOf[Integer],
@ -49,7 +49,7 @@ class ScalaMetaDataSerializerTest {
val namingStrategy = new DefaultNamingStrategy()
val serializer = new ScalaMetaDataSerializer(typeMappings, namingStrategy)
serializer.serialize(entityType, SimpleSerializerConfig.DEFAULT, new ScalaWriter(writer))
val str = writer.toString()
val str = writer.toString
//System.err.println(str)
assertTrue("companion object isn't before class", str.indexOf("object") < str.indexOf("class"))
//assertTrue("companion object isn't before annotations", str.indexOf("object") < str.indexOf("@Table"))

20
querydsl-scala/src/test/scala/test/Employee.scala
View File

@ -1,24 +1,24 @@
package test;
package test
import scala.reflect.BeanProperty;
import javax.validation.constraints.Size;
import javax.validation.constraints.NotNull;
import com.querydsl.sql._;
import scala.beans.BeanProperty
import javax.validation.constraints.Size
import javax.validation.constraints.NotNull
import com.querydsl.sql._
object Employee extends QEmployee("employee"){
object Employee extends QEmployee("employee") {
override def as(variable: String) = new QEmployee(variable)
}
class Employee {
var firstname: String = _;
var firstname: String = _
var id: Integer = _;
var id: Integer = _
var lastname: String = _;
var lastname: String = _
var superiorId: Integer = _;
var superiorId: Integer = _
}

18
querydsl-scala/src/test/scala/test/QEmployee.scala
View File

@ -1,13 +1,13 @@
package test;
package test
import com.querydsl.core.types._;
import com.querydsl.scala._;
import com.querydsl.core.types._
import com.querydsl.scala._
import com.querydsl.core.types.PathMetadataFactory._;
import com.querydsl.core.types.PathMetadataFactory._
import com.querydsl.scala.sql.RelationalPathImpl;
import com.querydsl.scala.sql.RelationalPathImpl
import com.querydsl.sql._;
import com.querydsl.sql._
object QEmployee extends QEmployee("employee"){
override def as(variable: String) = new QEmployee(variable)
@ -27,11 +27,11 @@ class QEmployee(md: PathMetadata) extends RelationalPathImpl[Employee](md, "PUBL
val superiorId = createNumber[Integer]("superiorId")
val sysIdx55: PrimaryKey[Employee] = createPrimaryKey(id);
val sysIdx55: PrimaryKey[Employee] = createPrimaryKey(id)
val superiorFk: ForeignKey[Employee] = createForeignKey(superiorId, "ID");
val superiorFk: ForeignKey[Employee] = createForeignKey(superiorId, "ID")
val _superiorFk: ForeignKey[Employee] = createInvForeignKey(id, "SUPERIOR_ID");
val _superiorFk: ForeignKey[Employee] = createInvForeignKey(id, "SUPERIOR_ID")
addMetadata(firstname, ColumnMetadata.named("FIRSTNAME"))
addMetadata(id, ColumnMetadata.named("ID"))

16
querydsl-scala/src/test/scala/test/QSurvey.scala
View File

@ -1,14 +1,14 @@
package test;
package test
import com.querydsl.core.types._;
import com.querydsl.scala._;
import com.querydsl.core.types._
import com.querydsl.scala._
import com.querydsl.core.types.PathMetadataFactory._;
import com.querydsl.scala.sql.RelationalPathImpl;
import com.querydsl.core.types.PathMetadataFactory._
import com.querydsl.scala.sql.RelationalPathImpl
import com.querydsl.sql._;
import com.querydsl.sql._
object QSurvey extends QSurvey("survey"){
object QSurvey extends QSurvey("survey") {
override def as(variable: String) = new QSurvey(variable)
}
@ -22,7 +22,7 @@ class QSurvey(md: PathMetadata) extends RelationalPathImpl[Survey](md, "PUBLIC",
val name = createString("name")
val sysIdx54: PrimaryKey[Survey] = createPrimaryKey(id);
val sysIdx54: PrimaryKey[Survey] = createPrimaryKey(id)
addMetadata(id, ColumnMetadata.named("ID"))
addMetadata(name, ColumnMetadata.named("NAME"))

14
querydsl-scala/src/test/scala/test/Survey.scala
View File

@ -1,9 +1,9 @@
package test;
package test
import scala.reflect.BeanProperty;
import javax.validation.constraints.Size;
import javax.validation.constraints.NotNull;
import com.querydsl.sql._;
import scala.beans.BeanProperty
import javax.validation.constraints.Size
import javax.validation.constraints.NotNull
import com.querydsl.sql._
object Survey extends QSurvey("survey"){
override def as(variable: String) = new QSurvey(variable)
@ -12,9 +12,9 @@ object Survey extends QSurvey("survey"){
class Survey {
var id: Integer = _;
var id: Integer = _
var name: String = _;
var name: String = _
}