gistfile1.scala

package payola
// AUTO-GENERATED Slick data model
/** Stand-alone Slick data model for immediate use */
object Tables extends {
  val profile = scala.slick.driver.H2Driver
} with Tables

/** Slick data model trait for extension, choice of backend or usage in the cake pattern. (Make sure to initialize this late.) */
trait Tables {
  val profile: scala.slick.driver.JdbcProfile
  import profile.simple._
  import scala.slick.model.ForeignKeyAction
  // NOTE: GetResult mappers for plain SQL are only generated for tables where Slick knows how to map the types of all columns.
  import scala.slick.jdbc.{GetResult => GR}
  
  /** DDL for all tables. Call .create to execute. */
  lazy val ddl = Analyses.ddl ++ Analysesresults.ddl ++ Booleanparameters.ddl ++ Booleanparametervalues.ddl ++ Classcustomizations.ddl ++ Datasources.ddl ++ Floatparameters.ddl ++ Floatparametervalues.ddl ++ Groupmembership.ddl ++ Groups.ddl ++ Intparameters.ddl ++ Intparametervalues.ddl ++ Ontologycustomizations.ddl ++ Plugininstancebindings.ddl ++ Plugininstances.ddl ++ Plugins.ddl ++ Prefixes.ddl ++ Privileges.ddl ++ Propertycustomizations.ddl ++ Stringparameters.ddl ++ Stringparametervalues.ddl ++ Users.ddl
  
  /** Entity class storing rows of table Analyses
   *  @param _Token Database column _TOKEN 
   *  @param _Desc Database column _DESC 
   *  @param defaultcustomizationid Database column DEFAULTCUSTOMIZATIONID 
   *  @param _Ispublic Database column _ISPUBLIC 
   *  @param _Ispub Database column _ISPUB 
   *  @param id Database column ID PrimaryKey
   *  @param token Database column TOKEN 
   *  @param ownerid Database column OWNERID 
   *  @param _Description Database column _DESCRIPTION 
   *  @param _Name Database column _NAME 
   *  @param __Isvisibleinlistings Database column __ISVISIBLEINLISTINGS 
   *  @param _Isvisibleinlistings Database column _ISVISIBLEINLISTINGS  */
  case class AnalysesRow(_Token: Option[String], _Desc: java.sql.Clob, defaultcustomizationid: Option[String], _Ispublic: Boolean, _Ispub: Boolean, id: String, token: Option[String], ownerid: Option[String], _Description: java.sql.Clob, _Name: String, __Isvisibleinlistings: Boolean, _Isvisibleinlistings: Boolean)
  /** GetResult implicit for fetching AnalysesRow objects using plain SQL queries */
  implicit def GetResultAnalysesRow(implicit e0: GR[Option[String]], e1: GR[java.sql.Clob], e2: GR[Boolean], e3: GR[String]): GR[AnalysesRow] = GR{
    prs => import prs._
    AnalysesRow.tupled((<<?[String], <<[java.sql.Clob], <<?[String], <<[Boolean], <<[Boolean], <<[String], <<?[String], <<?[String], <<[java.sql.Clob], <<[String], <<[Boolean], <<[Boolean]))
  }
  /** Table description of table ANALYSES. Objects of this class serve as prototypes for rows in queries. */
  class Analyses(tag: Tag) extends Table[AnalysesRow](tag, "ANALYSES") {
    def * = (_Token, _Desc, defaultcustomizationid, _Ispublic, _Ispub, id, token, ownerid, _Description, _Name, __Isvisibleinlistings, _Isvisibleinlistings) <> (AnalysesRow.tupled, AnalysesRow.unapply)
    /** Maps whole row to an option. Useful for outer joins. */
    def ? = (_Token, _Desc.?, defaultcustomizationid, _Ispublic.?, _Ispub.?, id.?, token, ownerid, _Description.?, _Name.?, __Isvisibleinlistings.?, _Isvisibleinlistings.?).shaped.<>({r=>import r._; _2.map(_=> AnalysesRow.tupled((_1, _2.get, _3, _4.get, _5.get, _6.get, _7, _8, _9.get, _10.get, _11.get, _12.get)))}, (_:Any) =>  throw new Exception("Inserting into ? projection not supported."))
    
    /** Database column _TOKEN  */
    val _Token: Column[Option[String]] = column[Option[String]]("_TOKEN")
    /** Database column _DESC  */
    val _Desc: Column[java.sql.Clob] = column[java.sql.Clob]("_DESC")
    /** Database column DEFAULTCUSTOMIZATIONID  */
    val defaultcustomizationid: Column[Option[String]] = column[Option[String]]("DEFAULTCUSTOMIZATIONID")
    /** Database column _ISPUBLIC  */
    val _Ispublic: Column[Boolean] = column[Boolean]("_ISPUBLIC")
    /** Database column _ISPUB  */
    val _Ispub: Column[Boolean] = column[Boolean]("_ISPUB")
    /** Database column ID PrimaryKey */
    val id: Column[String] = column[String]("ID", O.PrimaryKey)
    /** Database column TOKEN  */
    val token: Column[Option[String]] = column[Option[String]]("TOKEN")
    /** Database column OWNERID  */
    val ownerid: Column[Option[String]] = column[Option[String]]("OWNERID")
    /** Database column _DESCRIPTION  */
    val _Description: Column[java.sql.Clob] = column[java.sql.Clob]("_DESCRIPTION")
    /** Database column _NAME  */
    val _Name: Column[String] = column[String]("_NAME")
    /** Database column __ISVISIBLEINLISTINGS  */
    val __Isvisibleinlistings: Column[Boolean] = column[Boolean]("__ISVISIBLEINLISTINGS")
    /** Database column _ISVISIBLEINLISTINGS  */
    val _Isvisibleinlistings: Column[Boolean] = column[Boolean]("_ISVISIBLEINLISTINGS")
    
    /** Foreign key referencing Users (database name ANALYSESFK27) */
    lazy val usersFk = foreignKey("ANALYSESFK27", ownerid, Users)(r => r.id, onUpdate=ForeignKeyAction.Restrict, onDelete=ForeignKeyAction.Cascade)
    
    /** Uniqueness Index over (_Name,ownerid) (database name IDX63E80893) */
    val index1 = index("IDX63E80893", (_Name, ownerid), unique=true)
  }
  /** Collection-like TableQuery object for table Analyses */
  lazy val Analyses = new TableQuery(tag => new Analyses(tag))
  
  /** Entity class storing rows of table Analysesresults
   *  @param _Touched Database column _TOUCHED 
   *  @param evaluationid Database column EVALUATIONID 
   *  @param verticescount Database column VERTICESCOUNT 
   *  @param id Database column ID PrimaryKey
   *  @param ownerid Database column OWNERID 
   *  @param _Name Database column _NAME 
   *  @param analysisid Database column ANALYSISID  */
  case class AnalysesresultsRow(_Touched: java.sql.Timestamp, evaluationid: String, verticescount: Int, id: String, ownerid: Option[String], _Name: String, analysisid: String)
  /** GetResult implicit for fetching AnalysesresultsRow objects using plain SQL queries */
  implicit def GetResultAnalysesresultsRow(implicit e0: GR[java.sql.Timestamp], e1: GR[String], e2: GR[Int], e3: GR[Option[String]]): GR[AnalysesresultsRow] = GR{
    prs => import prs._
    AnalysesresultsRow.tupled((<<[java.sql.Timestamp], <<[String], <<[Int], <<[String], <<?[String], <<[String], <<[String]))
  }
  /** Table description of table ANALYSESRESULTS. Objects of this class serve as prototypes for rows in queries. */
  class Analysesresults(tag: Tag) extends Table[AnalysesresultsRow](tag, "ANALYSESRESULTS") {
    def * = (_Touched, evaluationid, verticescount, id, ownerid, _Name, analysisid) <> (AnalysesresultsRow.tupled, AnalysesresultsRow.unapply)
    /** Maps whole row to an option. Useful for outer joins. */
    def ? = (_Touched.?, evaluationid.?, verticescount.?, id.?, ownerid, _Name.?, analysisid.?).shaped.<>({r=>import r._; _1.map(_=> AnalysesresultsRow.tupled((_1.get, _2.get, _3.get, _4.get, _5, _6.get, _7.get)))}, (_:Any) =>  throw new Exception("Inserting into ? projection not supported."))
    
    /** Database column _TOUCHED  */
    val _Touched: Column[java.sql.Timestamp] = column[java.sql.Timestamp]("_TOUCHED")
    /** Database column EVALUATIONID  */
    val evaluationid: Column[String] = column[String]("EVALUATIONID")
    /** Database column VERTICESCOUNT  */
    val verticescount: Column[Int] = column[Int]("VERTICESCOUNT")
    /** Database column ID PrimaryKey */
    val id: Column[String] = column[String]("ID", O.PrimaryKey)
    /** Database column OWNERID  */
    val ownerid: Column[Option[String]] = column[Option[String]]("OWNERID")
    /** Database column _NAME  */
    val _Name: Column[String] = column[String]("_NAME")
    /** Database column ANALYSISID  */
    val analysisid: Column[String] = column[String]("ANALYSISID")
  }
  /** Collection-like TableQuery object for table Analysesresults */
  lazy val Analysesresults = new TableQuery(tag => new Analysesresults(tag))
  
