--- a/src/main/scala/SQL.scala	Fri Oct 08 15:58:19 2010 -0400
+++ b/src/main/scala/SQL.scala	Wed Oct 13 23:21:16 2010 -0400
@@ -3,6 +3,89 @@
 
 import scala.util.parsing.combinator._
 
+import scala.collection.Set
+
+// Relational structure
+object RDB {
+
+  case class Database (m:Map[RelName, Relation]) {
+    def apply (rn:RelName) = m(rn)
+    def keySet () = m.keySet
+  }
+
+  case class Relation (name:RelName, header:Header, body:Set[Tuple], candidates:List[CandidateKey], pk:Option[CandidateKey], fks:ForeignKeys)
+  case class Header (m:Map[AttrName, SQLDatatype]) {
+    def apply (a:AttrName) = m(a)
+    def keySet () = m.keySet
+    def sqlDatatype (a:AttrName) : SQLDatatype = m(a)
+  }
+  object Header {
+    def apply (s:(String, SQLDatatype)*):Header =
+      Header(s.map{p => (AttrName(p._1), p._2)}.toMap)
+  }
+  case class CandidateKey (attrs:List[AttrName])
+  object CandidateKey {
+    def apply (l:(String)*):CandidateKey =
+      CandidateKey(l.map{s => AttrName(s)}.toList)
+  }
+  implicit def cc2list (cc:CandidateKey) = cc.attrs
+
+  case class ForeignKeys (m:Map[List[AttrName], Target]) {
+    def apply (l:List[AttrName]) = m(l)
+    def keySet () = m.keySet
+    def contains (l:List[AttrName]) = m.contains(l)
+  }
+  object ForeignKeys {
+    def apply (s:(List[String], Target)*):ForeignKeys =
+      ForeignKeys(s.map{p => (p._1.map{s => AttrName(s)}, p._2)}.toMap)
+  }
+
+  case class Target (rel:RelName, key:CandidateKey)
+
+  sealed abstract class SQLDatatype
+  case class SQLInt () extends SQLDatatype
+  case class SQLFloat () extends SQLDatatype
+  case class SQLDate () extends SQLDatatype
+  case class SQLTime () extends SQLDatatype
+  case class SQLTimestamp () extends SQLDatatype
+  case class SQLChar () extends SQLDatatype
+  case class SQLVarchar () extends SQLDatatype
+  case class SQLString () extends SQLDatatype
+
+  case class Tuple (m:Map[AttrName, CellValue]) {
+    def apply (a:AttrName) = m(a)
+    def lexvalue (a:AttrName) : Option[LexicalValue] = 
+      m(a) match {
+	case ␀() => None
+	case v:LexicalValue => Some(v)
+      }
+    def lexvaluesNoNulls (as:List[AttrName]) = as.map(a => m(a).asInstanceOf[LexicalValue])
+    def nullAttributes (h:Header) : Set[(AttrName)] = {
+      h.keySet.flatMap(a =>
+	lexvalue(a) match {
+	  case None => Some(a)
+	  case _ => None
+	})
+    }
+  }
+  object Tuple {
+    def apply (s:(String, CellValue)*):Tuple =
+      Tuple(s.map{p => (AttrName(p._1), p._2)}.toMap)
+  }
+
+  abstract class CellValue
+  case class LexicalValue (s:String) extends CellValue
+  case class ␀ () extends CellValue
+
+  case class RelName(n:String) {
+    override def toString = n
+  }
+  case class AttrName(n:String) {
+    override def toString = n
+  }
+
+}
+
 object SQLParsers extends RegexParsers {
 
   val int = """[0-9]+""".r
@@ -19,38 +102,38 @@
   override def toString = "(\n       " + sel.toString.replace("\n", "\n       ") + "\n                  )"
 }
 sealed abstract class SelectORUnion
