Experimental work on a DDL DSL

Author: davidhoyt

.gitignore

@@ -1,13 +1,5 @@
-*.class
-*.log
+!.gitignore
 
-# sbt specific
-dist/*
 target/
-lib_managed/
-src_managed/
-project/boot/
-project/plugins/project/
-
-# Scala-IDE specific
-.scala_dependencies
+.idea/
+.idea_modules/

dsl-core/build.sbt

@@ -0,0 +1,7 @@
+
+libraryDependencies += "com.chuusai" % "shapeless_2.10.2" % "2.0.0-M1"
+
+libraryDependencies += "org.scalatest" %% "scalatest" % "2.0.M5b" % "test"
+
+libraryDependencies += "junit" % "junit" % "4.11" % "test"
+

dsl-core/src/main/scala/ddl/DataTypes.scala

@@ -0,0 +1,6 @@
+package ddl
+
+trait DataType
+trait NumericDataType extends DataType
+case class NumberDataType(size: Int) extends NumericDataType
+case object IntDataType extends NumericDataType

dsl-core/src/main/scala/ddl/Ddl.scala

@@ -0,0 +1,9 @@
+package ddl
+
+trait DdlExpression[+T] {
+  def value: T
+}
+
+trait DdlExpressionGroup {
+  def expressions: Seq[DdlExpression[Any]]
+}

dsl-core/src/main/scala/ddl/Table.scala

@@ -0,0 +1,71 @@
+package ddl
+
+trait DdlTableExpression[+T] extends DdlExpression[T]
+trait DdlTableExpressionGroup extends DdlExpressionGroup {
+  def expressions: Seq[DdlTableExpression[Any]]
+}
+trait Table extends DdlTableExpressionGroup
+case class TableWithExpressions(expressions: Seq[DdlTableExpression[Any]]) extends Table
+
+trait ColumnModifier
+case object PrimaryColumn extends ColumnModifier
+case object Nullable extends ColumnModifier
+
+trait ColumnPrimaryConstraint
+case object KEY extends ColumnPrimaryConstraint
+
+trait ColumnNullableConstraint
+case object NULL extends ColumnNullableConstraint
+
+trait Column extends DdlTableExpression[Column] {
+  def name: String
+  def dataType: DataType
+  def modifiers: Set[ColumnModifier]
+  def value: Column = this
+}
+
+class ColumnNeedsDataType(val name: String) {
+  object NUMBER {
+    def apply(value: Int): ColumnWithDataType =
+      new ColumnWithDataType(name, NumberDataType(value))
+  }
+  object INT {
+    def apply: ColumnWithDataType =
+      new ColumnWithDataType(name, IntDataType)
+  }
+}
+
+case class ColumnWithDataType(name: String, dataType: DataType, modifiers: Set[ColumnModifier] = Set(Nullable)) extends Column {
+  def PRIMARY(constraint: ColumnPrimaryConstraint): ColumnWithDataType =
+    constraint match {
+      case key =>
+        ColumnWithDataType(name, dataType, modifiers + PrimaryColumn)
+    }
+
+  def NOT(constraint: ColumnNullableConstraint): ColumnWithDataType =
+    constraint match {
+      case NULL =>
+        ColumnWithDataType(name, dataType, modifiers - Nullable)
+    }
+}
+
+case class Named[+T](name: String, values: Seq[T]) {
+  override def toString = name
+}
+
+
+
+
+
+trait PrimaryKey extends DdlTableExpression[PrimaryKey] {
+  def columns: Seq[PrimaryKeyName]
+  def value: PrimaryKey = this
+}
+
+case class PrimaryKeyName(name: String)
+case class PrimaryKeyWithColumns(columns: Seq[PrimaryKeyName]) extends PrimaryKey
+
+object PRIMARY {
+  def KEY(cols: PrimaryKeyName*): PrimaryKey =
+    PrimaryKeyWithColumns(cols)
+}

dsl-core/src/main/scala/ddl/package.scala

@@ -0,0 +1,12 @@
+package object ddl {
+  implicit class NamedStringInterpolator(val context : StringContext) {
+    def t[T <: DdlExpression[Any]](args : Any*)(values: T*): Named[T] =
+      Named(context.s(args : _*), values)
+
+    def c(args: Any*): ColumnNeedsDataType =
+      new ColumnNeedsDataType(context.s(args : _*))
+
+    def pk(args: Any*): PrimaryKeyName =
+      new PrimaryKeyName(context.s(args : _*))
+  }
+}

dsl-macros/build.sbt

@@ -0,0 +1,11 @@
+
+resolvers += Resolver.sonatypeRepo("snapshots")
+
+addCompilerPlugin("org.scala-lang.plugins" % "macro-paradise" % "2.0.0-SNAPSHOT" cross CrossVersion.full)
+
+libraryDependencies += "org.scala-lang" % "scala-reflect" % "2.10.2"
+
+libraryDependencies += "org.scalatest" %% "scalatest" % "2.0.M5b" % "test"
+
+libraryDependencies += "junit" % "junit" % "4.11" % "test"
+

dsl-macros/src/main/scala/ddl/Create.scala

@@ -0,0 +1,16 @@
+package ddl
+
+import scala.language.experimental.macros
+
+object CREATE {
+    object TABLE {
+//      def apply[T <: DdlTableExpression[Any]](n: Named[T]): Table = {
+//        val table = TableWithExpressions(n.values)
+//        TableMacros.check(table)
+//        table
+//      }
+
+      def apply[T <: DdlTableExpression[Any]](n: Named[T]) =
+        macro TableMacros.create[T]
+    }
+  }