  /** Entity class storing rows of table Booleanparameters
   *  @param pluginid Database column PLUGINID 
   *  @param _Defaultvaluedb Database column _DEFAULTVALUEDB 
   *  @param id Database column ID PrimaryKey
   *  @param _Name Database column _NAME 
   *  @param _Ordering Database column _ORDERING  */
  case class BooleanparametersRow(pluginid: String, _Defaultvaluedb: java.sql.Clob, id: String, _Name: String, _Ordering: Option[Int])
  /** GetResult implicit for fetching BooleanparametersRow objects using plain SQL queries */
  implicit def GetResultBooleanparametersRow(implicit e0: GR[String], e1: GR[java.sql.Clob], e2: GR[Option[Int]]): GR[BooleanparametersRow] = GR{
    prs => import prs._
    BooleanparametersRow.tupled((<<[String], <<[java.sql.Clob], <<[String], <<[String], <<?[Int]))
  }
  /** Table description of table BOOLEANPARAMETERS. Objects of this class serve as prototypes for rows in queries. */
  class Booleanparameters(tag: Tag) extends Table[BooleanparametersRow](tag, "BOOLEANPARAMETERS") {
    def * = (pluginid, _Defaultvaluedb, id, _Name, _Ordering) <> (BooleanparametersRow.tupled, BooleanparametersRow.unapply)
    /** Maps whole row to an option. Useful for outer joins. */
    def ? = (pluginid.?, _Defaultvaluedb.?, id.?, _Name.?, _Ordering).shaped.<>({r=>import r._; _1.map(_=> BooleanparametersRow.tupled((_1.get, _2.get, _3.get, _4.get, _5)))}, (_:Any) =>  throw new Exception("Inserting into ? projection not supported."))
    
    /** Database column PLUGINID  */
    val pluginid: Column[String] = column[String]("PLUGINID")
    /** Database column _DEFAULTVALUEDB  */
    val _Defaultvaluedb: Column[java.sql.Clob] = column[java.sql.Clob]("_DEFAULTVALUEDB")
    /** Database column ID PrimaryKey */
    val id: Column[String] = column[String]("ID", O.PrimaryKey)
    /** Database column _NAME  */
    val _Name: Column[String] = column[String]("_NAME")
    /** Database column _ORDERING  */
    val _Ordering: Column[Option[Int]] = column[Option[Int]]("_ORDERING")
    
    /** Foreign key referencing Plugins (database name BOOLEANPARAMETERSFK9) */
    lazy val pluginsFk = foreignKey("BOOLEANPARAMETERSFK9", pluginid, Plugins)(r => r.id, onUpdate=ForeignKeyAction.Restrict, onDelete=ForeignKeyAction.Cascade)
    
    /** Uniqueness Index over (pluginid,_Name) (database name IDXD2720C8B) */
    val index1 = index("IDXD2720C8B", (pluginid, _Name), unique=true)
  }
  /** Collection-like TableQuery object for table Booleanparameters */
  lazy val Booleanparameters = new TableQuery(tag => new Booleanparameters(tag))
  
  /** Entity class storing rows of table Booleanparametervalues
   *  @param plugininstanceid Database column PLUGININSTANCEID 
   *  @param datasourceid Database column DATASOURCEID 
   *  @param parameterid Database column PARAMETERID 
   *  @param id Database column ID PrimaryKey
   *  @param value Database column VALUE  */
  case class BooleanparametervaluesRow(plugininstanceid: Option[String], datasourceid: Option[String], parameterid: String, id: String, value: java.sql.Clob)
  /** GetResult implicit for fetching BooleanparametervaluesRow objects using plain SQL queries */
  implicit def GetResultBooleanparametervaluesRow(implicit e0: GR[Option[String]], e1: GR[String], e2: GR[java.sql.Clob]): GR[BooleanparametervaluesRow] = GR{
    prs => import prs._
    BooleanparametervaluesRow.tupled((<<?[String], <<?[String], <<[String], <<[String], <<[java.sql.Clob]))
  }
  /** Table description of table BOOLEANPARAMETERVALUES. Objects of this class serve as prototypes for rows in queries. */
  class Booleanparametervalues(tag: Tag) extends Table[BooleanparametervaluesRow](tag, "BOOLEANPARAMETERVALUES") {
    def * = (plugininstanceid, datasourceid, parameterid, id, value) <> (BooleanparametervaluesRow.tupled, BooleanparametervaluesRow.unapply)
    /** Maps whole row to an option. Useful for outer joins. */
    def ? = (plugininstanceid, datasourceid, parameterid.?, id.?, value.?).shaped.<>({r=>import r._; _3.map(_=> BooleanparametervaluesRow.tupled((_1, _2, _3.get, _4.get, _5.get)))}, (_:Any) =>  throw new Exception("Inserting into ? projection not supported."))
    
    /** Database column PLUGININSTANCEID  */
    val plugininstanceid: Column[Option[String]] = column[Option[String]]("PLUGININSTANCEID")
    /** Database column DATASOURCEID  */
    val datasourceid: Column[Option[String]] = column[Option[String]]("DATASOURCEID")
    /** Database column PARAMETERID  */
    val parameterid: Column[String] = column[String]("PARAMETERID")
    /** Database column ID PrimaryKey */
    val id: Column[String] = column[String]("ID", O.PrimaryKey)
    /** Database column VALUE  */
    val value: Column[java.sql.Clob] = column[java.sql.Clob]("VALUE")
    
    /** Foreign key referencing Booleanparameters (database name BOOLEANPARAMETERVALUESFK5) */
    lazy val booleanparametersFk = foreignKey("BOOLEANPARAMETERVALUESFK5", parameterid, Booleanparameters)(r => r.id, onUpdate=ForeignKeyAction.Restrict, onDelete=ForeignKeyAction.Cascade)
    /** Foreign key referencing Datasources (database name BOOLEANPARAMETERVALUESFK19) */
    lazy val datasourcesFk = foreignKey("BOOLEANPARAMETERVALUESFK19", datasourceid, Datasources)(r => r.id, onUpdate=ForeignKeyAction.Restrict, onDelete=ForeignKeyAction.Cascade)
    /** Foreign key referencing Plugininstances (database name BOOLEANPARAMETERVALUESFK13) */
    lazy val plugininstancesFk = foreignKey("BOOLEANPARAMETERVALUESFK13", plugininstanceid, Plugininstances)(r => r.id, onUpdate=ForeignKeyAction.Restrict, onDelete=ForeignKeyAction.Cascade)
  }
  /** Collection-like TableQuery object for table Booleanparametervalues */
  lazy val Booleanparametervalues = new TableQuery(tag => new Booleanparametervalues(tag))
  
  /** Entity class storing rows of table Classcustomizations
   *  @param uri Database column URI 
   *  @param _Conditionalvalue Database column _CONDITIONALVALUE 
   *  @param _Glyph Database column _GLYPH 
   *  @param id Database column ID PrimaryKey
   *  @param _Ordernum Database column _ORDERNUM 
   *  @param _Labels Database column _LABELS 
   *  @param _Fillcolor Database column _FILLCOLOR 
   *  @param customizationid Database column CUSTOMIZATIONID 
   *  @param _Radius Database column _RADIUS  */
  case class ClasscustomizationsRow(uri: java.sql.Clob, _Conditionalvalue: java.sql.Clob, _Glyph: String, id: String, _Ordernum: Int, _Labels: String, _Fillcolor: String, customizationid: String, _Radius: Int)
  /** GetResult implicit for fetching ClasscustomizationsRow objects using plain SQL queries */
  implicit def GetResultClasscustomizationsRow(implicit e0: GR[java.sql.Clob], e1: GR[String], e2: GR[Int]): GR[ClasscustomizationsRow] = GR{
    prs => import prs._
    ClasscustomizationsRow.tupled((<<[java.sql.Clob], <<[java.sql.Clob], <<[String], <<[String], <<[Int], <<[String], <<[String], <<[String], <<[Int]))
  }
  /** Table description of table CLASSCUSTOMIZATIONS. Objects of this class serve as prototypes for rows in queries. */
  class Classcustomizations(tag: Tag) extends Table[ClasscustomizationsRow](tag, "CLASSCUSTOMIZATIONS") {
    def * = (uri, _Conditionalvalue, _Glyph, id, _Ordernum, _Labels, _Fillcolor, customizationid, _Radius) <> (ClasscustomizationsRow.tupled, ClasscustomizationsRow.unapply)
    /** Maps whole row to an option. Useful for outer joins. */
    def ? = (uri.?, _Conditionalvalue.?, _Glyph.?, id.?, _Ordernum.?, _Labels.?, _Fillcolor.?, customizationid.?, _Radius.?).shaped.<>({r=>import r._; _1.map(_=> ClasscustomizationsRow.tupled((_1.get, _2.get, _3.get, _4.get, _5.get, _6.get, _7.get, _8.get, _9.get)))}, (_:Any) =>  throw new Exception("Inserting into ? projection not supported."))
    
    /** Database column URI  */
    val uri: Column[java.sql.Clob] = column[java.sql.Clob]("URI")
    /** Database column _CONDITIONALVALUE  */
    val _Conditionalvalue: Column[java.sql.Clob] = column[java.sql.Clob]("_CONDITIONALVALUE")
    /** Database column _GLYPH  */
    val _Glyph: Column[String] = column[String]("_GLYPH")
    /** Database column ID PrimaryKey */
    val id: Column[String] = column[String]("ID", O.PrimaryKey)
    /** Database column _ORDERNUM  */
    val _Ordernum: Column[Int] = column[Int]("_ORDERNUM")
    /** Database column _LABELS  */
    val _Labels: Column[String] = column[String]("_LABELS")
    /** Database column _FILLCOLOR  */
    val _Fillcolor: Column[String] = column[String]("_FILLCOLOR")
    /** Database column CUSTOMIZATIONID  */
    val customizationid: Column[String] = column[String]("CUSTOMIZATIONID")
    /** Database column _RADIUS  */
    val _Radius: Column[Int] = column[Int]("_RADIUS")
    