-case class Select(distinct:Boolean, attributelist:AttributeList, tablelist:TableList, expression:Option[Expression], order:List[OrderElt], offset:Option[Int], limit:Option[Int]) extends SelectORUnion {
+case class Select(distinct:Boolean, projection:Projection, tablelist:TableList, expression:Option[Expression], order:List[OrderElt], offset:Option[Int], limit:Option[Int]) extends SelectORUnion {
   override def toString = 
     "SELECT "+
     { if (distinct) "DISTINCT " else "" }+
-    attributelist+"\n"+
+    projection+"\n"+
     tablelist+
     { if (expression.isDefined) {"\b WHERE " + expression.get + " "} else "" }+
     { if (order.size > 0) {order.map(o => o.toString).mkString("ORDER BY ", " ", " ") } else "" }+
     { if (offset.isDefined) {"OFFSET " + offset + " "} else "" }+
     { if (limit.isDefined) {"LIMIT " + limit + " "} else "" }
 }
-case class Relation(n:Name) extends RelationORSubselect {
-  override def toString = n.s /* "'" + n.s + "'" */
+case class RelName(n:String) extends RelationORSubselect {
+  override def toString = n
 }
 case class Union(disjoints:Set[Select]) extends SelectORUnion {
   override def toString = "  " + (disjoints.toList.map(s => s.toString.replace("\n", "\n  ")).mkString("\nUNION\n  "))
 }
-case class AttributeList(attributes:Set[NamedAttribute]) {
+case class Projection(attributes:Set[ProjectAttribute]) {
   // foo, bar
   override def toString = attributes.toList.sortWith((l, r) => l.attralias.toString < r.attralias.toString).mkString(", ")
 }
-case class NamedAttribute(value:RelVarAttrORExpression, attralias:AttrAlias) {
+case class ProjectAttribute(value:RelVarAttrORExpression, attralias:AttrAlias) {
   override def toString = value + " AS " + attralias
 }
-//case class RelAttribute(relation:Relation, attribute:Attribute) c.f. ForeignKey
+//case class RelAttribute(relation:Relation, attribute:AttrName) c.f. ForeignKey
 sealed abstract class RelVarAttrORExpression
-case class RelVarAttr(relvar:RelVar, attribute:Attribute) extends RelVarAttrORExpression {
+case class RelVarAttr(relvar:RelVar, attribute:AttrName) extends RelVarAttrORExpression {
   override def toString = relvar + "." + attribute
 }
 
-case class Attribute(n:Name) {
-  override def toString = n.s /* "'" + n.s + "'" */
+case class AttrName(n:String) {
+  override def toString = n
 }
 case class AttrAlias(n:Name) {
   override def toString = n.s /* "'" + n.s + "'" */
@@ -173,16 +256,16 @@
 
 sealed abstract class ValueDescription
 case class Value(datatype:Datatype) extends ValueDescription
-case class ForeignKey(rel:Relation, attr:Attribute) extends ValueDescription
+case class ForeignKey(rel:RelName, attr:AttrName) extends ValueDescription
 
-case class DatabaseDesc(relationdescs:Map[Relation,RelationDesc])
-case class RelationDesc(primarykey:Option[Attribute], attributes:Map[Attribute, ValueDescription])
+case class DatabaseDesc(relationdescs:Map[RelName,RelationDesc])
+case class RelationDesc(primarykey:Option[AttrName], attributes:Map[AttrName, ValueDescription])
 sealed abstract class FieldDescOrKeyDeclaration
-case class FieldDesc(attr:Attribute, value:Value, pkness:Boolean) extends FieldDescOrKeyDeclaration
+case class FieldDesc(attr:AttrName, value:Value, pkness:Boolean) extends FieldDescOrKeyDeclaration
 sealed abstract class KeyDeclaration extends FieldDescOrKeyDeclaration
-case class PrimaryKeyDeclaration(attr:Attribute) extends KeyDeclaration
-case class ForeignKeyDeclaration(fk:Attribute, rel:Relation, pk:Attribute) extends KeyDeclaration
-case class View(rel:Relation, defn:SelectORUnion) { // sibling of RelationDesc
+case class PrimaryKeyDeclaration(attr:AttrName) extends KeyDeclaration
+case class ForeignKeyDeclaration(fk:AttrName, rel:RelName, pk:AttrName) extends KeyDeclaration
+case class View(rel:RelName, defn:SelectORUnion) { // sibling of RelationDesc
   override def toString = "CREATE VIEW " + rel + " AS\n" + defn
 }
 
@@ -195,19 +278,19 @@
   def ddl:Parser[DatabaseDesc] =
     rep1sep(createtable, ";") ~ opt(";") ^^
   {
-    case l~x => DatabaseDesc(l.foldLeft(Map[Relation, RelationDesc]())((m, p) => {
-      val (rel:Relation, desc:RelationDesc) = p
+    case l~x => DatabaseDesc(l.foldLeft(Map[RelName, RelationDesc]())((m, p) => {
+      val (rel:RelName, desc:RelationDesc) = p
       m + (rel -> desc)
     }))
   }
 
-  def createtable:Parser[(Relation, RelationDesc)] =
+  def createtable:Parser[(RelName, RelationDesc)] =
     "CREATE" ~ "TABLE" ~ relation ~ "(" ~ rep1sep(fielddescorkeydef, ",") ~ ")" ^^
   {
     case "CREATE"~"TABLE"~relation~"("~reldesc~")" => {
-      val pk0:Option[Attribute] = None
-      val attrs0 = Map[Attribute, ValueDescription]()
-      val fks0 = Map[Attribute, ForeignKey]()
+      val pk0:Option[AttrName] = None
+      val attrs0 = Map[AttrName, ValueDescription]()
+      val fks0 = Map[AttrName, ForeignKey]()
       /* <pk>: (most recently parsed) PRIMARY KEY
        * <attrs>: map of attribute to type (e.g. INTEGER)
        * <fks>: map holding FOREIGN KEY relation REFERENCES attr
@@ -232,7 +315,7 @@
        * The type isn't really lost -- it's the same as the referenced type.
        */
       val attrs2 = attrs.map(x => {
-	val (attr:Attribute, value:Value) = x
+	val (attr:AttrName, value:Value) = x
 	if (fks.contains(attr))	(attr -> fks(attr))
 	else (attr -> value)
       })
@@ -262,7 +345,7 @@
     rep1sep(select, "UNION") ^^ { l => if (l.size == 1) l(0) else Union(l.toSet) }
 
   def select:Parser[Select] =
-    "SELECT" ~ opt("DISTINCT") ~ attributelist ~ opt(tablelist) ~ opt(where) ~ opt(order) ~ opt(offset) ~ opt(limit) ^^
+    "SELECT" ~ opt("DISTINCT") ~ projection ~ opt(tablelist) ~ opt(where) ~ opt(order) ~ opt(offset) ~ opt(limit) ^^
     {
       case "SELECT" ~ distinct ~ attributes ~ tablesANDons ~ whereexpr ~ order ~ offset ~ limit => {
 	val (tables, onExpressions) =
@@ -306,13 +389,13 @@
   def where:Parser[Expression] =
     "WHERE" ~ expression ^^ { case "WHERE" ~ expression => expression }
 
-  def attributelist:Parser[AttributeList] =
-    repsep(namedattribute, ",") ^^ { l => AttributeList(l.toSet) }
+  def projection:Parser[Projection] =
+    repsep(namedattribute, ",") ^^ { l => Projection(l.toSet) }
 
-  def namedattribute:Parser[NamedAttribute] =
+  def namedattribute:Parser[ProjectAttribute] =
     fqattributeORprimaryexpression ~ "AS" ~ attralias ^^
     { case fqattributeORprimaryexpression ~ "AS" ~ attralias =>
-      NamedAttribute(fqattributeORprimaryexpression, attralias) }
+      ProjectAttribute(fqattributeORprimaryexpression, attralias) }
 
   def fqattributeORprimaryexpression:Parser[RelVarAttrORExpression] = (
       fqattribute ^^ { case fqattribute => fqattribute }
@@ -323,8 +406,8 @@
     relvar ~ "." ~ attribute ^^
     { case relvar ~ "." ~ attribute => RelVarAttr(relvar, attribute) }
 
-  def attribute:Parser[Attribute] =
-    """[a-zA-Z_]\w*""".r ^^ { x => Attribute(Name(x)) }
+  def attribute:Parser[AttrName] =
+    """[a-zA-Z_]\w*""".r ^^ { x => AttrName(x) }
 
   def attralias:Parser[AttrAlias] =
     """[a-zA-Z_]\w*""".r ^^ { x => AttrAlias(Name(x)) }
@@ -334,8 +417,8 @@
     | "(" ~ selectORunion ~ ")" ^^ { case "("~s~")" => Subselect(s) }
   )
 
-  def relation:Parser[Relation] =
-    """[a-zA-Z_]\w*""".r ^^ { x => Relation(Name(x)) }
+  def relation:Parser[RelName] =
+    """[a-zA-Z_]\w*""".r ^^ { x => RelName(x) }
 
   def relvar:Parser[RelVar] =
     """[a-zA-Z_]\w*""".r ^^ { x => RelVar(Name(x)) }
@@ -398,7 +481,7 @@
 
 case class PrettySql(select:Select) {
   def makePretty():Select = {
-    val Select(distinct, attributelist, tablelist, expression, order, offset, limit) = select
+    val Select(distinct, projection, tablelist, expression, order, offset, limit) = select
     val nullStripped =
       if (expression.isDefined) {
 	val nonNullAttrs = PrettySql.findNonNullRelVarAttrs(expression.get)
@@ -415,15 +498,15 @@
 	case InnerJoin(AliasedResource(rel, as), optOn) => InnerJoin(AliasedResource({ rel match {
 	  case Subselect(s:Select) => Subselect(PrettySql(s).makePretty())
 	  case Subselect(Union(disjoints)) => Subselect(Union(disjoints.map(s => PrettySql(s).makePretty())))
-	  case r:Relation => r
+	  case r:RelName => r
 	}}, as), None)
 	case LeftOuterJoin(AliasedResource(rel, as), on:Expression) => LeftOuterJoin(AliasedResource({ rel match {
 	  case Subselect(s:Select) => Subselect(PrettySql(s).makePretty())
 	  case Subselect(Union(disjoints)) => Subselect(Union(disjoints.map(s => PrettySql(s).makePretty())))
-	  case r:Relation => r
+	  case r:RelName => r
 	}}, as), on)
       }})
-    Select(distinct, attributelist, TableList(strippedTables), XeqXStripped, order, offset, limit)
+    Select(distinct, projection, TableList(strippedTables), XeqXStripped, order, offset, limit)
   }
 }
 

--- a/src/main/scala/Servlet.scala	Fri Oct 08 15:58:19 2010 -0400
+++ b/src/main/scala/Servlet.scala	Wed Oct 13 23:21:16 2010 -0400
@@ -8,7 +8,7 @@
 import java.sql.{Types => T}
 
 import java.net.URI
-import w3c.sw.sql.{Sql,DatabaseDesc,Relation,RelationDesc,Attribute,Value,Datatype,ForeignKey,Name}
+import w3c.sw.sql.{Sql,DatabaseDesc,RelName,RelationDesc,AttrName,Value,Datatype,ForeignKey,Name}
 import w3c.sw.sparql
 import w3c.sw.sparql.Sparql
 import w3c.sw.sql

--- a/src/main/scala/SparqlToSparqlToSql.scala	Fri Oct 08 15:58:19 2010 -0400
+++ b/src/main/scala/SparqlToSparqlToSql.scala	Wed Oct 13 23:21:16 2010 -0400
@@ -18,18 +18,18 @@
 
       /* ... turn each triple pattern in the rule heads into a SQL pattern. */
       rule.head.triplepatterns.foldLeft(allgps)((gps, triple) => {
-	def substituteVar (term:sparql.Term, label:String, triple:sparql.TriplePattern):(sparql.Term, List[sparql.Var], List[sql.NamedAttribute]) = {
+	def substituteVar (term:sparql.Term, label:String, triple:sparql.TriplePattern):(sparql.Term, List[sparql.Var], List[sql.ProjectAttribute]) = {
 	  term match {
-	    case sparql.TermVar(v) => (sparql.TermVar(sparql.Var(label)), List(sparql.Var(label)), List[sql.NamedAttribute]())
+	    case sparql.TermVar(v) => (sparql.TermVar(sparql.Var(label)), List(sparql.Var(label)), List[sql.ProjectAttribute]())
 	    case sparql.TermUri(u) => (term, List[sparql.Var](), List(
-	      sql.NamedAttribute(sql.PrimaryExpressionTyped(sql.Datatype.STRING,sql.Name(u.toString)),
-				 sql.AttrAlias(sql.Name(label)))))
+	      sql.ProjectAttribute(sql.PrimaryExpressionTyped(sql.Datatype.STRING,sql.Name(u.toString)),
+				   sql.AttrAlias(sql.Name(label)))))
 	    case sparql.TermBNode(b) => (term, List[sparql.Var](), List(
-	      sql.NamedAttribute(sql.PrimaryExpressionTyped(sql.Datatype.STRING,sql.Name(b.toString + "(" + triple + ")")),
-				 sql.AttrAlias(sql.Name(label)))))
+	      sql.ProjectAttribute(sql.PrimaryExpressionTyped(sql.Datatype.STRING,sql.Name(b.toString + "(" + triple + ")")),
+				   sql.AttrAlias(sql.Name(label)))))
 	    case sparql.TermLit(l) => (term, List[sparql.Var](), List(
-	      sql.NamedAttribute(sql.PrimaryExpressionTyped(sql.Datatype.STRING,sql.Name(l.toString)),
-				 sql.AttrAlias(sql.Name(label)))))
+	      sql.ProjectAttribute(sql.PrimaryExpressionTyped(sql.Datatype.STRING,sql.Name(l.toString)),
+				   sql.AttrAlias(sql.Name(label)))))
 	  }
 	}
 
@@ -51,11 +51,11 @@
 	val asStem = sparql2sparql.SparqlToSparql(select, List(sparql2sparql.SparqlMap(rule, emptyPatternMap)))
 	// println("triple: "+triple)
 	// println("asStem: "+asStem)
-	val sql.Select(distinct, sql.AttributeList(attributes), tablelist, expression, order,  offset, limit) = sparql2sql.SparqlToSql(schema, asStem, stemUri, false, true)._1
-	// println("SQL: "+sql.Select(sql.AttributeList(attributes ++ sconsts ++ pconsts ++ oconsts), tablelist, expression))
+	val sql.Select(distinct, sql.Projection(attributes), tablelist, expression, order,  offset, limit) = sparql2sql.SparqlToSql(schema, asStem, stemUri, false, true)._1
+	// println("SQL: "+sql.Select(sql.Projection(attributes ++ sconsts ++ pconsts ++ oconsts), tablelist, expression))
 
 	/* Add resulting SELECT to list of graph patterns. */
-	gps :+ sql.Select(distinct, sql.AttributeList(attributes ++ sconsts ++ pconsts ++ oconsts), tablelist, expression, order, offset, limit)
+	gps :+ sql.Select(distinct, sql.Projection(attributes ++ sconsts ++ pconsts ++ oconsts), tablelist, expression, order, offset, limit)
       })
     })
 
@@ -65,7 +65,7 @@
       case 1 => disjoints.toList(0)
       case _ => sql.Union(disjoints.toSet)
     }
-    sql.View(sql.Relation(sql.Name("triples")), body)
+    sql.View(sql.RelName("triples"), body)
   }
 }
 

--- a/src/main/scala/SparqlToSql.scala	Fri Oct 08 15:58:19 2010 -0400
+++ b/src/main/scala/SparqlToSql.scala	Wed Oct 13 23:21:16 2010 -0400
@@ -20,7 +20,7 @@
 import w3c.sw.util
 
 case class StemURI(s:String)
-case class PrimaryKey(attr:sql.Attribute)
+case class PrimaryKey(attr:sql.AttrName)
 
 sealed abstract class Binding
 case class RDFNode(relvarattr:sql.RelVarAttr) extends Binding
@@ -109,11 +109,11 @@
   /**
    * map to a URL for a tuple in the database.
    */
-  case class RDFNoder(relation:sql.Relation, binding:FullOrPartialBinding) extends SQL2RDFValueMapper(binding)
+  case class RDFNoder(relation:sql.RelName, binding:FullOrPartialBinding) extends SQL2RDFValueMapper(binding)
   /**
    * map to a blank node label for a tuple in the database.
    */
-  case class RDFBNoder(relation:sql.Relation, binding:FullOrPartialBinding) extends SQL2RDFValueMapper(binding)
+  case class RDFBNoder(relation:sql.RelName, binding:FullOrPartialBinding) extends SQL2RDFValueMapper(binding)
 
   /**
    * a URL representing a tuple in a database.
@@ -224,7 +224,7 @@
    * <p/>
    * e.g. <code>?emp</code> =&gt;<code>emp</code>
    */
-  def attrAliasNameFromVar(v:sparql.Assignable):sql.Name = sql.Name("" + v.s)
+  def attrAliasNameFromVar(v:sparql.Assignable):String = "" + v.s
 
   /**
    * add constraints implied by a URI
@@ -279,8 +279,8 @@
    *   return: (VarAssignable(?emp),RDFNoder(Employee,FullBinding(R_emp.empid)))
    *   which maps 4 to &lt;http://hr.example/our/favorite/DB/Employee/id.4#record&gt;
    */
-  def varConstraint(state:R2RState, alias:sql.RelVar, optAttr:Option[sql.Attribute], v:sparql.Assignable, db:sql.DatabaseDesc, rel:sql.Relation):R2RState = {
-    val constrainMe = if (optAttr.isDefined) sql.RelVarAttr(alias, optAttr.get) else sql.RelVarAttr(alias, sql.Attribute(sql.Name("_no_such_attribute")))
+  def varConstraint(state:R2RState, alias:sql.RelVar, optAttr:Option[sql.AttrName], v:sparql.Assignable, db:sql.DatabaseDesc, rel:sql.RelName):R2RState = {
+    val constrainMe = if (optAttr.isDefined) sql.RelVarAttr(alias, optAttr.get) else sql.RelVarAttr(alias, sql.AttrName("_no_such_attribute"))
     val reldesc = db.relationdescs(rel)
     val boundTo = FullBinding(constrainMe)
 
@@ -289,7 +289,7 @@
      */
     val binding = reldesc.primarykey match {
       /** <pre>varConstraint(R_emp, Some(empid), VarAssignable(?emp), Employee) -&gt; RDFNoder(Employee,FullBinding(R_emp.empid))</pre> */
-      case Some(sql.Attribute(constrainMe.attribute.n)) => RDFNoder(rel, boundTo)
+      case Some(sql.AttrName(constrainMe.attribute.n)) => RDFNoder(rel, boundTo)
       case _ => {
 
 	if (reldesc.attributes.contains(constrainMe.attribute)) {
@@ -345,7 +345,7 @@
   }
 
   def toString(relvarattr:sql.RelVarAttr) : String = {
-    relvarattr.relvar.n.s + "." + relvarattr.attribute.n.s
+    relvarattr.relvar.n.s + "." + relvarattr.attribute.n
   }
   // def toString(mapper:SQL2RDFValueMapper) : String = {
   //   mapper match {
@@ -374,8 +374,8 @@
       case sparql.TermUri(uri) => {
 	val PUri(stem, spRel, spAttr) = parsePredicateURI(uri)
 	/** The relation and attribute come from the predicate, e.g. Employee.fname =&gt; Employee and fname. */
-	val rel = sql.Relation(sql.Name(spRel.s))
-	val attr = sql.Attribute(sql.Name(spAttr.s))
+	val rel = sql.RelName(spRel.s)
+	val attr = sql.AttrName(spAttr.s)
 
 	/**
 	 * The particular join for e.g. Employee is controled by the subject.
@@ -629,7 +629,7 @@
 		    nestedVarmap:Map[sparql.Assignable, SQL2RDFValueMapper],
 		    isOpt:Boolean):R2RState = {
 
-    val varAliasAttr = sql.RelVarAttr(optionalAlias, sql.Attribute(attrAliasNameFromVar(v)))
+    val varAliasAttr = sql.RelVarAttr(optionalAlias, sql.AttrName(attrAliasNameFromVar(v)))
     if (startState.varmap.contains(v)) {
 
       /** The variable has already been bound. */
@@ -739,17 +739,17 @@
      * coreference constraints against ?v2 should only be enforced for
      * tuples from the right side of this union.
      */
-    val pathNo = sql.NamedAttribute(sql.PrimaryExpressionTyped(sql.Datatype.INTEGER,sql.Name("" + initState.joins.size)),
+    val pathNo = sql.ProjectAttribute(sql.PrimaryExpressionTyped(sql.Datatype.INTEGER,sql.Name("" + initState.joins.size)),
 					sql.AttrAlias(sql.Name("_DISJOINT_")))
     val leftJoinVars = gp.findVars
-    val attrlist:Set[sql.NamedAttribute] = leftJoinVars.map(
+    val attrlist:Set[sql.ProjectAttribute] = leftJoinVars.map(
       v =>
-	sql.NamedAttribute(varToAttribute(nestedState.varmap, sparql.VarAssignable(v)),
+	sql.ProjectAttribute(varToAttribute(nestedState.varmap, sparql.VarAssignable(v)),
 			   sql.AttrAlias(attrAliasNameFromVar(sparql.VarAssignable(v))))
     ) + pathNo // add join number to selections
     val subselect = sql.Select(
       false,
-      sql.AttributeList(attrlist),
+      sql.Projection(attrlist),
       sql.TableList(nestedState.joins),
       nestedState.exprs.size match {
       	case 0 => None
@@ -763,7 +763,7 @@
      * _DISJOINT_ as OPTIONAL behaves pretty much like a disjunction).
      */
     val nestedCond = sql.RelationalExpressionNull(sql.PrimaryExpressionAttr(
-      sql.RelVarAttr(leftJoinAlias, sql.Attribute(sql.Name("_DISJOINT_")))))
+      sql.RelVarAttr(leftJoinAlias, sql.AttrName("_DISJOINT_"))))
 
     /** Bind variables to the attributes projected from the subselect;
      * handle corefs (equivalence with earlier bindings).
@@ -795,7 +795,7 @@
        )
     val exprs =
       if (negate) {
-	initState.exprs + sql.RelationalExpressionNull(sql.PrimaryExpressionAttr(sql.RelVarAttr(leftJoinAlias, sql.Attribute(sql.Name("_DISJOINT_")))))
+	initState.exprs + sql.RelationalExpressionNull(sql.PrimaryExpressionAttr(sql.RelVarAttr(leftJoinAlias, sql.AttrName("_DISJOINT_"))))
       } else initState.exprs
     R2RState(initState.joins + join, outerState2.varmap, exprs)
   }
@@ -862,7 +862,7 @@
 	    R2RState(state.joins + sql.InnerJoin(sql.AliasedResource(sql.Subselect(
 	      sql.Select(
 		false, 
-		sql.AttributeList(Set(sql.NamedAttribute(sql.PrimaryExpressionTyped(sql.Datatype.INTEGER,sql.Name("1")),
+		sql.Projection(Set(sql.ProjectAttribute(sql.PrimaryExpressionTyped(sql.Datatype.INTEGER,sql.Name("1")),
 							 sql.AttrAlias(sql.Name("_EMPTY_"))))),
 		sql.TableList(util.AddOrderedSet()),
 		None, List[sql.OrderElt](), None, None
@@ -937,17 +937,17 @@
 	   * coreference constraints against ?v2 should only be enforced for
 	   * tuples from the right side of this union.
 	   */
-	  val pathNo = sql.NamedAttribute(uniqueConst,
+	  val pathNo = sql.ProjectAttribute(uniqueConst,
 					  sql.AttrAlias(sql.Name("_DISJOINT_")))
 
-	  val attrlist:Set[sql.NamedAttribute] = unionVars.foldLeft(Set(pathNo))((attrs, v) => {
+	  val attrlist:Set[sql.ProjectAttribute] = unionVars.foldLeft(Set(pathNo))((attrs, v) => {
 	    val attrOrNull = if (disjointState.varmap.contains(sparql.VarAssignable(v))) varToAttribute(disjointState.varmap, sparql.VarAssignable(v)) else sql.ConstNULL()
-	    attrs ++ Set(sql.NamedAttribute(attrOrNull, sql.AttrAlias(attrAliasNameFromVar(sparql.VarAssignable(v)))))
+	    attrs ++ Set(sql.ProjectAttribute(attrOrNull, sql.AttrAlias(attrAliasNameFromVar(sparql.VarAssignable(v)))))
 	  })
 
 	  val subselect = sql.Select(
 	    false,
-	    sql.AttributeList(attrlist),
+	    sql.Projection(attrlist),
 	    sql.TableList(disjointState.joins),
 	    disjointState.exprs.size match {
 	      case 0 => None
@@ -968,7 +968,7 @@
 	  val (disjointState, disjointVars, uniqueConst) = state
 
 	  /** Create a condition to test if this disjoint was matched. */
-	  val disjointCond = sql.RelationalExpressionNe(sql.PrimaryExpressionAttr(sql.RelVarAttr(unionAlias, sql.Attribute(sql.Name("_DISJOINT_")))),
+	  val disjointCond = sql.RelationalExpressionNe(sql.PrimaryExpressionAttr(sql.RelVarAttr(unionAlias, sql.AttrName("_DISJOINT_"))),
 							uniqueConst)
 	  val outerState2 = disjointVars.foldLeft(outerState)((myState, v) =>
 	      subselectVars(myState, sparql.VarAssignable(v), unionAlias, disjointCond, outerState.varmap, disjointState.varmap, false))
@@ -1023,9 +1023,9 @@
      * Select the attributes corresponding to the variables
      * in the SPARQL SELECT.
      */
-    val attrlist:Set[sql.NamedAttribute] =
+    val attrlist:Set[sql.ProjectAttribute] =
       // This foldLeft could be a map, if i could coerce to a set afterwards.
-      sparquery.attrs.attributelist.foldLeft(Set[sql.NamedAttribute]())((attrs, v) => {
+      sparquery.attrs.attributelist.foldLeft(Set[sql.ProjectAttribute]())((attrs, v) => {
 	val exp =
 	  if (concat)
 	    // generate CONCAT expression for keys.
@@ -1034,13 +1034,13 @@
 	    varToAttribute(r2rState.varmap, sparql.VarAssignable(v))
 	/** Projection alias. */
 	val as = sql.AttrAlias(attrAliasNameFromVar(sparql.VarAssignable(v)))
-	attrs + sql.NamedAttribute(exp , as)
+	attrs + sql.ProjectAttribute(exp , as)
       })
 
     /** Construct the generated query as an abstract syntax. */
     val select = sql.Select(
       sparquery.distinct,
-      sql.AttributeList(attrlist),
+      sql.Projection(attrlist),
       sql.TableList(r2rState.joins),
       r2rState.exprs.size match {
 	case 0 => None
@@ -1155,7 +1155,7 @@
    * @param stem  stem URI for all generated RDF URIs.
    */
   def binding (name:String, value:String, varmap:Map[sparql.Assignable, SparqlToSql.SQL2RDFValueMapper], stem:StemURI) : String = {
-    def getattr (b:SparqlToSql.FullOrPartialBinding) : sql.Attribute = {
+    def getattr (b:SparqlToSql.FullOrPartialBinding) : sql.AttrName = {
       b match {
 	case SparqlToSql.FullBinding(sql.RelVarAttr(_, attr)) =>
 	  attr

--- a/src/test/scala/SQLTest.scala	Fri Oct 08 15:58:19 2010 -0400
+++ b/src/test/scala/SQLTest.scala	Wed Oct 13 23:21:16 2010 -0400
@@ -13,10 +13,10 @@
 R_manager.id=R_emp.manager AND R_emp.lastName IS NOT NULL AND R_manager.lastName IS NOT NULL
 """
     val expected = ExprConjunction(Set(
-      RelationalExpressionEq(PrimaryExpressionAttr(RelVarAttr(RelVar(Name("R_manager")),Attribute(Name("id")))),
-			     PrimaryExpressionAttr(RelVarAttr(RelVar(Name("R_emp")),Attribute(Name("manager"))))),
-      RelationalExpressionNotNull(PrimaryExpressionAttr(RelVarAttr(RelVar(Name("R_emp")),Attribute(Name("lastName"))))),
-      RelationalExpressionNotNull(PrimaryExpressionAttr(RelVarAttr(RelVar(Name("R_manager")),Attribute(Name("lastName")))))))
+      RelationalExpressionEq(PrimaryExpressionAttr(RelVarAttr(RelVar(Name("R_manager")),AttrName("id"))),
+			     PrimaryExpressionAttr(RelVarAttr(RelVar(Name("R_emp")),AttrName("manager")))),
+      RelationalExpressionNotNull(PrimaryExpressionAttr(RelVarAttr(RelVar(Name("R_emp")),AttrName("lastName")))),
+      RelationalExpressionNotNull(PrimaryExpressionAttr(RelVarAttr(RelVar(Name("R_manager")),AttrName("lastName"))))))
     assert(expected === (a.parseAll(a.expression, e).get))
   }
 
@@ -27,10 +27,10 @@
 R_manager.id=R_emp.manager OR R_emp.lastName IS NOT NULL OR R_manager.lastName IS NOT NULL
 """
     val expected = ExprDisjunction(Set(
-      RelationalExpressionEq(PrimaryExpressionAttr(RelVarAttr(RelVar(Name("R_manager")),Attribute(Name("id")))),
-			     PrimaryExpressionAttr(RelVarAttr(RelVar(Name("R_emp")),Attribute(Name("manager"))))),
-      RelationalExpressionNotNull(PrimaryExpressionAttr(RelVarAttr(RelVar(Name("R_emp")),Attribute(Name("lastName"))))),
-      RelationalExpressionNotNull(PrimaryExpressionAttr(RelVarAttr(RelVar(Name("R_manager")),Attribute(Name("lastName")))))))
+      RelationalExpressionEq(PrimaryExpressionAttr(RelVarAttr(RelVar(Name("R_manager")),AttrName("id"))),
+			     PrimaryExpressionAttr(RelVarAttr(RelVar(Name("R_emp")),AttrName("manager")))),
+      RelationalExpressionNotNull(PrimaryExpressionAttr(RelVarAttr(RelVar(Name("R_emp")),AttrName("lastName")))),
+      RelationalExpressionNotNull(PrimaryExpressionAttr(RelVarAttr(RelVar(Name("R_manager")),AttrName("lastName"))))))
     assert(expected === (a.parseAll(a.expression, e).get))
   }
 
@@ -41,10 +41,10 @@
 ( R_manager.id=R_emp.manager OR R_emp.lastName IS NOT NULL OR R_manager.lastName IS NOT NULL )
 """
     val expected = ExprDisjunction(Set(
-      RelationalExpressionEq(PrimaryExpressionAttr(RelVarAttr(RelVar(Name("R_manager")),Attribute(Name("id")))),
-			     PrimaryExpressionAttr(RelVarAttr(RelVar(Name("R_emp")),Attribute(Name("manager"))))),
-      RelationalExpressionNotNull(PrimaryExpressionAttr(RelVarAttr(RelVar(Name("R_emp")),Attribute(Name("lastName"))))),
-      RelationalExpressionNotNull(PrimaryExpressionAttr(RelVarAttr(RelVar(Name("R_manager")),Attribute(Name("lastName")))))))
+      RelationalExpressionEq(PrimaryExpressionAttr(RelVarAttr(RelVar(Name("R_manager")),AttrName("id"))),
+			     PrimaryExpressionAttr(RelVarAttr(RelVar(Name("R_emp")),AttrName("manager")))),
+      RelationalExpressionNotNull(PrimaryExpressionAttr(RelVarAttr(RelVar(Name("R_emp")),AttrName("lastName")))),
+      RelationalExpressionNotNull(PrimaryExpressionAttr(RelVarAttr(RelVar(Name("R_manager")),AttrName("lastName"))))))
     assert(expected === (a.parseAll(a.expression, e).get))
   }
 
@@ -56,7 +56,7 @@
 """
     val expected = Select(
       false,
-      AttributeList(Set(NamedAttribute(PrimaryExpressionTyped(Datatype.INTEGER,Name("1")),
+      Projection(Set(ProjectAttribute(PrimaryExpressionTyped(Datatype.INTEGER,Name("1")),
 				       AttrAlias(Name("_TEST_"))))),
       TableList(AddOrderedSet()),
       None, List[OrderElt](), None, None)
@@ -74,20 +74,20 @@
 """
     val expected = Select(
       false,
-      AttributeList(Set(NamedAttribute(RelVarAttr(RelVar(Name("R_emp")),
-						  Attribute(Name("lastName"))),
+      Projection(Set(ProjectAttribute(RelVarAttr(RelVar(Name("R_emp")),
+						  AttrName("lastName")),
 				       AttrAlias(Name("A_empName"))))),
-      TableList(AddOrderedSet(InnerJoin(AliasedResource(Relation(Name("Employee")),RelVar(Name("R_emp"))), None),
-			      InnerJoin(AliasedResource(Relation(Name("Employee")),RelVar(Name("R_manager"))), None))),
+      TableList(AddOrderedSet(InnerJoin(AliasedResource(RelName("Employee"),RelVar(Name("R_emp"))), None),
+			      InnerJoin(AliasedResource(RelName("Employee"),RelVar(Name("R_manager"))), None))),
       Some(
-	RelationalExpressionEq(PrimaryExpressionAttr(RelVarAttr(RelVar(Name("R_manager")),Attribute(Name("id")))),
-			       PrimaryExpressionAttr(RelVarAttr(RelVar(Name("R_emp")),Attribute(Name("manager")))))),
+	RelationalExpressionEq(PrimaryExpressionAttr(RelVarAttr(RelVar(Name("R_manager")),AttrName("id"))),
+			       PrimaryExpressionAttr(RelVarAttr(RelVar(Name("R_emp")),AttrName("manager"))))),
       List[OrderElt](), None, None)
     assert(expected === (a.parseAll(a.select, e).get))
   }
 
   test("parse INNER JOIN ON") {
-    // AliasedResource(Relation(Name("Employee")),RelVar(Name("R_emp")))
+    // AliasedResource(RelName("Employee"),RelVar(Name("R_emp")))
     val a = Sql()
     val e = """
 SELECT R_emp.lastName AS A_empName
@@ -96,20 +96,20 @@
 """
     val expected = Select(
       false,
-      AttributeList(Set(NamedAttribute(RelVarAttr(RelVar(Name("R_emp")),
-						  Attribute(Name("lastName"))),
+      Projection(Set(ProjectAttribute(RelVarAttr(RelVar(Name("R_emp")),
+						  AttrName("lastName")),
 				       AttrAlias(Name("A_empName"))))),
-      TableList(AddOrderedSet(InnerJoin(AliasedResource(Relation(Name("Employee")),RelVar(Name("R_emp"))), None),
-			      InnerJoin(AliasedResource(Relation(Name("Employee")),RelVar(Name("R_manager"))), None))),
+      TableList(AddOrderedSet(InnerJoin(AliasedResource(RelName("Employee"),RelVar(Name("R_emp"))), None),
+			      InnerJoin(AliasedResource(RelName("Employee"),RelVar(Name("R_manager"))), None))),
       Some(
-	RelationalExpressionEq(PrimaryExpressionAttr(RelVarAttr(RelVar(Name("R_manager")),Attribute(Name("id")))),
-			       PrimaryExpressionAttr(RelVarAttr(RelVar(Name("R_emp")),Attribute(Name("manager")))))),
+	RelationalExpressionEq(PrimaryExpressionAttr(RelVarAttr(RelVar(Name("R_manager")),AttrName("id"))),
+			       PrimaryExpressionAttr(RelVarAttr(RelVar(Name("R_emp")),AttrName("manager"))))),
       List[OrderElt](), None, None)
     assert(expected === (a.parseAll(a.select, e).get))
   }
 
   test("parse SQLbgp") {
-    // AliasedResource(Relation(Name("Employee")),RelVar(Name("R_emp")))
+    // AliasedResource(RelName("Employee"),RelVar(Name("R_emp")))
     val a = Sql()
     val e = """
 SELECT R_emp.lastName AS A_empName, R_manager.lastName AS A_managName
@@ -119,19 +119,19 @@
 """
     val expected = Select(
       false,
-      AttributeList(Set(NamedAttribute(RelVarAttr(RelVar(Name("R_emp")),
-						  Attribute(Name("lastName"))),
+      Projection(Set(ProjectAttribute(RelVarAttr(RelVar(Name("R_emp")),
+						  AttrName("lastName")),
 				       AttrAlias(Name("A_empName"))),
-			NamedAttribute(RelVarAttr(RelVar(Name("R_manager")),
-						  Attribute(Name("lastName"))),
+			ProjectAttribute(RelVarAttr(RelVar(Name("R_manager")),
+						  AttrName("lastName")),
 				       AttrAlias(Name("A_managName"))))),
-      TableList(AddOrderedSet(InnerJoin(AliasedResource(Relation(Name("Employee")),RelVar(Name("R_emp"))), None),
-			      InnerJoin(AliasedResource(Relation(Name("Employee")),RelVar(Name("R_manager"))), None))),
+      TableList(AddOrderedSet(InnerJoin(AliasedResource(RelName("Employee"),RelVar(Name("R_emp"))), None),
+			      InnerJoin(AliasedResource(RelName("Employee"),RelVar(Name("R_manager"))), None))),
       Some(ExprConjunction(Set(
-	RelationalExpressionEq(PrimaryExpressionAttr(RelVarAttr(RelVar(Name("R_manager")),Attribute(Name("id")))),
-			       PrimaryExpressionAttr(RelVarAttr(RelVar(Name("R_emp")),Attribute(Name("manager"))))),
-	RelationalExpressionNotNull(PrimaryExpressionAttr(RelVarAttr(RelVar(Name("R_emp")),Attribute(Name("lastName"))))),
-	RelationalExpressionNotNull(PrimaryExpressionAttr(RelVarAttr(RelVar(Name("R_manager")),Attribute(Name("lastName")))))))),
+	RelationalExpressionEq(PrimaryExpressionAttr(RelVarAttr(RelVar(Name("R_manager")),AttrName("id"))),
+			       PrimaryExpressionAttr(RelVarAttr(RelVar(Name("R_emp")),AttrName("manager")))),
+	RelationalExpressionNotNull(PrimaryExpressionAttr(RelVarAttr(RelVar(Name("R_emp")),AttrName("lastName")))),
+	RelationalExpressionNotNull(PrimaryExpressionAttr(RelVarAttr(RelVar(Name("R_manager")),AttrName("lastName"))))))),
       List[OrderElt](), None, None)
     assert(expected === (a.parseAll(a.select, e).get))
   }
@@ -145,13 +145,13 @@
 """
     val expected = Select(
       false,
-      AttributeList(Set(NamedAttribute(RelVarAttr(RelVar(Name("R_emp")),
-						  Attribute(Name("lastName"))),
+      Projection(Set(ProjectAttribute(RelVarAttr(RelVar(Name("R_emp")),
+						  AttrName("lastName")),
 				       AttrAlias(Name("A_empName"))))),
-      TableList(AddOrderedSet(InnerJoin(AliasedResource(Relation(Name("Employee")),RelVar(Name("R_emp"))), None))),
-      Some(ExprConjunction(Set(RelationalExpressionEq(PrimaryExpressionAttr(RelVarAttr(RelVar(Name("R_emp")),Attribute(Name("manager")))),
+      TableList(AddOrderedSet(InnerJoin(AliasedResource(RelName("Employee"),RelVar(Name("R_emp"))), None))),
+      Some(ExprConjunction(Set(RelationalExpressionEq(PrimaryExpressionAttr(RelVarAttr(RelVar(Name("R_emp")),AttrName("manager"))),
 						      PrimaryExpressionTyped(Datatype.INTEGER,Name("18"))),
-			       RelationalExpressionNotNull(PrimaryExpressionAttr(RelVarAttr(RelVar(Name("R_emp")),Attribute(Name("lastName")))))))),
+			       RelationalExpressionNotNull(PrimaryExpressionAttr(RelVarAttr(RelVar(Name("R_emp")),AttrName("lastName"))))))),
       List[OrderElt](), None, None)
     assert(expected === (a.parseAll(a.select, e).get))
   }
@@ -166,16 +166,16 @@
 """
     val expected = Select(
       false,
-      AttributeList(Set(NamedAttribute(RelVarAttr(RelVar(Name("R_emp")),
-						  Attribute(Name("lastName"))),
+      Projection(Set(ProjectAttribute(RelVarAttr(RelVar(Name("R_emp")),
+						  AttrName("lastName")),
 				       AttrAlias(Name("A_empName"))))),
-      TableList(AddOrderedSet(InnerJoin(AliasedResource(Relation(Name("Employee")),RelVar(Name("R_emp"))), None),
-			      InnerJoin(AliasedResource(Relation(Name("Employee")),RelVar(Name("R_manager"))), None))),
-      Some(ExprConjunction(Set(RelationalExpressionEq(PrimaryExpressionAttr(RelVarAttr(RelVar(Name("R_emp")),Attribute(Name("manager")))),
-						      PrimaryExpressionAttr(RelVarAttr(RelVar(Name("R_manager")),Attribute(Name("id"))))),
-			       RelationalExpressionEq(PrimaryExpressionAttr(RelVarAttr(RelVar(Name("R_manager")),Attribute(Name("lastName")))),
+      TableList(AddOrderedSet(InnerJoin(AliasedResource(RelName("Employee"),RelVar(Name("R_emp"))), None),
+			      InnerJoin(AliasedResource(RelName("Employee"),RelVar(Name("R_manager"))), None))),
+      Some(ExprConjunction(Set(RelationalExpressionEq(PrimaryExpressionAttr(RelVarAttr(RelVar(Name("R_emp")),AttrName("manager"))),
+						      PrimaryExpressionAttr(RelVarAttr(RelVar(Name("R_manager")),AttrName("id")))),
+			       RelationalExpressionEq(PrimaryExpressionAttr(RelVarAttr(RelVar(Name("R_manager")),AttrName("lastName"))),
 						      PrimaryExpressionTyped(Datatype.STRING,Name("Johnson"))),
-			       RelationalExpressionNotNull(PrimaryExpressionAttr(RelVarAttr(RelVar(Name("R_emp")),Attribute(Name("lastName")))))))),
+			       RelationalExpressionNotNull(PrimaryExpressionAttr(RelVarAttr(RelVar(Name("R_emp")),AttrName("lastName"))))))),
       List[OrderElt](), None, None)
     assert(expected === (a.parseAll(a.select, e).get))
   }
@@ -197,29 +197,29 @@
 """
     val expected = Select(
       false,
-      AttributeList(Set(NamedAttribute(RelVarAttr(RelVar(Name("R_emp")), Attribute(Name("lastName"))),
+      Projection(Set(ProjectAttribute(RelVarAttr(RelVar(Name("R_emp")), AttrName("lastName")),
 				       AttrAlias(Name("A_empName"))),
-			NamedAttribute(RelVarAttr(RelVar(Name("R_grandManager")),Attribute(Name("lastName"))),
+			ProjectAttribute(RelVarAttr(RelVar(Name("R_grandManager")),AttrName("lastName")),
 				       AttrAlias(Name("A_grandManagName"))))),
-      TableList(AddOrderedSet(InnerJoin(AliasedResource(Relation(Name("Employee")),RelVar(Name("R_emp"))), None),
-			      InnerJoin(AliasedResource(Relation(Name("Manage")),RelVar(Name("R_lower"))), None),
-			      InnerJoin(AliasedResource(Relation(Name("Employee")),RelVar(Name("R_manager"))), None),
-			      InnerJoin(AliasedResource(Relation(Name("Manage")),RelVar(Name("R_upper"))), None),
-			      InnerJoin(AliasedResource(Relation(Name("Employee")),RelVar(Name("R_grandManager"))), None))),
-      Some(ExprConjunction(Set(RelationalExpressionEq(PrimaryExpressionAttr(RelVarAttr(RelVar(Name("R_lower")),Attribute(Name("manages")))),
-						      PrimaryExpressionAttr(RelVarAttr(RelVar(Name("R_emp")),Attribute(Name("id"))))),
-			       RelationalExpressionEq(PrimaryExpressionAttr(RelVarAttr(RelVar(Name("R_manager")),Attribute(Name("id")))),
-						      PrimaryExpressionAttr(RelVarAttr(RelVar(Name("R_lower")),Attribute(Name("manager"))))),
-			       RelationalExpressionLt(PrimaryExpressionAttr(RelVarAttr(RelVar(Name("R_manager")),Attribute(Name("birthday")))),
-						      PrimaryExpressionAttr(RelVarAttr(RelVar(Name("R_emp")),Attribute(Name("birthday"))))),
-			       RelationalExpressionEq(PrimaryExpressionAttr(RelVarAttr(RelVar(Name("R_upper")),Attribute(Name("manages")))),
-						      PrimaryExpressionAttr(RelVarAttr(RelVar(Name("R_manager")),Attribute(Name("id"))))),
-			       RelationalExpressionEq(PrimaryExpressionAttr(RelVarAttr(RelVar(Name("R_grandManager")),Attribute(Name("id")))),
-						      PrimaryExpressionAttr(RelVarAttr(RelVar(Name("R_upper")),Attribute(Name("manager"))))),
-			       RelationalExpressionLt(PrimaryExpressionAttr(RelVarAttr(RelVar(Name("R_grandManager")),Attribute(Name("birthday")))),
-						      PrimaryExpressionAttr(RelVarAttr(RelVar(Name("R_manager")),Attribute(Name("birthday"))))),
-			       RelationalExpressionNotNull(PrimaryExpressionAttr(RelVarAttr(RelVar(Name("R_emp")),Attribute(Name("lastName"))))),
-			       RelationalExpressionNotNull(PrimaryExpressionAttr(RelVarAttr(RelVar(Name("R_grandManager")),Attribute(Name("lastName")))))))),
+      TableList(AddOrderedSet(InnerJoin(AliasedResource(RelName("Employee"),RelVar(Name("R_emp"))), None),
+			      InnerJoin(AliasedResource(RelName("Manage"),RelVar(Name("R_lower"))), None),
+			      InnerJoin(AliasedResource(RelName("Employee"),RelVar(Name("R_manager"))), None),
+			      InnerJoin(AliasedResource(RelName("Manage"),RelVar(Name("R_upper"))), None),
+			      InnerJoin(AliasedResource(RelName("Employee"),RelVar(Name("R_grandManager"))), None))),
+      Some(ExprConjunction(Set(RelationalExpressionEq(PrimaryExpressionAttr(RelVarAttr(RelVar(Name("R_lower")),AttrName("manages"))),
+						      PrimaryExpressionAttr(RelVarAttr(RelVar(Name("R_emp")),AttrName("id")))),
+			       RelationalExpressionEq(PrimaryExpressionAttr(RelVarAttr(RelVar(Name("R_manager")),AttrName("id"))),
+						      PrimaryExpressionAttr(RelVarAttr(RelVar(Name("R_lower")),AttrName("manager")))),
+			       RelationalExpressionLt(PrimaryExpressionAttr(RelVarAttr(RelVar(Name("R_manager")),AttrName("birthday"))),
+						      PrimaryExpressionAttr(RelVarAttr(RelVar(Name("R_emp")),AttrName("birthday")))),
+			       RelationalExpressionEq(PrimaryExpressionAttr(RelVarAttr(RelVar(Name("R_upper")),AttrName("manages"))),
+						      PrimaryExpressionAttr(RelVarAttr(RelVar(Name("R_manager")),AttrName("id")))),
+			       RelationalExpressionEq(PrimaryExpressionAttr(RelVarAttr(RelVar(Name("R_grandManager")),AttrName("id"))),
+						      PrimaryExpressionAttr(RelVarAttr(RelVar(Name("R_upper")),AttrName("manager")))),
+			       RelationalExpressionLt(PrimaryExpressionAttr(RelVarAttr(RelVar(Name("R_grandManager")),AttrName("birthday"))),
+						      PrimaryExpressionAttr(RelVarAttr(RelVar(Name("R_manager")),AttrName("birthday")))),
+			       RelationalExpressionNotNull(PrimaryExpressionAttr(RelVarAttr(RelVar(Name("R_emp")),AttrName("lastName")))),
+			       RelationalExpressionNotNull(PrimaryExpressionAttr(RelVarAttr(RelVar(Name("R_grandManager")),AttrName("lastName"))))))),
       List[OrderElt](), None, None)
     assert(expected === (a.parseAll(a.select, e).get))
   }
@@ -244,42 +244,42 @@
 """
     val expected = Select(
       false,
-      AttributeList(Set(NamedAttribute(RelVarAttr(RelVar(Name("R_union1")), Attribute(Name("name"))),
+      Projection(Set(ProjectAttribute(RelVarAttr(RelVar(Name("R_union1")), AttrName("name")),
 				       AttrAlias(Name("A_name"))))),
-      TableList(AddOrderedSet(InnerJoin(AliasedResource(Relation(Name("Employee")),RelVar(Name("R_who"))), None),
+      TableList(AddOrderedSet(InnerJoin(AliasedResource(RelName("Employee"),RelVar(Name("R_who"))), None),
 			      InnerJoin(AliasedResource(Subselect(Union(Set(
 				Select(
 				  false,
-				  AttributeList(Set(NamedAttribute(RelVarAttr(RelVar(Name("R_manager")), Attribute(Name("lastName"))),
+				  Projection(Set(ProjectAttribute(RelVarAttr(RelVar(Name("R_manager")), AttrName("lastName")),
 								   AttrAlias(Name("A_name"))), 
-						    NamedAttribute(RelVarAttr(RelVar(Name("R_above")), Attribute(Name("manages"))),
+						    ProjectAttribute(RelVarAttr(RelVar(Name("R_above")), AttrName("manages")),
 								   AttrAlias(Name("A_who"))))),
 				  TableList(AddOrderedSet(
-				    InnerJoin(AliasedResource(Relation(Name("Manage")),RelVar(Name("R_above"))), None),
-				    InnerJoin(AliasedResource(Relation(Name("Employee")),RelVar(Name("R_manager"))), None)
+				    InnerJoin(AliasedResource(RelName("Manage"),RelVar(Name("R_above"))), None),
+				    InnerJoin(AliasedResource(RelName("Employee"),RelVar(Name("R_manager"))), None)
 				  )), 
-				  Some(ExprConjunction(Set(RelationalExpressionEq(PrimaryExpressionAttr(RelVarAttr(RelVar(Name("R_above")),Attribute(Name("manager")))),
-										  PrimaryExpressionAttr(RelVarAttr(RelVar(Name("R_manager")),Attribute(Name("id"))))),
-							   RelationalExpressionNotNull(PrimaryExpressionAttr(RelVarAttr(RelVar(Name("R_manager")),Attribute(Name("lastName")))))))),
+				  Some(ExprConjunction(Set(RelationalExpressionEq(PrimaryExpressionAttr(RelVarAttr(RelVar(Name("R_above")),AttrName("manager"))),
+										  PrimaryExpressionAttr(RelVarAttr(RelVar(Name("R_manager")),AttrName("id")))),
+							   RelationalExpressionNotNull(PrimaryExpressionAttr(RelVarAttr(RelVar(Name("R_manager")),AttrName("lastName"))))))),
 				  List[OrderElt](), None, None), 
 				Select(
 				  false,
-				  AttributeList(Set(NamedAttribute(RelVarAttr(RelVar(Name("R_managed")), Attribute(Name("lastName"))),
+				  Projection(Set(ProjectAttribute(RelVarAttr(RelVar(Name("R_managed")), AttrName("lastName")),
 								   AttrAlias(Name("A_name"))), 
-						    NamedAttribute(RelVarAttr(RelVar(Name("R_below")), Attribute(Name("manager"))),
+						    ProjectAttribute(RelVarAttr(RelVar(Name("R_below")), AttrName("manager")),
 								   AttrAlias(Name("A_who"))))),
 				  TableList(AddOrderedSet(
-				    InnerJoin(AliasedResource(Relation(Name("Manage")),RelVar(Name("R_below"))), None),
-				    InnerJoin(AliasedResource(Relation(Name("Employee")),RelVar(Name("R_managed"))), None)
+				    InnerJoin(AliasedResource(RelName("Manage"),RelVar(Name("R_below"))), None),
+				    InnerJoin(AliasedResource(RelName("Employee"),RelVar(Name("R_managed"))), None)
 				  )), 
-				  Some(ExprConjunction(Set(RelationalExpressionEq(PrimaryExpressionAttr(RelVarAttr(RelVar(Name("R_below")),Attribute(Name("manages")))),
-										  PrimaryExpressionAttr(RelVarAttr(RelVar(Name("R_managed")),Attribute(Name("id"))))),
-							   RelationalExpressionNotNull(PrimaryExpressionAttr(RelVarAttr(RelVar(Name("R_managed")),Attribute(Name("lastName")))))))),
+				  Some(ExprConjunction(Set(RelationalExpressionEq(PrimaryExpressionAttr(RelVarAttr(RelVar(Name("R_below")),AttrName("manages"))),
+										  PrimaryExpressionAttr(RelVarAttr(RelVar(Name("R_managed")),AttrName("id")))),
+							   RelationalExpressionNotNull(PrimaryExpressionAttr(RelVarAttr(RelVar(Name("R_managed")),AttrName("lastName"))))))),
 				  List[OrderElt](), None, None)))),
 							RelVar(Name("R_union1"))), None))), 
-      Some(ExprConjunction(Set(RelationalExpressionEq(PrimaryExpressionAttr(RelVarAttr(RelVar(Name("R_union1")),Attribute(Name("A_who")))),
-						      PrimaryExpressionAttr(RelVarAttr(RelVar(Name("R_who")),Attribute(Name("id"))))),
-			       RelationalExpressionEq(PrimaryExpressionAttr(RelVarAttr(RelVar(Name("R_who")),Attribute(Name("lastName")))),
+      Some(ExprConjunction(Set(RelationalExpressionEq(PrimaryExpressionAttr(RelVarAttr(RelVar(Name("R_union1")),AttrName("A_who"))),
+						      PrimaryExpressionAttr(RelVarAttr(RelVar(Name("R_who")),AttrName("id")))),
+			       RelationalExpressionEq(PrimaryExpressionAttr(RelVarAttr(RelVar(Name("R_who")),AttrName("lastName"))),
 						      PrimaryExpressionTyped(Datatype.STRING,Name("Smith")))))),
       List[OrderElt](), None, None)
     assert(expected === (a.parseAll(a.select, e).get))
@@ -294,14 +294,14 @@
 """
     val expected = Select(
       false,
-      AttributeList(Set(NamedAttribute(RelVarAttr(RelVar(Name("R_above")),
-						  Attribute(Name("manages"))),
+      Projection(Set(ProjectAttribute(RelVarAttr(RelVar(Name("R_above")),
+						  AttrName("manages")),
 				       AttrAlias(Name("A_who"))),
-			NamedAttribute(ConstNULL(),
+			ProjectAttribute(ConstNULL(),
 				       AttrAlias(Name("A_bday"))))),
-      TableList(AddOrderedSet(InnerJoin(AliasedResource(Relation(Name("Manage")),RelVar(Name("R_above"))), None))),
+      TableList(AddOrderedSet(InnerJoin(AliasedResource(RelName("Manage"),RelVar(Name("R_above"))), None))),
       Some(
-	RelationalExpressionNotNull(PrimaryExpressionAttr(RelVarAttr(RelVar(Name("R_above")),Attribute(Name("id")))))),
+	RelationalExpressionNotNull(PrimaryExpressionAttr(RelVarAttr(RelVar(Name("R_above")),AttrName("id"))))),
       List[OrderElt](), None, None)
     assert(expected === (a.parseAll(a.select, e).get))
   }
@@ -314,15 +314,15 @@
        FROM Employee AS R_emp
 """
     val expected = Select(
-      false, AttributeList(Set(NamedAttribute(Concat(List(PrimaryExpressionTyped(Datatype("String"),Name("http://hr.example/DB/")),
+      false, Projection(Set(ProjectAttribute(Concat(List(PrimaryExpressionTyped(Datatype("String"),Name("http://hr.example/DB/")),
 							  PrimaryExpressionTyped(Datatype("String"),Name("Employee")),
 							  PrimaryExpressionTyped(Datatype("String"),Name("/")),
 							  PrimaryExpressionTyped(Datatype("String"),Name("id")),
 							  PrimaryExpressionTyped(Datatype("String"),Name(".")),
-							  PrimaryExpressionAttr(RelVarAttr(RelVar(Name("R_emp")),Attribute(Name("id")))),
+							  PrimaryExpressionAttr(RelVarAttr(RelVar(Name("R_emp")),AttrName("id"))),
 							  PrimaryExpressionTyped(Datatype("String"),Name("#record")))),
 					      AttrAlias(Name("A_emp"))))),
-      TableList(AddOrderedSet(InnerJoin(AliasedResource(Relation(Name("Employee")),RelVar(Name("R_emp"))), None))),
+      TableList(AddOrderedSet(InnerJoin(AliasedResource(RelName("Employee"),RelVar(Name("R_emp"))), None))),
       None, List[OrderElt](), None, None)
     assert(expected === (a.parseAll(a.select, e).get))
   }
@@ -336,19 +336,19 @@
 """
     val expected = Select(
       false,
-      AttributeList(Set(NamedAttribute(RelVarAttr(RelVar(Name("R_above")),
-						  Attribute(Name("manages"))),
+      Projection(Set(ProjectAttribute(RelVarAttr(RelVar(Name("R_above")),
+						  AttrName("manages")),
 				       AttrAlias(Name("A_who"))),
-			NamedAttribute(ConstNULL(),
+			ProjectAttribute(ConstNULL(),
 				       AttrAlias(Name("A_bday"))))),
-      TableList(AddOrderedSet(InnerJoin(AliasedResource(Relation(Name("Manage")),RelVar(Name("R_above"))), None))),
+      TableList(AddOrderedSet(InnerJoin(AliasedResource(RelName("Manage"),RelVar(Name("R_above"))), None))),
       Some(
 	ExprDisjunction(Set(
-	  RelationalExpressionNotNull(PrimaryExpressionAttr(RelVarAttr(RelVar(Name("R_above")),Attribute(Name("id"))))),
+	  RelationalExpressionNotNull(PrimaryExpressionAttr(RelVarAttr(RelVar(Name("R_above")),AttrName("id")))),
 	  ExprConjunction(Set(
-	    RelationalExpressionLt(PrimaryExpressionAttr(RelVarAttr(RelVar(Name("R_above")),Attribute(Name("id")))),
+	    RelationalExpressionLt(PrimaryExpressionAttr(RelVarAttr(RelVar(Name("R_above")),AttrName("id"))),
 				   PrimaryExpressionTyped(Datatype.INTEGER,Name("5"))),
-	    RelationalExpressionLt(PrimaryExpressionAttr(RelVarAttr(RelVar(Name("R_above")),Attribute(Name("id")))),
+	    RelationalExpressionLt(PrimaryExpressionAttr(RelVarAttr(RelVar(Name("R_above")),AttrName("id"))),
 				   PrimaryExpressionTyped(Datatype.INTEGER,Name("3")))
 	  ))))),
       List[OrderElt](), None, None)
@@ -365,19 +365,19 @@
 """
     val expected = Select(
       false,
-      AttributeList(Set(NamedAttribute(RelVarAttr(RelVar(Name("R_emp")),
-						  Attribute(Name("lastName"))),
+      Projection(Set(ProjectAttribute(RelVarAttr(RelVar(Name("R_emp")),
+						  AttrName("lastName")),
 				       AttrAlias(Name("A_empName"))),
-			NamedAttribute(RelVarAttr(RelVar(Name("R_mang")),
-						  Attribute(Name("manageName"))),
+			ProjectAttribute(RelVarAttr(RelVar(Name("R_mang")),
+						  AttrName("manageName")),
 				       AttrAlias(Name("A_manageName"))))),
-      TableList(AddOrderedSet(InnerJoin(AliasedResource(Relation(Name("Employee")),RelVar(Name("R_emp"))), None),
-			      LeftOuterJoin(AliasedResource(Relation(Name("Manage")),RelVar(Name("R_mang"))),
-					    RelationalExpressionEq(PrimaryExpressionAttr(RelVarAttr(RelVar(Name("R_mang")),Attribute(Name("emp")))),
-								   PrimaryExpressionAttr(RelVarAttr(RelVar(Name("R_emp")),Attribute(Name("id"))))
+      TableList(AddOrderedSet(InnerJoin(AliasedResource(RelName("Employee"),RelVar(Name("R_emp"))), None),
+			      LeftOuterJoin(AliasedResource(RelName("Manage"),RelVar(Name("R_mang"))),
+					    RelationalExpressionEq(PrimaryExpressionAttr(RelVarAttr(RelVar(Name("R_mang")),AttrName("emp"))),
+								   PrimaryExpressionAttr(RelVarAttr(RelVar(Name("R_emp")),AttrName("id")))
 								 )))),
       Some(
-	RelationalExpressionNotNull(PrimaryExpressionAttr(RelVarAttr(RelVar(Name("R_emp")),Attribute(Name("lastName")))))
+	RelationalExpressionNotNull(PrimaryExpressionAttr(RelVarAttr(RelVar(Name("R_emp")),AttrName("lastName"))))
       ),
       List[OrderElt](), None, None)
     assert(expected === (a.parseAll(a.select, e).get))
@@ -397,20 +397,20 @@
     val expected = 
       Select(
 	false,
-	AttributeList(Set(NamedAttribute(RelVarAttr(RelVar(Name("R_emp")),Attribute(Name("lastName"))),AttrAlias(Name("A_empName"))),
-			  NamedAttribute(RelVarAttr(RelVar(Name("R_mang")),Attribute(Name("manageName"))),AttrAlias(Name("A_manageName"))))),
-	TableList(AddOrderedSet(InnerJoin(AliasedResource(Relation(Name("Employee")),RelVar(Name("R_emp"))), None),
+	Projection(Set(ProjectAttribute(RelVarAttr(RelVar(Name("R_emp")),AttrName("lastName")),AttrAlias(Name("A_empName"))),
+			  ProjectAttribute(RelVarAttr(RelVar(Name("R_mang")),AttrName("manageName")),AttrAlias(Name("A_manageName"))))),
+	TableList(AddOrderedSet(InnerJoin(AliasedResource(RelName("Employee"),RelVar(Name("R_emp"))), None),
 				LeftOuterJoin(AliasedResource(
 				  Subselect(Select(
 				    false,
-				    AttributeList(Set(NamedAttribute(RelVarAttr(RelVar(Name("R_emp")),Attribute(Name("lastName"))),AttrAlias(Name("A_empName"))),
-								     NamedAttribute(RelVarAttr(RelVar(Name("R_mang")),Attribute(Name("manageName"))),AttrAlias(Name("A_manageName"))))),
-						   TableList(AddOrderedSet(InnerJoin(AliasedResource(Relation(Name("Employee")),RelVar(Name("R_emp"))), None))),
+				    Projection(Set(ProjectAttribute(RelVarAttr(RelVar(Name("R_emp")),AttrName("lastName")),AttrAlias(Name("A_empName"))),
+								     ProjectAttribute(RelVarAttr(RelVar(Name("R_mang")),AttrName("manageName")),AttrAlias(Name("A_manageName"))))),
+						   TableList(AddOrderedSet(InnerJoin(AliasedResource(RelName("Employee"),RelVar(Name("R_emp"))), None))),
 				    None, List[OrderElt](), None, None)),
 				  RelVar(Name("R_mang"))),
-					      RelationalExpressionEq(PrimaryExpressionAttr(RelVarAttr(RelVar(Name("R_mang")),Attribute(Name("emp")))),
-								     PrimaryExpressionAttr(RelVarAttr(RelVar(Name("R_emp")),Attribute(Name("id")))))))),
-	Some(RelationalExpressionNotNull(PrimaryExpressionAttr(RelVarAttr(RelVar(Name("R_emp")),Attribute(Name("lastName")))))),
+					      RelationalExpressionEq(PrimaryExpressionAttr(RelVarAttr(RelVar(Name("R_mang")),AttrName("emp"))),
+								     PrimaryExpressionAttr(RelVarAttr(RelVar(Name("R_emp")),AttrName("id"))))))),
+	Some(RelationalExpressionNotNull(PrimaryExpressionAttr(RelVarAttr(RelVar(Name("R_emp")),AttrName("lastName"))))),
 	List[OrderElt](), None, None)
     assert(expected === (a.parseAll(a.select, e).get))
   }
@@ -420,7 +420,7 @@
     val e = """
 ID INT PRIMARY KEY
 """
-    val expected = FieldDesc(Attribute("ID"), Value(Datatype.INTEGER), true)
+    val expected = FieldDesc(AttrName("ID"), Value(Datatype.INTEGER), true)
     assert(expected === (a.parseAll(a.fielddescorkeydef, e).get))
   }
 
@@ -430,9 +430,9 @@
 CREATE TABLE Sex_DE (ID INT PRIMARY KEY)
 """
     val expected = 
-      (Relation("Sex_DE") -> 
-       RelationDesc(Option(Attribute("ID")),
-		    Map(Attribute("ID") -> Value(Datatype.INTEGER))))
+      (RelName("Sex_DE") -> 
+       RelationDesc(Option(AttrName("ID")),
+		    Map(AttrName("ID") -> Value(Datatype.INTEGER))))
       assert(expected === (a.parseAll(a.createtable, e).get))
   }
 
@@ -442,10 +442,10 @@
 CREATE TABLE Sex_DE (ID INT PRIMARY KEY, EnterpriseEntryID INT)
 """
     val expected = DatabaseDesc(
-      Map(Relation("Sex_DE") -> 
-	  RelationDesc(Option(Attribute("ID")),
-		       Map(Attribute("ID") -> Value(Datatype.INTEGER),
-			   Attribute("EnterpriseEntryID") -> Value(Datatype.INTEGER)))))
+      Map(RelName("Sex_DE") -> 
+	  RelationDesc(Option(AttrName("ID")),
+		       Map(AttrName("ID") -> Value(Datatype.INTEGER),
+			   AttrName("EnterpriseEntryID") -> Value(Datatype.INTEGER)))))
 
     assert(expected === (a.parseAll(a.ddl, e).get))
   }
@@ -456,10 +456,10 @@
 CREATE TABLE Sex_DE (ID INT, EnterpriseEntryID INT, PRIMARY KEY (ID))
 """
     val expected = DatabaseDesc(
-      Map(Relation("Sex_DE") -> 
-	  RelationDesc(Option(Attribute("ID")),
-		       Map(Attribute("ID") -> Value(Datatype.INTEGER),
-			   Attribute("EnterpriseEntryID") -> Value(Datatype.INTEGER)))))
+      Map(RelName("Sex_DE") -> 
+	  RelationDesc(Option(AttrName("ID")),
+		       Map(AttrName("ID") -> Value(Datatype.INTEGER),
+			   AttrName("EnterpriseEntryID") -> Value(Datatype.INTEGER)))))
 
     assert(expected === (a.parseAll(a.ddl, e).get))
   }
@@ -471,16 +471,16 @@
 CREATE TABLE Sex_DE (ID INT PRIMARY KEY, EntryName STRING)
 """
   val expected:DatabaseDesc = DatabaseDesc(
-    Map(Relation("Person") -> 
-	RelationDesc(Option(Attribute("ID")), 
-		     Map(Attribute("ID") -> Value(Datatype.INTEGER),
-			 Attribute("MiddleName") -> Value(Datatype.STRING),
-			 Attribute("DateOfBirth") -> Value(Datatype.DATE),
-			 Attribute("SexDE") -> ForeignKey(Relation("Sex_DE"), Attribute("ID")))),
-	Relation("Sex_DE") -> 
-	RelationDesc(Option(Attribute("ID")),
-		     Map(Attribute("ID") -> Value(Datatype.INTEGER),
-			 Attribute("EntryName") -> Value(Datatype.STRING)))
+    Map(RelName("Person") -> 
+	RelationDesc(Option(AttrName("ID")), 
+		     Map(AttrName("ID") -> Value(Datatype.INTEGER),
+			 AttrName("MiddleName") -> Value(Datatype.STRING),
+			 AttrName("DateOfBirth") -> Value(Datatype.DATE),
+			 AttrName("SexDE") -> ForeignKey(RelName("Sex_DE"), AttrName("ID")))),
+	RelName("Sex_DE") -> 
+	RelationDesc(Option(AttrName("ID")),
+		     Map(AttrName("ID") -> Value(Datatype.INTEGER),
+			 AttrName("EntryName") -> Value(Datatype.STRING)))
       ))
     assert(expected === (a.parseAll(a.ddl, e).get))
   }
@@ -496,42 +496,42 @@
 CREATE TABLE NDCcodes (ID INT PRIMARY KEY, NDC INT, ingredient INT);
 """
   val expected:DatabaseDesc = DatabaseDesc(
-    Map(Relation("Person") -> 
-	RelationDesc(Option(Attribute("ID")), 
-		     Map(Attribute("ID") -> Value(Datatype.INTEGER),
-			 Attribute("MiddleName") -> Value(Datatype.STRING),
-			 Attribute("DateOfBirth") -> Value(Datatype.DATE),
-			 Attribute("SexDE") -> ForeignKey(Relation("Sex_DE"), Attribute("ID")))),
-	Relation("Sex_DE") -> 
-	RelationDesc(Option(Attribute("ID")),
-		     Map(Attribute("ID") -> Value(Datatype.INTEGER),
-			 Attribute("EntryName") -> Value(Datatype.STRING))),
-	Relation("Item_Medication") -> 
-	RelationDesc(Option(Attribute("ID")),
-		     Map(Attribute("ID") -> Value(Datatype.INTEGER),
-			 Attribute("PatientID") -> ForeignKey(Relation("Person"),  Attribute("ID")),
-			 Attribute("PerformedDTTM") -> Value(Datatype.DATE),
-			 Attribute("EntryName") -> Value(Datatype.STRING))),
-	Relation("Medication") -> 
-	RelationDesc(Option(Attribute("ID")),
-		     Map(Attribute("ID") -> Value(Datatype.INTEGER),
-			 Attribute("ItemID") -> ForeignKey(Relation("Item_Medication"),  Attribute("ID")),
-			 Attribute("MedDictDE") -> ForeignKey(Relation("Medication_DE"), Attribute("ID")))),
-	Relation("Medication_DE") -> 
-	RelationDesc(Option(Attribute("ID")),
-		     Map(Attribute("ID") -> Value(Datatype.INTEGER),
-			 Attribute("NDC") -> Value(Datatype.INTEGER))),
-	Relation("NDCcodes") -> 
-	RelationDesc(Option(Attribute("ID")),
-		     Map(Attribute("ID") -> Value(Datatype.INTEGER),
-			 Attribute("NDC") -> Value(Datatype.INTEGER),
-			 Attribute("ingredient") -> Value(Datatype.INTEGER)))
+    Map(RelName("Person") -> 
+	RelationDesc(Option(AttrName("ID")), 
+		     Map(AttrName("ID") -> Value(Datatype.INTEGER),
+			 AttrName("MiddleName") -> Value(Datatype.STRING),
+			 AttrName("DateOfBirth") -> Value(Datatype.DATE),
+			 AttrName("SexDE") -> ForeignKey(RelName("Sex_DE"), AttrName("ID")))),
+	RelName("Sex_DE") -> 
+	RelationDesc(Option(AttrName("ID")),
+		     Map(AttrName("ID") -> Value(Datatype.INTEGER),
+			 AttrName("EntryName") -> Value(Datatype.STRING))),
+	RelName("Item_Medication") -> 
+	RelationDesc(Option(AttrName("ID")),
+		     Map(AttrName("ID") -> Value(Datatype.INTEGER),
+			 AttrName("PatientID") -> ForeignKey(RelName("Person"),  AttrName("ID")),
+			 AttrName("PerformedDTTM") -> Value(Datatype.DATE),
+			 AttrName("EntryName") -> Value(Datatype.STRING))),
+	RelName("Medication") -> 
+	RelationDesc(Option(AttrName("ID")),
+		     Map(AttrName("ID") -> Value(Datatype.INTEGER),
+			 AttrName("ItemID") -> ForeignKey(RelName("Item_Medication"),  AttrName("ID")),
+			 AttrName("MedDictDE") -> ForeignKey(RelName("Medication_DE"), AttrName("ID")))),
+	RelName("Medication_DE") -> 
+	RelationDesc(Option(AttrName("ID")),
+		     Map(AttrName("ID") -> Value(Datatype.INTEGER),
+			 AttrName("NDC") -> Value(Datatype.INTEGER))),
+	RelName("NDCcodes") -> 
+	RelationDesc(Option(AttrName("ID")),
+		     Map(AttrName("ID") -> Value(Datatype.INTEGER),
+			 AttrName("NDC") -> Value(Datatype.INTEGER),
+			 AttrName("ingredient") -> Value(Datatype.INTEGER)))
       ))
     assert(expected === (a.parseAll(a.ddl, e).get))
   }
 
   test("CREATE VIEW") {
-    // AliasedResource(Relation(Name("Employee")),RelVar(Name("R_emp")))
+    // AliasedResource(RelName("Employee"),RelVar(Name("R_emp")))
     val a = Sql()
     val e = """
 CREATE VIEW triples AS SELECT
@@ -540,23 +540,23 @@
             R_emp.lastName AS O
        FROM Employee AS R_emp
 """ // "
-    val expected = View(Relation(Name("triples")), Select(
+    val expected = View(RelName("triples"), Select(
       false,
-      AttributeList(Set(
-	NamedAttribute(Concat(List(PrimaryExpressionTyped(Datatype("String"),Name("http://hr.example/DB/")),
+      Projection(Set(
+	ProjectAttribute(Concat(List(PrimaryExpressionTyped(Datatype("String"),Name("http://hr.example/DB/")),
 				   PrimaryExpressionTyped(Datatype("String"),Name("Employee")),
 				   PrimaryExpressionTyped(Datatype("String"),Name("/")),
 				   PrimaryExpressionTyped(Datatype("String"),Name("empid")),
 				   PrimaryExpressionTyped(Datatype("String"),Name(".")),
-				   PrimaryExpressionAttr(RelVarAttr(RelVar(Name("R_emp")),Attribute(Name("id")))),
+				   PrimaryExpressionAttr(RelVarAttr(RelVar(Name("R_emp")),AttrName("id"))),
 				   PrimaryExpressionTyped(Datatype("String"),Name("#record")))),
 		       AttrAlias(Name("S"))),
-	NamedAttribute(PrimaryExpressionTyped(Datatype.STRING,Name("<http://hr.example/DB/Employee#lastName>")),
+	ProjectAttribute(PrimaryExpressionTyped(Datatype.STRING,Name("<http://hr.example/DB/Employee#lastName>")),
 		       AttrAlias(Name("P"))),
-	NamedAttribute(RelVarAttr(RelVar(Name("R_emp")),
-				  Attribute(Name("lastName"))),
+	ProjectAttribute(RelVarAttr(RelVar(Name("R_emp")),
+				  AttrName("lastName")),
 		       AttrAlias(Name("O"))))), 
-      TableList(AddOrderedSet(InnerJoin(AliasedResource(Relation(Name("Employee")),RelVar(Name("R_emp"))), None))),
+      TableList(AddOrderedSet(InnerJoin(AliasedResource(RelName("Employee"),RelVar(Name("R_emp"))), None))),
       None, List[OrderElt](), None, None))
     assert(expected === (a.parseAll(a.createview, e).get))
   }

--- a/src/test/scala/SparqlToSparqlToSqlTest.scala	Fri Oct 08 15:58:19 2010 -0400
+++ b/src/test/scala/SparqlToSparqlToSqlTest.scala	Wed Oct 13 23:21:16 2010 -0400
@@ -9,7 +9,7 @@
 import java.net.URI
 import w3c.sw.sparql.Sparql
 import w3c.sw.sparql2sparql.{SparqlToSparql,NodePatternMap,NodePattern,SparqlMap}
-import w3c.sw.sql.{Sql,DatabaseDesc,Relation,RelationDesc,Attribute,Value,Datatype,ForeignKey,Name}
+import w3c.sw.sql.{Sql,DatabaseDesc,RelName,RelationDesc,AttrName,Value,Datatype,ForeignKey,Name}
 import w3c.sw.sparql2sql.{SparqlToSql,StemURI}
 import w3c.sw.sparql2sparql2sql.SparqlToSparqlToSql.toView
 

--- a/src/test/scala/SparqlToSqlTest.scala	Fri Oct 08 15:58:19 2010 -0400
+++ b/src/test/scala/SparqlToSqlTest.scala	Wed Oct 13 23:21:16 2010 -0400
@@ -6,7 +6,7 @@
 
 import org.scalatest.FunSuite
 import java.net.URI
-import w3c.sw.sql.{Sql,DatabaseDesc,Relation,RelationDesc,Attribute,Value,Datatype,ForeignKey,Name}
+import w3c.sw.sql.{Sql,DatabaseDesc,RelName,RelationDesc,AttrName,Value,Datatype,ForeignKey,Name}
 import w3c.sw.sparql.Sparql
 import w3c.sw.sparql2sql.{SparqlToSql,StemURI,SqlToXMLRes}