    /** Foreign key referencing Ontologycustomizations (database name CLASSCUSTOMIZATIONSFK30) */
    lazy val ontologycustomizationsFk = foreignKey("CLASSCUSTOMIZATIONSFK30", customizationid, Ontologycustomizations)(r => r.id, onUpdate=ForeignKeyAction.Restrict, onDelete=ForeignKeyAction.Cascade)
  }
  /** Collection-like TableQuery object for table Classcustomizations */
  lazy val Classcustomizations = new TableQuery(tag => new Classcustomizations(tag))
  
  /** Entity class storing rows of table Datasources
   *  @param _Desc Database column _DESC 
   *  @param _Ispublic Database column _ISPUBLIC 
   *  @param _Iseditable Database column _ISEDITABLE 
   *  @param pluginid Database column PLUGINID 
   *  @param _Ispub Database column _ISPUB 
   *  @param id Database column ID PrimaryKey
   *  @param _Isedit Database column _ISEDIT 
   *  @param ownerid Database column OWNERID 
   *  @param _Description Database column _DESCRIPTION 
   *  @param _Name Database column _NAME 
   *  @param _Isvisibleinlistings Database column _ISVISIBLEINLISTINGS  */
  case class DatasourcesRow(_Desc: java.sql.Clob, _Ispublic: Boolean, _Iseditable: Boolean, pluginid: String, _Ispub: Boolean, id: String, _Isedit: Boolean, ownerid: Option[String], _Description: java.sql.Clob, _Name: String, _Isvisibleinlistings: Boolean)
  /** GetResult implicit for fetching DatasourcesRow objects using plain SQL queries */
  implicit def GetResultDatasourcesRow(implicit e0: GR[java.sql.Clob], e1: GR[Boolean], e2: GR[String], e3: GR[Option[String]]): GR[DatasourcesRow] = GR{
    prs => import prs._
    DatasourcesRow.tupled((<<[java.sql.Clob], <<[Boolean], <<[Boolean], <<[String], <<[Boolean], <<[String], <<[Boolean], <<?[String], <<[java.sql.Clob], <<[String], <<[Boolean]))
  }
  /** Table description of table DATASOURCES. Objects of this class serve as prototypes for rows in queries. */
  class Datasources(tag: Tag) extends Table[DatasourcesRow](tag, "DATASOURCES") {
    def * = (_Desc, _Ispublic, _Iseditable, pluginid, _Ispub, id, _Isedit, ownerid, _Description, _Name, _Isvisibleinlistings) <> (DatasourcesRow.tupled, DatasourcesRow.unapply)
    /** Maps whole row to an option. Useful for outer joins. */
    def ? = (_Desc.?, _Ispublic.?, _Iseditable.?, pluginid.?, _Ispub.?, id.?, _Isedit.?, ownerid, _Description.?, _Name.?, _Isvisibleinlistings.?).shaped.<>({r=>import r._; _1.map(_=> DatasourcesRow.tupled((_1.get, _2.get, _3.get, _4.get, _5.get, _6.get, _7.get, _8, _9.get, _10.get, _11.get)))}, (_:Any) =>  throw new Exception("Inserting into ? projection not supported."))
    
    /** Database column _DESC  */
    val _Desc: Column[java.sql.Clob] = column[java.sql.Clob]("_DESC")
    /** Database column _ISPUBLIC  */
    val _Ispublic: Column[Boolean] = column[Boolean]("_ISPUBLIC")
    /** Database column _ISEDITABLE  */
    val _Iseditable: Column[Boolean] = column[Boolean]("_ISEDITABLE")
    /** Database column PLUGINID  */
    val pluginid: Column[String] = column[String]("PLUGINID")
    /** Database column _ISPUB  */
    val _Ispub: Column[Boolean] = column[Boolean]("_ISPUB")
    /** Database column ID PrimaryKey */
    val id: Column[String] = column[String]("ID", O.PrimaryKey)
    /** Database column _ISEDIT  */
    val _Isedit: Column[Boolean] = column[Boolean]("_ISEDIT")
    /** Database column OWNERID  */
    val ownerid: Column[Option[String]] = column[Option[String]]("OWNERID")
    /** Database column _DESCRIPTION  */
    val _Description: Column[java.sql.Clob] = column[java.sql.Clob]("_DESCRIPTION")
    /** Database column _NAME  */
    val _Name: Column[String] = column[String]("_NAME")
    /** Database column _ISVISIBLEINLISTINGS  */
    val _Isvisibleinlistings: Column[Boolean] = column[Boolean]("_ISVISIBLEINLISTINGS")
    
    /** Foreign key referencing Plugins (database name DATASOURCESFK2) */
    lazy val pluginsFk = foreignKey("DATASOURCESFK2", pluginid, Plugins)(r => r.id, onUpdate=ForeignKeyAction.Restrict, onDelete=ForeignKeyAction.Cascade)
    /** Foreign key referencing Users (database name DATASOURCESFK28) */
    lazy val usersFk = foreignKey("DATASOURCESFK28", ownerid, Users)(r => r.id, onUpdate=ForeignKeyAction.Restrict, onDelete=ForeignKeyAction.Cascade)
    
    /** Uniqueness Index over (_Name,ownerid) (database name IDX7F3109B1) */
    val index1 = index("IDX7F3109B1", (_Name, ownerid), unique=true)
  }
  /** Collection-like TableQuery object for table Datasources */
  lazy val Datasources = new TableQuery(tag => new Datasources(tag))
  
  /** Entity class storing rows of table Floatparameters
   *  @param pluginid Database column PLUGINID 
   *  @param _Defaultvaluedb Database column _DEFAULTVALUEDB 
   *  @param id Database column ID PrimaryKey
   *  @param _Name Database column _NAME 
   *  @param _Ordering Database column _ORDERING  */
  case class FloatparametersRow(pluginid: String, _Defaultvaluedb: java.sql.Clob, id: String, _Name: String, _Ordering: Option[Int])
  /** GetResult implicit for fetching FloatparametersRow objects using plain SQL queries */
  implicit def GetResultFloatparametersRow(implicit e0: GR[String], e1: GR[java.sql.Clob], e2: GR[Option[Int]]): GR[FloatparametersRow] = GR{
    prs => import prs._
    FloatparametersRow.tupled((<<[String], <<[java.sql.Clob], <<[String], <<[String], <<?[Int]))
  }
  /** Table description of table FLOATPARAMETERS. Objects of this class serve as prototypes for rows in queries. */
  class Floatparameters(tag: Tag) extends Table[FloatparametersRow](tag, "FLOATPARAMETERS") {
    def * = (pluginid, _Defaultvaluedb, id, _Name, _Ordering) <> (FloatparametersRow.tupled, FloatparametersRow.unapply)
    /** Maps whole row to an option. Useful for outer joins. */
    def ? = (pluginid.?, _Defaultvaluedb.?, id.?, _Name.?, _Ordering).shaped.<>({r=>import r._; _1.map(_=> FloatparametersRow.tupled((_1.get, _2.get, _3.get, _4.get, _5)))}, (_:Any) =>  throw new Exception("Inserting into ? projection not supported."))
    
    /** Database column PLUGINID  */
    val pluginid: Column[String] = column[String]("PLUGINID")
    /** Database column _DEFAULTVALUEDB  */
    val _Defaultvaluedb: Column[java.sql.Clob] = column[java.sql.Clob]("_DEFAULTVALUEDB")
    /** Database column ID PrimaryKey */
    val id: Column[String] = column[String]("ID", O.PrimaryKey)
    /** Database column _NAME  */
    val _Name: Column[String] = column[String]("_NAME")
    /** Database column _ORDERING  */
    val _Ordering: Column[Option[Int]] = column[Option[Int]]("_ORDERING")
    
    /** Foreign key referencing Plugins (database name FLOATPARAMETERSFK10) */
    lazy val pluginsFk = foreignKey("FLOATPARAMETERSFK10", pluginid, Plugins)(r => r.id, onUpdate=ForeignKeyAction.Restrict, onDelete=ForeignKeyAction.Cascade)
    
    /** Uniqueness Index over (pluginid,_Name) (database name IDXB9650BC1) */
    val index1 = index("IDXB9650BC1", (pluginid, _Name), unique=true)
  }
  /** Collection-like TableQuery object for table Floatparameters */
  lazy val Floatparameters = new TableQuery(tag => new Floatparameters(tag))
  
  /** Entity class storing rows of table Floatparametervalues
   *  @param plugininstanceid Database column PLUGININSTANCEID 
   *  @param datasourceid Database column DATASOURCEID 
   *  @param parameterid Database column PARAMETERID 
   *  @param id Database column ID PrimaryKey
   *  @param value Database column VALUE  */
  case class FloatparametervaluesRow(plugininstanceid: Option[String], datasourceid: Option[String], parameterid: String, id: String, value: java.sql.Clob)
  /** GetResult implicit for fetching FloatparametervaluesRow objects using plain SQL queries */
  implicit def GetResultFloatparametervaluesRow(implicit e0: GR[Option[String]], e1: GR[String], e2: GR[java.sql.Clob]): GR[FloatparametervaluesRow] = GR{
    prs => import prs._
    FloatparametervaluesRow.tupled((<<?[String], <<?[String], <<[String], <<[String], <<[java.sql.Clob]))
  }
  /** Table description of table FLOATPARAMETERVALUES. Objects of this class serve as prototypes for rows in queries. */
  class Floatparametervalues(tag: Tag) extends Table[FloatparametervaluesRow](tag, "FLOATPARAMETERVALUES") {
    def * = (plugininstanceid, datasourceid, parameterid, id, value) <> (FloatparametervaluesRow.tupled, FloatparametervaluesRow.unapply)
    /** Maps whole row to an option. Useful for outer joins. */
    def ? = (plugininstanceid, datasourceid, parameterid.?, id.?, value.?).shaped.<>({r=>import r._; _3.map(_=> FloatparametervaluesRow.tupled((_1, _2, _3.get, _4.get, _5.get)))}, (_:Any) =>  throw new Exception("Inserting into ? projection not supported."))
    
    /** Database column PLUGININSTANCEID  */
    val plugininstanceid: Column[Option[String]] = column[Option[String]]("PLUGININSTANCEID")
    /** Database column DATASOURCEID  */
    val datasourceid: Column[Option[String]] = column[Option[String]]("DATASOURCEID")
    /** Database column PARAMETERID  */
    val parameterid: Column[String] = column[String]("PARAMETERID")
    /** Database column ID PrimaryKey */
    val id: Column[String] = column[String]("ID", O.PrimaryKey)
    /** Database column VALUE  */
    val value: Column[java.sql.Clob] = column[java.sql.Clob]("VALUE")
    
    /** Foreign key referencing Datasources (database name FLOATPARAMETERVALUESFK20) */
    lazy val datasourcesFk = foreignKey("FLOATPARAMETERVALUESFK20", datasourceid, Datasources)(r => r.id, onUpdate=ForeignKeyAction.Restrict, onDelete=ForeignKeyAction.Cascade)
    /** Foreign key referencing Floatparameters (database name FLOATPARAMETERVALUESFK6) */
    lazy val floatparametersFk = foreignKey("FLOATPARAMETERVALUESFK6", parameterid, Floatparameters)(r => r.id, onUpdate=ForeignKeyAction.Restrict, onDelete=ForeignKeyAction.Cascade)
    /** Foreign key referencing Plugininstances (database name FLOATPARAMETERVALUESFK14) */
    lazy val plugininstancesFk = foreignKey("FLOATPARAMETERVALUESFK14", plugininstanceid, Plugininstances)(r => r.id, onUpdate=ForeignKeyAction.Restrict, onDelete=ForeignKeyAction.Cascade)
  }
  /** Collection-like TableQuery object for table Floatparametervalues */
  lazy val Floatparametervalues = new TableQuery(tag => new Floatparametervalues(tag))
  
  /** Entity class storing rows of table Groupmembership
   *  @param groupid Database column GROUPID 
   *  @param memberid Database column MEMBERID  */
  case class GroupmembershipRow(groupid: String, memberid: String)
  /** GetResult implicit for fetching GroupmembershipRow objects using plain SQL queries */
  implicit def GetResultGroupmembershipRow(implicit e0: GR[String]): GR[GroupmembershipRow] = GR{
    prs => import prs._
    GroupmembershipRow.tupled((<<[String], <<[String]))
  }
  /** Table description of table GROUPMEMBERSHIP. Objects of this class serve as prototypes for rows in queries. */
  class Groupmembership(tag: Tag) extends Table[GroupmembershipRow](tag, "GROUPMEMBERSHIP") {
    def * = (groupid, memberid) <> (GroupmembershipRow.tupled, GroupmembershipRow.unapply)
    /** Maps whole row to an option. Useful for outer joins. */
    def ? = (groupid.?, memberid.?).shaped.<>({r=>import r._; _1.map(_=> GroupmembershipRow.tupled((_1.get, _2.get)))}, (_:Any) =>  throw new Exception("Inserting into ? projection not supported."))
    
    /** Database column GROUPID  */
    val groupid: Column[String] = column[String]("GROUPID")
    /** Database column MEMBERID  */
    val memberid: Column[String] = column[String]("MEMBERID")
    
    /** Foreign key referencing Groups (database name GROUPMEMBERSHIPFK24) */
    lazy val groupsFk = foreignKey("GROUPMEMBERSHIPFK24", groupid, Groups)(r => r.id, onUpdate=ForeignKeyAction.Restrict, onDelete=ForeignKeyAction.Cascade)
    /** Foreign key referencing Users (database name GROUPMEMBERSHIPFK23) */
    lazy val usersFk = foreignKey("GROUPMEMBERSHIPFK23", memberid, Users)(r => r.id, onUpdate=ForeignKeyAction.Restrict, onDelete=ForeignKeyAction.Cascade)
    
    /** Uniqueness Index over (memberid,groupid) (database name GROUPMEMBERSHIPCPK_INDEX_C) */
    val index1 = index("GROUPMEMBERSHIPCPK_INDEX_C", (memberid, groupid), unique=true)
  }
  /** Collection-like TableQuery object for table Groupmembership */
  lazy val Groupmembership = new TableQuery(tag => new Groupmembership(tag))
  
  /** Entity class storing rows of table Groups
   *  @param id Database column ID PrimaryKey
   *  @param ownerid Database column OWNERID 
   *  @param _Name Database column _NAME  */
  case class GroupsRow(id: String, ownerid: String, _Name: String)
  /** GetResult implicit for fetching GroupsRow objects using plain SQL queries */
  implicit def GetResultGroupsRow(implicit e0: GR[String]): GR[GroupsRow] = GR{
    prs => import prs._
    GroupsRow.tupled((<<[String], <<[String], <<[String]))
  }
  /** Table description of table GROUPS. Objects of this class serve as prototypes for rows in queries. */
  class Groups(tag: Tag) extends Table[GroupsRow](tag, "GROUPS") {
    def * = (id, ownerid, _Name) <> (GroupsRow.tupled, GroupsRow.unapply)
    /** Maps whole row to an option. Useful for outer joins. */
    def ? = (id.?, ownerid.?, _Name.?).shaped.<>({r=>import r._; _1.map(_=> GroupsRow.tupled((_1.get, _2.get, _3.get)))}, (_:Any) =>  throw new Exception("Inserting into ? projection not supported."))
    
    /** Database column ID PrimaryKey */
    val id: Column[String] = column[String]("ID", O.PrimaryKey)
    /** Database column OWNERID  */
    val ownerid: Column[String] = column[String]("OWNERID")
    /** Database column _NAME  */
    val _Name: Column[String] = column[String]("_NAME")
    
    /** Foreign key referencing Users (database name GROUPSFK25) */
    lazy val usersFk = foreignKey("GROUPSFK25", ownerid, Users)(r => r.id, onUpdate=ForeignKeyAction.Restrict, onDelete=ForeignKeyAction.Cascade)
    
    /** Uniqueness Index over (_Name,ownerid) (database name IDX539207D3) */
    val index1 = index("IDX539207D3", (_Name, ownerid), unique=true)
  }
  /** Collection-like TableQuery object for table Groups */
  lazy val Groups = new TableQuery(tag => new Groups(tag))
  
  /** Entity class storing rows of table Intparameters
   *  @param pluginid Database column PLUGINID 
   *  @param _Defaultvaluedb Database column _DEFAULTVALUEDB 
   *  @param id Database column ID PrimaryKey
   *  @param _Name Database column _NAME 
   *  @param _Ordering Database column _ORDERING  */
  case class IntparametersRow(pluginid: String, _Defaultvaluedb: java.sql.Clob, id: String, _Name: String, _Ordering: Option[Int])
  /** GetResult implicit for fetching IntparametersRow objects using plain SQL queries */
  implicit def GetResultIntparametersRow(implicit e0: GR[String], e1: GR[java.sql.Clob], e2: GR[Option[Int]]): GR[IntparametersRow] = GR{
    prs => import prs._
    IntparametersRow.tupled((<<[String], <<[java.sql.Clob], <<[String], <<[String], <<?[Int]))
  }
  /** Table description of table INTPARAMETERS. Objects of this class serve as prototypes for rows in queries. */
  class Intparameters(tag: Tag) extends Table[IntparametersRow](tag, "INTPARAMETERS") {
    def * = (pluginid, _Defaultvaluedb, id, _Name, _Ordering) <> (IntparametersRow.tupled, IntparametersRow.unapply)
    /** Maps whole row to an option. Useful for outer joins. */
    def ? = (pluginid.?, _Defaultvaluedb.?, id.?, _Name.?, _Ordering).shaped.<>({r=>import r._; _1.map(_=> IntparametersRow.tupled((_1.get, _2.get, _3.get, _4.get, _5)))}, (_:Any) =>  throw new Exception("Inserting into ? projection not supported."))
    
    /** Database column PLUGINID  */
    val pluginid: Column[String] = column[String]("PLUGINID")
    /** Database column _DEFAULTVALUEDB  */
    val _Defaultvaluedb: Column[java.sql.Clob] = column[java.sql.Clob]("_DEFAULTVALUEDB")
    /** Database column ID PrimaryKey */
    val id: Column[String] = column[String]("ID", O.PrimaryKey)
    /** Database column _NAME  */
    val _Name: Column[String] = column[String]("_NAME")
    /** Database column _ORDERING  */
    val _Ordering: Column[Option[Int]] = column[Option[Int]]("_ORDERING")
    
    /** Foreign key referencing Plugins (database name INTPARAMETERSFK11) */
    lazy val pluginsFk = foreignKey("INTPARAMETERSFK11", pluginid, Plugins)(r => r.id, onUpdate=ForeignKeyAction.Restrict, onDelete=ForeignKeyAction.Cascade)
    
    /** Uniqueness Index over (pluginid,_Name) (database name IDXA1EA0AF6) */
    val index1 = index("IDXA1EA0AF6", (pluginid, _Name), unique=true)
  }
  /** Collection-like TableQuery object for table Intparameters */
  lazy val Intparameters = new TableQuery(tag => new Intparameters(tag))
  
  /** Entity class storing rows of table Intparametervalues
   *  @param plugininstanceid Database column PLUGININSTANCEID 
   *  @param datasourceid Database column DATASOURCEID 
   *  @param parameterid Database column PARAMETERID 
   *  @param id Database column ID PrimaryKey
   *  @param value Database column VALUE  */
  case class IntparametervaluesRow(plugininstanceid: Option[String], datasourceid: Option[String], parameterid: String, id: String, value: java.sql.Clob)
  /** GetResult implicit for fetching IntparametervaluesRow objects using plain SQL queries */
  implicit def GetResultIntparametervaluesRow(implicit e0: GR[Option[String]], e1: GR[String], e2: GR[java.sql.Clob]): GR[IntparametervaluesRow] = GR{
    prs => import prs._
    IntparametervaluesRow.tupled((<<?[String], <<?[String], <<[String], <<[String], <<[java.sql.Clob]))
  }
  /** Table description of table INTPARAMETERVALUES. Objects of this class serve as prototypes for rows in queries. */
  class Intparametervalues(tag: Tag) extends Table[IntparametervaluesRow](tag, "INTPARAMETERVALUES") {
    def * = (plugininstanceid, datasourceid, parameterid, id, value) <> (IntparametervaluesRow.tupled, IntparametervaluesRow.unapply)
    /** Maps whole row to an option. Useful for outer joins. */
    def ? = (plugininstanceid, datasourceid, parameterid.?, id.?, value.?).shaped.<>({r=>import r._; _3.map(_=> IntparametervaluesRow.tupled((_1, _2, _3.get, _4.get, _5.get)))}, (_:Any) =>  throw new Exception("Inserting into ? projection not supported."))
    
    /** Database column PLUGININSTANCEID  */
    val plugininstanceid: Column[Option[String]] = column[Option[String]]("PLUGININSTANCEID")
    /** Database column DATASOURCEID  */
    val datasourceid: Column[Option[String]] = column[Option[String]]("DATASOURCEID")
    /** Database column PARAMETERID  */
    val parameterid: Column[String] = column[String]("PARAMETERID")
    /** Database column ID PrimaryKey */
    val id: Column[String] = column[String]("ID", O.PrimaryKey)
    /** Database column VALUE  */
    val value: Column[java.sql.Clob] = column[java.sql.Clob]("VALUE")
    
    /** Foreign key referencing Datasources (database name INTPARAMETERVALUESFK21) */
    lazy val datasourcesFk = foreignKey("INTPARAMETERVALUESFK21", datasourceid, Datasources)(r => r.id, onUpdate=ForeignKeyAction.Restrict, onDelete=ForeignKeyAction.Cascade)
    /** Foreign key referencing Intparameters (database name INTPARAMETERVALUESFK7) */
    lazy val intparametersFk = foreignKey("INTPARAMETERVALUESFK7", parameterid, Intparameters)(r => r.id, onUpdate=ForeignKeyAction.Restrict, onDelete=ForeignKeyAction.Cascade)
    /** Foreign key referencing Plugininstances (database name INTPARAMETERVALUESFK15) */
    lazy val plugininstancesFk = foreignKey("INTPARAMETERVALUESFK15", plugininstanceid, Plugininstances)(r => r.id, onUpdate=ForeignKeyAction.Restrict, onDelete=ForeignKeyAction.Cascade)
  }
  /** Collection-like TableQuery object for table Intparametervalues */
  lazy val Intparametervalues = new TableQuery(tag => new Intparametervalues(tag))
  
  /** Entity class storing rows of table Ontologycustomizations
   *  @param userdefined Database column USERDEFINED 
   *  @param _Ispublic Database column _ISPUBLIC 
   *  @param _Ispub Database column _ISPUB 
   *  @param id Database column ID PrimaryKey
   *  @param ownerid Database column OWNERID 
   *  @param _Name Database column _NAME 
   *  @param urls Database column URLS 
   *  @param _Isvisibleinlistings Database column _ISVISIBLEINLISTINGS  */
  case class OntologycustomizationsRow(userdefined: Option[Boolean], _Ispublic: Boolean, _Ispub: Boolean, id: String, ownerid: Option[String], _Name: String, urls: java.sql.Clob, _Isvisibleinlistings: Boolean)
  /** GetResult implicit for fetching OntologycustomizationsRow objects using plain SQL queries */
  implicit def GetResultOntologycustomizationsRow(implicit e0: GR[Option[Boolean]], e1: GR[Boolean], e2: GR[String], e3: GR[Option[String]], e4: GR[java.sql.Clob]): GR[OntologycustomizationsRow] = GR{
    prs => import prs._
    OntologycustomizationsRow.tupled((<<?[Boolean], <<[Boolean], <<[Boolean], <<[String], <<?[String], <<[String], <<[java.sql.Clob], <<[Boolean]))
  }
  /** Table description of table ONTOLOGYCUSTOMIZATIONS. Objects of this class serve as prototypes for rows in queries. */
  class Ontologycustomizations(tag: Tag) extends Table[OntologycustomizationsRow](tag, "ONTOLOGYCUSTOMIZATIONS") {
    def * = (userdefined, _Ispublic, _Ispub, id, ownerid, _Name, urls, _Isvisibleinlistings) <> (OntologycustomizationsRow.tupled, OntologycustomizationsRow.unapply)
    /** Maps whole row to an option. Useful for outer joins. */
    def ? = (userdefined, _Ispublic.?, _Ispub.?, id.?, ownerid, _Name.?, urls.?, _Isvisibleinlistings.?).shaped.<>({r=>import r._; _2.map(_=> OntologycustomizationsRow.tupled((_1, _2.get, _3.get, _4.get, _5, _6.get, _7.get, _8.get)))}, (_:Any) =>  throw new Exception("Inserting into ? projection not supported."))
    
    /** Database column USERDEFINED  */
    val userdefined: Column[Option[Boolean]] = column[Option[Boolean]]("USERDEFINED")
    /** Database column _ISPUBLIC  */
    val _Ispublic: Column[Boolean] = column[Boolean]("_ISPUBLIC")
    /** Database column _ISPUB  */
    val _Ispub: Column[Boolean] = column[Boolean]("_ISPUB")
    /** Database column ID PrimaryKey */
    val id: Column[String] = column[String]("ID", O.PrimaryKey)
    /** Database column OWNERID  */
    val ownerid: Column[Option[String]] = column[Option[String]]("OWNERID")
    /** Database column _NAME  */
    val _Name: Column[String] = column[String]("_NAME")
    /** Database column URLS  */
    val urls: Column[java.sql.Clob] = column[java.sql.Clob]("URLS")
    /** Database column _ISVISIBLEINLISTINGS  */
    val _Isvisibleinlistings: Column[Boolean] = column[Boolean]("_ISVISIBLEINLISTINGS")
    
    /** Foreign key referencing Users (database name ONTOLOGYCUSTOMIZATIONSFK26) */
    lazy val usersFk = foreignKey("ONTOLOGYCUSTOMIZATIONSFK26", ownerid, Users)(r => r.id, onUpdate=ForeignKeyAction.Restrict, onDelete=ForeignKeyAction.Cascade)
    
    /** Uniqueness Index over (_Name,ownerid) (database name IDX156A0E9A) */
    val index1 = index("IDX156A0E9A", (_Name, ownerid), unique=true)
  }
  /** Collection-like TableQuery object for table Ontologycustomizations */
  lazy val Ontologycustomizations = new TableQuery(tag => new Ontologycustomizations(tag))
  
  /** Entity class storing rows of table Plugininstancebindings
   *  @param sourceplugininstanceid Database column SOURCEPLUGININSTANCEID 
   *  @param targetplugininstanceid Database column TARGETPLUGININSTANCEID 
   *  @param analysisid Database column ANALYSISID 
   *  @param _Targetinputindex Database column _TARGETINPUTINDEX 
   *  @param id Database column ID PrimaryKey
   *  @param inputindex Database column INPUTINDEX  */
  case class PlugininstancebindingsRow(sourceplugininstanceid: String, targetplugininstanceid: String, analysisid: String, _Targetinputindex: Int, id: String, inputindex: Int)
  /** GetResult implicit for fetching PlugininstancebindingsRow objects using plain SQL queries */
  implicit def GetResultPlugininstancebindingsRow(implicit e0: GR[String], e1: GR[Int]): GR[PlugininstancebindingsRow] = GR{
    prs => import prs._
    PlugininstancebindingsRow.tupled((<<[String], <<[String], <<[String], <<[Int], <<[String], <<[Int]))
  }
  /** Table description of table PLUGININSTANCEBINDINGS. Objects of this class serve as prototypes for rows in queries. */
  class Plugininstancebindings(tag: Tag) extends Table[PlugininstancebindingsRow](tag, "PLUGININSTANCEBINDINGS") {
    def * = (sourceplugininstanceid, targetplugininstanceid, analysisid, _Targetinputindex, id, inputindex) <> (PlugininstancebindingsRow.tupled, PlugininstancebindingsRow.unapply)
    /** Maps whole row to an option. Useful for outer joins. */
    def ? = (sourceplugininstanceid.?, targetplugininstanceid.?, analysisid.?, _Targetinputindex.?, id.?, inputindex.?).shaped.<>({r=>import r._; _1.map(_=> PlugininstancebindingsRow.tupled((_1.get, _2.get, _3.get, _4.get, _5.get, _6.get)))}, (_:Any) =>  throw new Exception("Inserting into ? projection not supported."))
    
    /** Database column SOURCEPLUGININSTANCEID  */
    val sourceplugininstanceid: Column[String] = column[String]("SOURCEPLUGININSTANCEID")
    /** Database column TARGETPLUGININSTANCEID  */
    val targetplugininstanceid: Column[String] = column[String]("TARGETPLUGININSTANCEID")
    /** Database column ANALYSISID  */
    val analysisid: Column[String] = column[String]("ANALYSISID")
    /** Database column _TARGETINPUTINDEX  */
    val _Targetinputindex: Column[Int] = column[Int]("_TARGETINPUTINDEX")
    /** Database column ID PrimaryKey */
    val id: Column[String] = column[String]("ID", O.PrimaryKey)
    /** Database column INPUTINDEX  */
    val inputindex: Column[Int] = column[Int]("INPUTINDEX")
    
    /** Foreign key referencing Analyses (database name PLUGININSTANCEBINDINGSFK4) */
    lazy val analysesFk = foreignKey("PLUGININSTANCEBINDINGSFK4", analysisid, Analyses)(r => r.id, onUpdate=ForeignKeyAction.Restrict, onDelete=ForeignKeyAction.Cascade)
    /** Foreign key referencing Plugininstances (database name PLUGININSTANCEBINDINGSFK17) */
    lazy val plugininstancesFk2 = foreignKey("PLUGININSTANCEBINDINGSFK17", sourceplugininstanceid, Plugininstances)(r => r.id, onUpdate=ForeignKeyAction.Restrict, onDelete=ForeignKeyAction.Cascade)
    /** Foreign key referencing Plugininstances (database name PLUGININSTANCEBINDINGSFK18) */
    lazy val plugininstancesFk3 = foreignKey("PLUGININSTANCEBINDINGSFK18", targetplugininstanceid, Plugininstances)(r => r.id, onUpdate=ForeignKeyAction.Restrict, onDelete=ForeignKeyAction.Cascade)
    
    /** Uniqueness Index over (targetplugininstanceid,inputindex) (database name IDX7F99164D) */
    val index1 = index("IDX7F99164D", (targetplugininstanceid, inputindex), unique=true)
    /** Uniqueness Index over (sourceplugininstanceid,analysisid) (database name IDX80B71640) */
    val index2 = index("IDX80B71640", (sourceplugininstanceid, analysisid), unique=true)
  }
  /** Collection-like TableQuery object for table Plugininstancebindings */
  lazy val Plugininstancebindings = new TableQuery(tag => new Plugininstancebindings(tag))
  
  /** Entity class storing rows of table Plugininstances
   *  @param _Desc Database column _DESC 
   *  @param _Iseditable Database column _ISEDITABLE 
   *  @param pluginid Database column PLUGINID 
   *  @param analysisid Database column ANALYSISID 
   *  @param id Database column ID PrimaryKey
   *  @param _Isedit Database column _ISEDIT 
   *  @param _Description Database column _DESCRIPTION  */
  case class PlugininstancesRow(_Desc: java.sql.Clob, _Iseditable: Boolean, pluginid: String, analysisid: String, id: String, _Isedit: Boolean, _Description: java.sql.Clob)
  /** GetResult implicit for fetching PlugininstancesRow objects using plain SQL queries */
  implicit def GetResultPlugininstancesRow(implicit e0: GR[java.sql.Clob], e1: GR[Boolean], e2: GR[String]): GR[PlugininstancesRow] = GR{
    prs => import prs._
    PlugininstancesRow.tupled((<<[java.sql.Clob], <<[Boolean], <<[String], <<[String], <<[String], <<[Boolean], <<[java.sql.Clob]))
  }
  /** Table description of table PLUGININSTANCES. Objects of this class serve as prototypes for rows in queries. */
  class Plugininstances(tag: Tag) extends Table[PlugininstancesRow](tag, "PLUGININSTANCES") {
    def * = (_Desc, _Iseditable, pluginid, analysisid, id, _Isedit, _Description) <> (PlugininstancesRow.tupled, PlugininstancesRow.unapply)
    /** Maps whole row to an option. Useful for outer joins. */
    def ? = (_Desc.?, _Iseditable.?, pluginid.?, analysisid.?, id.?, _Isedit.?, _Description.?).shaped.<>({r=>import r._; _1.map(_=> PlugininstancesRow.tupled((_1.get, _2.get, _3.get, _4.get, _5.get, _6.get, _7.get)))}, (_:Any) =>  throw new Exception("Inserting into ? projection not supported."))
    
    /** Database column _DESC  */
    val _Desc: Column[java.sql.Clob] = column[java.sql.Clob]("_DESC")
    /** Database column _ISEDITABLE  */
    val _Iseditable: Column[Boolean] = column[Boolean]("_ISEDITABLE")
    /** Database column PLUGINID  */
    val pluginid: Column[String] = column[String]("PLUGINID")
    /** Database column ANALYSISID  */
    val analysisid: Column[String] = column[String]("ANALYSISID")
    /** Database column ID PrimaryKey */
    val id: Column[String] = column[String]("ID", O.PrimaryKey)
    /** Database column _ISEDIT  */
    val _Isedit: Column[Boolean] = column[Boolean]("_ISEDIT")
    /** Database column _DESCRIPTION  */
    val _Description: Column[java.sql.Clob] = column[java.sql.Clob]("_DESCRIPTION")
    
    /** Foreign key referencing Analyses (database name PLUGININSTANCESFK3) */
    lazy val analysesFk = foreignKey("PLUGININSTANCESFK3", analysisid, Analyses)(r => r.id, onUpdate=ForeignKeyAction.Restrict, onDelete=ForeignKeyAction.Cascade)
    /** Foreign key referencing Plugins (database name PLUGININSTANCESFK1) */
    lazy val pluginsFk = foreignKey("PLUGININSTANCESFK1", pluginid, Plugins)(r => r.id, onUpdate=ForeignKeyAction.Restrict, onDelete=ForeignKeyAction.Cascade)
  }
  /** Collection-like TableQuery object for table Plugininstances */
  lazy val Plugininstances = new TableQuery(tag => new Plugininstances(tag))
  
  /** Entity class storing rows of table Plugins
   *  @param pluginclassname Database column PLUGINCLASSNAME 
   *  @param _Ispublic Database column _ISPUBLIC 
   *  @param _Ispub Database column _ISPUB 
   *  @param id Database column ID PrimaryKey
   *  @param ownerid Database column OWNERID 
   *  @param _Name Database column _NAME 
   *  @param inputcount Database column INPUTCOUNT 
   *  @param _Isvisibleinlistings Database column _ISVISIBLEINLISTINGS  */
  case class PluginsRow(pluginclassname: String, _Ispublic: Boolean, _Ispub: Boolean, id: String, ownerid: Option[String], _Name: String, inputcount: Int, _Isvisibleinlistings: Boolean)
  /** GetResult implicit for fetching PluginsRow objects using plain SQL queries */
  implicit def GetResultPluginsRow(implicit e0: GR[String], e1: GR[Boolean], e2: GR[Option[String]], e3: GR[Int]): GR[PluginsRow] = GR{
    prs => import prs._
    PluginsRow.tupled((<<[String], <<[Boolean], <<[Boolean], <<[String], <<?[String], <<[String], <<[Int], <<[Boolean]))
  }
  /** Table description of table PLUGINS. Objects of this class serve as prototypes for rows in queries. */
  class Plugins(tag: Tag) extends Table[PluginsRow](tag, "PLUGINS") {
    def * = (pluginclassname, _Ispublic, _Ispub, id, ownerid, _Name, inputcount, _Isvisibleinlistings) <> (PluginsRow.tupled, PluginsRow.unapply)
    /** Maps whole row to an option. Useful for outer joins. */
    def ? = (pluginclassname.?, _Ispublic.?, _Ispub.?, id.?, ownerid, _Name.?, inputcount.?, _Isvisibleinlistings.?).shaped.<>({r=>import r._; _1.map(_=> PluginsRow.tupled((_1.get, _2.get, _3.get, _4.get, _5, _6.get, _7.get, _8.get)))}, (_:Any) =>  throw new Exception("Inserting into ? projection not supported."))
    
    /** Database column PLUGINCLASSNAME  */
    val pluginclassname: Column[String] = column[String]("PLUGINCLASSNAME")
    /** Database column _ISPUBLIC  */
    val _Ispublic: Column[Boolean] = column[Boolean]("_ISPUBLIC")
    /** Database column _ISPUB  */
    val _Ispub: Column[Boolean] = column[Boolean]("_ISPUB")
    /** Database column ID PrimaryKey */
    val id: Column[String] = column[String]("ID", O.PrimaryKey)
    /** Database column OWNERID  */
    val ownerid: Column[Option[String]] = column[Option[String]]("OWNERID")
    /** Database column _NAME  */
    val _Name: Column[String] = column[String]("_NAME")
    /** Database column INPUTCOUNT  */
    val inputcount: Column[Int] = column[Int]("INPUTCOUNT")
    /** Database column _ISVISIBLEINLISTINGS  */
    val _Isvisibleinlistings: Column[Boolean] = column[Boolean]("_ISVISIBLEINLISTINGS")
    
    /** Foreign key referencing Users (database name PLUGINSFK29) */
    lazy val usersFk = foreignKey("PLUGINSFK29", ownerid, Users)(r => r.id, onUpdate=ForeignKeyAction.Restrict, onDelete=ForeignKeyAction.Cascade)
    
    /** Uniqueness Index over (_Name) (database name IDX25230530) */
    val index1 = index("IDX25230530", _Name, unique=true)
  }
  /** Collection-like TableQuery object for table Plugins */
  lazy val Plugins = new TableQuery(tag => new Plugins(tag))
  
  /** Entity class storing rows of table Prefixes
   *  @param _Url Database column _URL 
   *  @param _Prefix Database column _PREFIX 
   *  @param id Database column ID PrimaryKey
   *  @param ownerid Database column OWNERID 
   *  @param _Name Database column _NAME  */
  case class PrefixesRow(_Url: String, _Prefix: String, id: String, ownerid: Option[String], _Name: String)
  /** GetResult implicit for fetching PrefixesRow objects using plain SQL queries */
  implicit def GetResultPrefixesRow(implicit e0: GR[String], e1: GR[Option[String]]): GR[PrefixesRow] = GR{
    prs => import prs._
    PrefixesRow.tupled((<<[String], <<[String], <<[String], <<?[String], <<[String]))
  }
  /** Table description of table PREFIXES. Objects of this class serve as prototypes for rows in queries. */
  class Prefixes(tag: Tag) extends Table[PrefixesRow](tag, "PREFIXES") {
    def * = (_Url, _Prefix, id, ownerid, _Name) <> (PrefixesRow.tupled, PrefixesRow.unapply)
    /** Maps whole row to an option. Useful for outer joins. */
    def ? = (_Url.?, _Prefix.?, id.?, ownerid, _Name.?).shaped.<>({r=>import r._; _1.map(_=> PrefixesRow.tupled((_1.get, _2.get, _3.get, _4, _5.get)))}, (_:Any) =>  throw new Exception("Inserting into ? projection not supported."))
    
    /** Database column _URL  */
    val _Url: Column[String] = column[String]("_URL")
    /** Database column _PREFIX  */
    val _Prefix: Column[String] = column[String]("_PREFIX")
    /** Database column ID PrimaryKey */
    val id: Column[String] = column[String]("ID", O.PrimaryKey)
    /** Database column OWNERID  */
    val ownerid: Column[Option[String]] = column[Option[String]]("OWNERID")
    /** Database column _NAME  */
    val _Name: Column[String] = column[String]("_NAME")
    
    /** Uniqueness Index over (ownerid,_Url) (database name IDX5CEC084B) */
    val index1 = index("IDX5CEC084B", (ownerid, _Url), unique=true)
    /** Uniqueness Index over (ownerid,_Prefix) (database name IDX780F0986) */
    val index2 = index("IDX780F0986", (ownerid, _Prefix), unique=true)
  }
  /** Collection-like TableQuery object for table Prefixes */
  lazy val Prefixes = new TableQuery(tag => new Prefixes(tag))
  
  /** Entity class storing rows of table Privileges
   *  @param granteeid Database column GRANTEEID 
   *  @param privilegeclass Database column PRIVILEGECLASS 
   *  @param granterid Database column GRANTERID 
   *  @param id Database column ID PrimaryKey
   *  @param objectclassname Database column OBJECTCLASSNAME 
   *  @param granteeclassname Database column GRANTEECLASSNAME 
   *  @param objectid Database column OBJECTID  */
  case class PrivilegesRow(granteeid: String, privilegeclass: String, granterid: String, id: String, objectclassname: String, granteeclassname: String, objectid: String)
  /** GetResult implicit for fetching PrivilegesRow objects using plain SQL queries */
  implicit def GetResultPrivilegesRow(implicit e0: GR[String]): GR[PrivilegesRow] = GR{
    prs => import prs._
    PrivilegesRow.tupled((<<[String], <<[String], <<[String], <<[String], <<[String], <<[String], <<[String]))
  }
  /** Table description of table PRIVILEGES. Objects of this class serve as prototypes for rows in queries. */
  class Privileges(tag: Tag) extends Table[PrivilegesRow](tag, "PRIVILEGES") {
    def * = (granteeid, privilegeclass, granterid, id, objectclassname, granteeclassname, objectid) <> (PrivilegesRow.tupled, PrivilegesRow.unapply)
    /** Maps whole row to an option. Useful for outer joins. */
    def ? = (granteeid.?, privilegeclass.?, granterid.?, id.?, objectclassname.?, granteeclassname.?, objectid.?).shaped.<>({r=>import r._; _1.map(_=> PrivilegesRow.tupled((_1.get, _2.get, _3.get, _4.get, _5.get, _6.get, _7.get)))}, (_:Any) =>  throw new Exception("Inserting into ? projection not supported."))
    
    /** Database column GRANTEEID  */
    val granteeid: Column[String] = column[String]("GRANTEEID")
    /** Database column PRIVILEGECLASS  */
    val privilegeclass: Column[String] = column[String]("PRIVILEGECLASS")
    /** Database column GRANTERID  */
    val granterid: Column[String] = column[String]("GRANTERID")
    /** Database column ID PrimaryKey */
    val id: Column[String] = column[String]("ID", O.PrimaryKey)
    /** Database column OBJECTCLASSNAME  */
    val objectclassname: Column[String] = column[String]("OBJECTCLASSNAME")
    /** Database column GRANTEECLASSNAME  */
    val granteeclassname: Column[String] = column[String]("GRANTEECLASSNAME")
    /** Database column OBJECTID  */
    val objectid: Column[String] = column[String]("OBJECTID")
    
    /** Uniqueness Index over (granteeid,privilegeclass,objectid) (database name IDX891F1136) */
    val index1 = index("IDX891F1136", (granteeid, privilegeclass, objectid), unique=true)
  }
  /** Collection-like TableQuery object for table Privileges */
  lazy val Privileges = new TableQuery(tag => new Privileges(tag))
  
  /** Entity class storing rows of table Propertycustomizations
   *  @param _Strokecolor Database column _STROKECOLOR 
   *  @param uri Database column URI 
   *  @param id Database column ID PrimaryKey
   *  @param classcustomizationid Database column CLASSCUSTOMIZATIONID 
   *  @param _Strokewidth Database column _STROKEWIDTH  */
  case class PropertycustomizationsRow(_Strokecolor: String, uri: java.sql.Clob, id: String, classcustomizationid: String, _Strokewidth: Int)
  /** GetResult implicit for fetching PropertycustomizationsRow objects using plain SQL queries */
  implicit def GetResultPropertycustomizationsRow(implicit e0: GR[String], e1: GR[java.sql.Clob], e2: GR[Int]): GR[PropertycustomizationsRow] = GR{
    prs => import prs._
    PropertycustomizationsRow.tupled((<<[String], <<[java.sql.Clob], <<[String], <<[String], <<[Int]))
  }
  /** Table description of table PROPERTYCUSTOMIZATIONS. Objects of this class serve as prototypes for rows in queries. */
  class Propertycustomizations(tag: Tag) extends Table[PropertycustomizationsRow](tag, "PROPERTYCUSTOMIZATIONS") {
    def * = (_Strokecolor, uri, id, classcustomizationid, _Strokewidth) <> (PropertycustomizationsRow.tupled, PropertycustomizationsRow.unapply)
    /** Maps whole row to an option. Useful for outer joins. */
    def ? = (_Strokecolor.?, uri.?, id.?, classcustomizationid.?, _Strokewidth.?).shaped.<>({r=>import r._; _1.map(_=> PropertycustomizationsRow.tupled((_1.get, _2.get, _3.get, _4.get, _5.get)))}, (_:Any) =>  throw new Exception("Inserting into ? projection not supported."))
    
    /** Database column _STROKECOLOR  */
    val _Strokecolor: Column[String] = column[String]("_STROKECOLOR")
    /** Database column URI  */
    val uri: Column[java.sql.Clob] = column[java.sql.Clob]("URI")
    /** Database column ID PrimaryKey */
    val id: Column[String] = column[String]("ID", O.PrimaryKey)
    /** Database column CLASSCUSTOMIZATIONID  */
    val classcustomizationid: Column[String] = column[String]("CLASSCUSTOMIZATIONID")
    /** Database column _STROKEWIDTH  */
    val _Strokewidth: Column[Int] = column[Int]("_STROKEWIDTH")
    
    /** Foreign key referencing Classcustomizations (database name PROPERTYCUSTOMIZATIONSFK31) */
    lazy val classcustomizationsFk = foreignKey("PROPERTYCUSTOMIZATIONSFK31", classcustomizationid, Classcustomizations)(r => r.id, onUpdate=ForeignKeyAction.Restrict, onDelete=ForeignKeyAction.Cascade)
  }
  /** Collection-like TableQuery object for table Propertycustomizations */
  lazy val Propertycustomizations = new TableQuery(tag => new Propertycustomizations(tag))
  
  /** Entity class storing rows of table Stringparameters
   *  @param _Ispattern Database column _ISPATTERN 
   *  @param _Cancontainurl Database column _CANCONTAINURL 
   *  @param _Ismultiline Database column _ISMULTILINE 
   *  @param pluginid Database column PLUGINID 
   *  @param _Defaultvaluedb Database column _DEFAULTVALUEDB 
   *  @param id Database column ID PrimaryKey
   *  @param _Ispassword Database column _ISPASSWORD 
   *  @param _Name Database column _NAME 
   *  @param _Ordering Database column _ORDERING  */
  case class StringparametersRow(_Ispattern: Boolean, _Cancontainurl: Boolean, _Ismultiline: Boolean, pluginid: String, _Defaultvaluedb: java.sql.Clob, id: String, _Ispassword: Boolean, _Name: String, _Ordering: Option[Int])
  /** GetResult implicit for fetching StringparametersRow objects using plain SQL queries */
  implicit def GetResultStringparametersRow(implicit e0: GR[Boolean], e1: GR[String], e2: GR[java.sql.Clob], e3: GR[Option[Int]]): GR[StringparametersRow] = GR{
    prs => import prs._
    StringparametersRow.tupled((<<[Boolean], <<[Boolean], <<[Boolean], <<[String], <<[java.sql.Clob], <<[String], <<[Boolean], <<[String], <<?[Int]))
  }
  /** Table description of table STRINGPARAMETERS. Objects of this class serve as prototypes for rows in queries. */
  class Stringparameters(tag: Tag) extends Table[StringparametersRow](tag, "STRINGPARAMETERS") {
    def * = (_Ispattern, _Cancontainurl, _Ismultiline, pluginid, _Defaultvaluedb, id, _Ispassword, _Name, _Ordering) <> (StringparametersRow.tupled, StringparametersRow.unapply)
    /** Maps whole row to an option. Useful for outer joins. */
    def ? = (_Ispattern.?, _Cancontainurl.?, _Ismultiline.?, pluginid.?, _Defaultvaluedb.?, id.?, _Ispassword.?, _Name.?, _Ordering).shaped.<>({r=>import r._; _1.map(_=> StringparametersRow.tupled((_1.get, _2.get, _3.get, _4.get, _5.get, _6.get, _7.get, _8.get, _9)))}, (_:Any) =>  throw new Exception("Inserting into ? projection not supported."))
    
    /** Database column _ISPATTERN  */
    val _Ispattern: Column[Boolean] = column[Boolean]("_ISPATTERN")
    /** Database column _CANCONTAINURL  */
    val _Cancontainurl: Column[Boolean] = column[Boolean]("_CANCONTAINURL")
    /** Database column _ISMULTILINE  */
    val _Ismultiline: Column[Boolean] = column[Boolean]("_ISMULTILINE")
    /** Database column PLUGINID  */
    val pluginid: Column[String] = column[String]("PLUGINID")
    /** Database column _DEFAULTVALUEDB  */
    val _Defaultvaluedb: Column[java.sql.Clob] = column[java.sql.Clob]("_DEFAULTVALUEDB")
    /** Database column ID PrimaryKey */
    val id: Column[String] = column[String]("ID", O.PrimaryKey)
    /** Database column _ISPASSWORD  */
    val _Ispassword: Column[Boolean] = column[Boolean]("_ISPASSWORD")
    /** Database column _NAME  */
    val _Name: Column[String] = column[String]("_NAME")
    /** Database column _ORDERING  */
    val _Ordering: Column[Option[Int]] = column[Option[Int]]("_ORDERING")
    
    /** Foreign key referencing Plugins (database name STRINGPARAMETERSFK12) */
    lazy val pluginsFk = foreignKey("STRINGPARAMETERSFK12", pluginid, Plugins)(r => r.id, onUpdate=ForeignKeyAction.Restrict, onDelete=ForeignKeyAction.Cascade)
    
    /** Uniqueness Index over (pluginid,_Name) (database name IDXC90A0C42) */
    val index1 = index("IDXC90A0C42", (pluginid, _Name), unique=true)
  }
  /** Collection-like TableQuery object for table Stringparameters */
  lazy val Stringparameters = new TableQuery(tag => new Stringparameters(tag))
  
  /** Entity class storing rows of table Stringparametervalues
   *  @param plugininstanceid Database column PLUGININSTANCEID 
   *  @param datasourceid Database column DATASOURCEID 
   *  @param parameterid Database column PARAMETERID 
   *  @param id Database column ID PrimaryKey
   *  @param value Database column VALUE  */
  case class StringparametervaluesRow(plugininstanceid: Option[String], datasourceid: Option[String], parameterid: String, id: String, value: java.sql.Clob)
  /** GetResult implicit for fetching StringparametervaluesRow objects using plain SQL queries */
  implicit def GetResultStringparametervaluesRow(implicit e0: GR[Option[String]], e1: GR[String], e2: GR[java.sql.Clob]): GR[StringparametervaluesRow] = GR{
    prs => import prs._
    StringparametervaluesRow.tupled((<<?[String], <<?[String], <<[String], <<[String], <<[java.sql.Clob]))
  }
  /** Table description of table STRINGPARAMETERVALUES. Objects of this class serve as prototypes for rows in queries. */
  class Stringparametervalues(tag: Tag) extends Table[StringparametervaluesRow](tag, "STRINGPARAMETERVALUES") {
    def * = (plugininstanceid, datasourceid, parameterid, id, value) <> (StringparametervaluesRow.tupled, StringparametervaluesRow.unapply)
    /** Maps whole row to an option. Useful for outer joins. */
    def ? = (plugininstanceid, datasourceid, parameterid.?, id.?, value.?).shaped.<>({r=>import r._; _3.map(_=> StringparametervaluesRow.tupled((_1, _2, _3.get, _4.get, _5.get)))}, (_:Any) =>  throw new Exception("Inserting into ? projection not supported."))
    
    /** Database column PLUGININSTANCEID  */
    val plugininstanceid: Column[Option[String]] = column[Option[String]]("PLUGININSTANCEID")
    /** Database column DATASOURCEID  */
    val datasourceid: Column[Option[String]] = column[Option[String]]("DATASOURCEID")
    /** Database column PARAMETERID  */
    val parameterid: Column[String] = column[String]("PARAMETERID")
    /** Database column ID PrimaryKey */
    val id: Column[String] = column[String]("ID", O.PrimaryKey)
    /** Database column VALUE  */
    val value: Column[java.sql.Clob] = column[java.sql.Clob]("VALUE")
    
    /** Foreign key referencing Datasources (database name STRINGPARAMETERVALUESFK22) */
    lazy val datasourcesFk = foreignKey("STRINGPARAMETERVALUESFK22", datasourceid, Datasources)(r => r.id, onUpdate=ForeignKeyAction.Restrict, onDelete=ForeignKeyAction.Cascade)
    /** Foreign key referencing Plugininstances (database name STRINGPARAMETERVALUESFK16) */
    lazy val plugininstancesFk = foreignKey("STRINGPARAMETERVALUESFK16", plugininstanceid, Plugininstances)(r => r.id, onUpdate=ForeignKeyAction.Restrict, onDelete=ForeignKeyAction.Cascade)
    /** Foreign key referencing Stringparameters (database name STRINGPARAMETERVALUESFK8) */
    lazy val stringparametersFk = foreignKey("STRINGPARAMETERVALUESFK8", parameterid, Stringparameters)(r => r.id, onUpdate=ForeignKeyAction.Restrict, onDelete=ForeignKeyAction.Cascade)
  }
  /** Collection-like TableQuery object for table Stringparametervalues */
  lazy val Stringparametervalues = new TableQuery(tag => new Stringparametervalues(tag))
  
  /** Entity class storing rows of table Users
   *  @param _Password Database column _PASSWORD 
   *  @param id Database column ID PrimaryKey
   *  @param _Name Database column _NAME 
   *  @param _Email Database column _EMAIL  */
  case class UsersRow(_Password: String, id: String, _Name: String, _Email: String)
  /** GetResult implicit for fetching UsersRow objects using plain SQL queries */
  implicit def GetResultUsersRow(implicit e0: GR[String]): GR[UsersRow] = GR{
    prs => import prs._
    UsersRow.tupled((<<[String], <<[String], <<[String], <<[String]))
  }
  /** Table description of table USERS. Objects of this class serve as prototypes for rows in queries. */
  class Users(tag: Tag) extends Table[UsersRow](tag, "USERS") {
    def * = (_Password, id, _Name, _Email) <> (UsersRow.tupled, UsersRow.unapply)
    /** Maps whole row to an option. Useful for outer joins. */
    def ? = (_Password.?, id.?, _Name.?, _Email.?).shaped.<>({r=>import r._; _1.map(_=> UsersRow.tupled((_1.get, _2.get, _3.get, _4.get)))}, (_:Any) =>  throw new Exception("Inserting into ? projection not supported."))
    
    /** Database column _PASSWORD  */
    val _Password: Column[String] = column[String]("_PASSWORD")
    /** Database column ID PrimaryKey */
    val id: Column[String] = column[String]("ID", O.PrimaryKey)
    /** Database column _NAME  */
    val _Name: Column[String] = column[String]("_NAME")
    /** Database column _EMAIL  */
    val _Email: Column[String] = column[String]("_EMAIL")
    
    /** Uniqueness Index over (_Name) (database name IDX1AD50460) */
    val index1 = index("IDX1AD50460", _Name, unique=true)
  }
  /** Collection-like TableQuery object for table Users */
  lazy val Users = new TableQuery(tag => new Users(tag))
}