source: trunk/src/core/common-queries.xml @ 7997

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE predefined-queries SYSTEM "predefined-queries.dtd" >
<!--
  $Id: common-queries.xml 7997 2021-08-09 13:32:20Z nicklas $

  Copyright (C) 2005 Samuel Andersson, Johan Enell, Nicklas Nordborg
  Copyright (C) 2006 Jari Häkkinen, Nicklas Nordborg, Martin Svensson
  Copyright (C) 2007 Johan Enell, Nicklas Nordborg, Martin Svensson

  This file is part of BASE - BioArray Software Environment.
  Available at http://base.thep.lu.se/

  BASE is free software; you can redistribute it and/or
  modify it under the terms of the GNU General Public License
  as published by the Free Software Foundation; either version 3
  of the License, or (at your option) any later version.

  BASE is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with BASE. If not, see <http://www.gnu.org/licenses/>.
-->
<!--
  This XML file contains HQL and SQL queries that are common
  to all databases. If one of them happens to fail on your
  particular database, do not modify this file. Instead, you
  should add an entry into the file that is specific for your
  particular database that overrides the query in this file.
  For example, for PostgreSQL modify the postgresql-queries.xml.
-->
<predefined-queries>

  <query id="LOAD_SYSTEM_ITEMS" type="HQL">
    <sql>
      SELECT item.id, item.systemId
      FROM net.sf.basedb.core.data.SystemData item
      WHERE NOT item.systemId IS NULL
    </sql>
    <description>
      Load the ID and systemID, in that order, of all SystemData
      items.
    </description>
  </query>

  <query id="LOAD_ROLE_KEY_IDS" type="HQL">
    <sql>
      SELECT rk.id, rk.itemType
      FROM RoleKeyData rk
    </sql>
    <description>
      Load the ID and itemType, in that order, of all RoleKeyData
      items.
    </description>
  </query>

  <query id="GET_USER_FOR_LOGIN" type="HQL">
    <sql>
      SELECT usr
      FROM UserData usr
      WHERE usr.login = :login
    </sql>
    <description>
      Load a user when you know the login.
    </description>
  </query>
  
  <query id="GET_USER_FOR_EXTERNAL_ID" type="HQL">
    <sql>
      SELECT usr
      FROM UserData usr
      WHERE usr.externalId = :externalId
    </sql>
    <description>
      Load a user when you know the external id.
    </description>
  </query>

  <query id="GET_CLIENT_FOR_EXTERNAL_ID" type="HQL">
    <sql>
      SELECT cli
      FROM ClientData cli
      WHERE cli.externalId = :externalId
    </sql>
    <description>
      Load a client when you know the external ID.
    </description>
  </query>
  
  <query id="GET_ROLE_IDS_FOR_USER" type="HQL">
    <sql>
      SELECT ur.roleId
      FROM UserRoles ur
      WHERE ur.userId = :userId
    </sql>
    <description>
      Load the ID of all roles where the given user is a member.
    </description>
  </query>

  <query id="GET_GROUP_IDS_FOR_USER" type="HQL">
    <sql>
      SELECT ug.groupId
      FROM UserGroups ug
      WHERE ug.userId = :userId
    </sql>
    <description>
      Load the ID of all groups where the given user is a direct member.
    </description>
  </query>
  
  <query id="GET_QUOTA_GROUP_ID_FOR_USER" type="HQL">
    <sql>
      SELECT usr.quotaGroup.id
      FROM UserData usr
      WHERE usr.id = :userId
    </sql>
    <description>
      Load the ID of a user's quota group.
    </description>
  </query>

  <query id="GET_PARENTGROUPS_IDS_FOR_GROUPS" type="HQL">
    <sql>
      SELECT DISTINCT gg.parentId
      FROM GroupGroups gg
      WHERE gg.childId IN (:groups)
      AND gg.parentId NOT IN (:groups)
    </sql>
    <description>
      Load the ID of all groups that are parents to at least one of
      the given groups, excluding the given groups.
    </description>
  </query>
  
  <query id="GET_CHILDGROUPS_IDS_FOR_GROUPS" type="HQL">
    <sql>
      SELECT DISTINCT gg.childId
      FROM GroupGroups gg
      WHERE gg.parentId IN (:groups)
      AND gg.childId NOT IN (:groups)
    </sql>
    <description>
      Load the ID of all groups that are children to at least one of
      the given groups, excluding the given groups.
    </description>
  </query>

  <query id="GET_PROJECT_IDS_FOR_OWNER" type="HQL">
    <sql>
      SELECT p.id
      FROM ProjectData p
      WHERE p.owner = :userId
    </sql>
    <description>
      Load the ID of all projects where the given user is the owner.
    </description>
  </query>

  <query id="GET_PROJECTINFO_FOR_USER" type="HQL">
    <sql>
      SELECT up
      FROM UserProjects up
      WHERE up.userId = :userId
    </sql>
    <description>
      Load the UserProjects of all projects where the given user is a member.
    </description>
  </query>

  <query id="GET_PROJECTINFO_FOR_GROUPS" type="HQL">
    <sql>
      SELECT DISTINCT gp
      FROM GroupProjects gp
      WHERE gp.groupId IN (:groups)
    </sql>
    <description>
      Load the GroupProjects of all projects where at least one of the given groups 
      is a member.
    </description>
  </query>

  <query id="GET_USER_IDS_FOR_GROUPS" type="HQL">
    <sql>
      SELECT ug.userId
      FROM UserGroups ug
      WHERE ug.groupId IN (:groups)
    </sql>
    <description>
      Load the ID of all users which is a member of at least one of the given groups.
    </description>
  </query>

  <query id="GET_USER_IDS_FOR_QUOTAGROUPS" type="HQL">
    <sql>
      SELECT usr.id
      FROM UserData usr
      WHERE usr.quotaGroup.id IN (:groups)
    </sql>
    <description>
      Load the ID of all users which has a quota group from one of the given groups.
    </description>
  </query>

  <query id="GET_USER_IDS_FOR_PROJECT" type="HQL">
    <sql>
      SELECT up.userId
      FROM UserProjects up
      WHERE up.projectId = :projectId
    </sql>
    <description>
      Load the ID of all users which are direct member of the given project
    </description>
  </query>

  <query id="GET_GROUP_IDS_FOR_PROJECT" type="HQL">
    <sql>
      SELECT gp.groupId
      FROM GroupProjects gp
      WHERE gp.projectId = :projectId
    </sql>
    <description>
      Load the ID of all groups which are direct member of the given project
    </description>
  </query>

  <query id="GET_USERKEYS_FOR_USER" type="HQL">
    <sql>
      SELECT uk
      FROM UserKeys uk
      WHERE uk.userId = :userId
    </sql>
    <description>
      Load the UserKeys for the given user.
    </description>
  </query>

  <query id="GET_GROUPKEYS_FOR_GROUPS" type="HQL">
    <sql>
      SELECT gk
      FROM GroupKeys gk
      WHERE gk.groupId IN (:groups)
    </sql>
    <description>
      Load the GroupKeys for the given groups.
    </description>
  </query>

  <query id="GET_ROLEKEYS_FOR_USER" type="HQL">
    <sql>
      SELECT rk
      FROM RoleKeys rk, UserRoles ur
      WHERE rk.roleId = ur.roleId AND ur.userId = :userId
      ORDER BY rk.keyId
    </sql>
    <description>
      Load the RoleKeys for the roles where the given user is a member.
    </description>
  </query>

  <query id="GET_PROJECTKEYS_FOR_PROJECT" type="HQL">
    <sql>
      SELECT pk
      FROM ProjectKeys pk
      WHERE pk.projectId = :projectId
      ORDER BY pk.keyId
    </sql>
    <description>
      Load the ProjectKeys for the given project. Sort by
      keyId for fast lookup in array (Keyring class).
    </description>
  </query>
  
  <query id="GET_PROJECTKEYIDS_FOR_PROJECT" type="HQL">
    <sql>
      SELECT pk.keyId
      FROM ProjectKeys pk
      WHERE pk.projectId = :projectId
    </sql>
    <description>
      Load the ID of ProjectKeys for the given project.
    </description>
  </query>

  <query id="GET_PROJECTKEY_IDS_FOR_COUNT" type="HQL">
    <sql>
      SELECT pk.keyId FROM ProjectKeys pk
      GROUP BY pk.keyId
      HAVING count(pk.projectId) = :numPermissions
    </sql>
    <description>
      Load the ID of all project keys which have permissions for the 
      specified number of projects.
    </description>
  </query>

  <query id="FIND_USED_PROJECTKEY_IDS" type="HQL">
    <sql>
      SELECT DISTINCT sd.projectKey.id
      FROM net.sf.basedb.core.data.ShareableData sd
      WHERE NOT sd.projectKey IS NULL
    </sql>
    <description>
      Load the ID of all project keys which are used by at least one 
      shareable item.
    </description>
  </query>
  
  <query id="SELECT_UNUSED_PROJECTKEYS" type="HQL">
    <sql>
      SELECT pk FROM ProjectKeyData pk 
      WHERE pk.id NOT IN (:used)
    </sql>
    <description>
      Load all unused project keys given a list of the ID:s of all used
      keys.
    </description>
  </query>

  <query id="GET_ITEMKEY_IDS_FOR_USERCOUNT" type="HQL">
    <sql>
      SELECT ik.id FROM ItemKeyData ik
      LEFT JOIN ik.users u
      GROUP BY ik.id
      HAVING COUNT(u.index) = :numPermissions
    </sql>
    <description>
      Load the ID of all item keys which have permissions for the 
      specified number of users.
    </description>
  </query>

  <query id="GET_ITEMKEY_IDS_FOR_GROUPCOUNT" type="HQL">
    <sql>
      SELECT ik.id FROM ItemKeyData ik
      LEFT JOIN ik.groups g
      WHERE ik.id IN (:candidates)
      GROUP BY ik.id
      HAVING count(g.index) = :numPermissions
    </sql>
    <description>
      Load the ID of all item keys which have permissions for the 
      specified number of groups and are among the list of candidates.
    </description>
  </query>
  
  <query id="FIND_USED_ITEMKEY_IDS" type="HQL">
    <sql>
      SELECT DISTINCT sd.itemKey.id
      FROM net.sf.basedb.core.data.ShareableData sd
      WHERE NOT sd.itemKey IS NULL
    </sql>
    <description>
      Load the ID of all item keys which are used by at least one 
      shareable item.
    </description>
  </query>
  
  <query id="SELECT_UNUSED_ITEMKEYS" type="HQL">
    <sql>
      SELECT ik FROM ItemKeyData ik 
      WHERE ik.id NOT IN (:used)
    </sql>
    <description>
      Load all unused item keys given a list of the ID:s of all used
      keys.
    </description>
  </query>

  <query id="GET_USERS_FOR_QUOTAGROUP" type="HQL">
    <sql>
      SELECT {1}
      FROM UserData usr
      WHERE usr.quotaGroup = :theGroup
    </sql>
    <description>
      Get users having the specified group as
      their quota group.
    </description>
  </query>
  
  <query id="GET_USERS_FOR_QUOTA" type="HQL">
    <sql>
      SELECT {1}
      FROM UserData u
      WHERE u.quota = :quota
    </sql>
    <description>
      A Hibernate query that gets users
      that has been assigned a given quota.
    </description>
  </query>
  
  <query id="GET_GROUPS_FOR_QUOTA" type="HQL">
    <sql>
      SELECT {1}
      FROM GroupData g
      WHERE g.quota = :quota
    </sql>
    <description>
      A Hibernate query that gets groups
      that has been assigned a given quota.
    </description>
  </query>

  <query id="GET_SHAREABLE_ITEMS_FOR_ITEMKEY" type="HQL">
    <sql>
      SELECT s
      FROM net.sf.basedb.core.data.ShareableData s
      WHERE s.itemKey = :itemKey
    </sql>
    <description>
      Get all items beeing shared to the specified item key.
    </description>
  </query>

  <query id="GET_SHAREABLE_ITEMS_FOR_PROJECTKEY" type="HQL">
    <sql>
      SELECT s
      FROM net.sf.basedb.core.data.ShareableData s
      WHERE s.projectKey = :projectKey
    </sql>
    <description>
      Get all items beeing shared to the specified project key.
    </description>
  </query>
  
  <query id="GET_OWNABLE_ITEMS_FOR_USER" type="HQL">
    <sql>
      SELECT o
      FROM net.sf.basedb.core.data.OwnableData o
      WHERE o.owner = :user
    </sql>
    <description>
      Get all items that are owned by the specified user.
    </description>
  </query>
  
  <query id="LOAD_USER_CLIENT_SETTINGS" type="HQL">
    <sql>
      SELECT s 
      FROM UserClientSettingData s
      WHERE s.user = :user AND s.client = :client
    </sql>
    <description>
      Load all settings for the specified user and client application.
    </description>
  </query>
  
  <query id="LOAD_USER_DEFAULT_SETTINGS" type="HQL">
    <sql>
      SELECT s 
      FROM UserDefaultSettingData s
      WHERE s.user = :user
    </sql>
    <description>
      Load all default settings for the specified user.
    </description>
  </query>

  <query id="LOAD_CLIENT_DEFAULT_SETTINGS" type="HQL">
    <sql>
      SELECT s 
      FROM ClientDefaultSettingData s
      WHERE s.client = :client
    </sql>
    <description>
      Load all default settings for the specified client application.
    </description>
  </query>
  
  <query id="GET_MIME_TYPE_FROM_EXTENSION" type="HQL">
    <sql>
      SELECT s
      FROM net.sf.basedb.core.data.MimeTypeData s
      WHERE LOWER(s.extension) = LOWER(:extension)
    </sql>
    <description>
      A Hibernate query that returns a MimeType given an extension.
    </description>
  </query>
  
  <query id="GET_TOTAL_DISKUSAGE_FOR_USER" type="HQL">
    <sql>
      SELECT sum(du.bytes)
      FROM DiskUsageData du
      WHERE du.user = :user
      AND du.location = :location
    </sql>
    <description>
      A Hibernate query that returns the total used quota
      for the specified user at the specified location.
    </description>
  </query>
  
  <query id="GET_SPECIFIC_DISKUSAGE_FOR_USER" type="HQL">
    <sql>
      SELECT sum(du.bytes)
      FROM DiskUsageData du
      WHERE du.user = :user
      AND du.location = :location
      AND du.quotaType = :quotaType
    </sql>
    <description>
      A Hibernate query that returns the used quota for the
      specific quota type for the specified user at the
      specified location.
    </description>
  </query>

  <query id="GET_TOTAL_DISKUSAGE_FOR_GROUP" type="HQL">
    <sql>
      SELECT sum(du.bytes)
      FROM DiskUsageData du
      WHERE du.group = :group
      AND du.location = :location
    </sql>
    <description>
      A Hibernate query that returns the total used quota
      for the specified group at the specified location.
    </description>
  </query>

  <query id="GET_SPECIFIC_DISKUSAGE_FOR_GROUP" type="HQL">
    <sql>
      SELECT sum(du.bytes)
      FROM DiskUsageData du
      WHERE du.group = :group
      AND du.location = :location
      AND du.quotaType = :quotaType
    </sql>
    <description>
      A Hibernate query that returns the used quota for the
      specific quota type for the specified group at the
      specified location.
    </description>
  </query>

  <query id="GET_TOTAL_DISKUSAGE_SUMMARY" type="HQL">
    <sql>
      SELECT SUM(du.bytes), du.location, du.quotaType.systemId
      FROM DiskUsageData du
      GROUP BY du.location, du.quotaType.systemId
    </sql>
    <description>
      A Hibernate query that returns the total disk usage grouped
      by location and quota type system id.
    </description>
  </query>

  <query id="GET_DISKUSAGE_SUMMARY_FOR_USER" type="HQL">
    <sql>
      SELECT SUM(du.bytes), du.location, du.quotaType.systemId
      FROM DiskUsageData du
      WHERE du.user = :user
      GROUP BY du.location, du.quotaType.systemId
    </sql>
    <description>
      A Hibernate query that returns the disk usage for a user grouped
      by location and quota type system id.
    </description>
  </query>

  <query id="GET_DISKUSAGE_SUMMARY_FOR_GROUP" type="HQL">
    <sql>
      SELECT SUM(du.bytes), du.location, du.quotaType.systemId
      FROM DiskUsageData du
      WHERE du.group = :group
      GROUP BY du.location, du.quotaType.systemId
    </sql>
    <description>
      A Hibernate query that returns the disk usage for a group grouped
      by location and quota type system id.
    </description>
  </query>
  
  <query id="GET_FILES_IN_DIRECTORY" type="HQL">
    <sql>
      SELECT {1}
      FROM FileData f
      WHERE f.directory = :directory
    </sql>
    <description>
      A Hibernate query that gets the files
      in a given directory.
    </description>
  </query>

  <query id="GET_FILES_FOR_FILESERVER" type="HQL">
    <sql>
      SELECT {1}
      FROM FileData f
      WHERE f.fileServer = :fileServer
    </sql>
    <description>
      A Hibernate query that gets the files
      with a given file server.
    </description>
  </query>


  <query id="GET_SUBDIRECTORIES_IN_DIRECTORY" type="HQL">
    <sql>
      SELECT {1}
      FROM DirectoryData d
      WHERE d.parent = :directory
    </sql>
    <description>
      A Hibernate query that gets the subdirectories
      in a given directory.
    </description>
  </query>
  
  <query id="GET_HOME_DIRECTORIES" type="HQL">
    <sql>
      SELECT {1}
      FROM UserData usr
      WHERE usr.homeDirectory = :directory
    </sql>
    <description>
      A Hibernate query that gets the users having
      the specified directory as home directory.
    </description>
  </query>
  
  <query id="GET_EXPERIMENT_DIRECTORIES" type="HQL">
    <sql>
      SELECT {1}
      FROM ExperimentData xpr
      WHERE xpr.directory = :directory
    </sql>
    <description>
      A Hibernate query that gets the experiments having
      the specified directory as the plugin directory.
    </description>
  </query>

  <query id="GET_SUBDIRECTORIES" type="HQL">
    <sql>
      SELECT dir
      FROM DirectoryData dir
      WHERE dir.parent = :parent
    </sql>
    <description>
      A Hibernate query that returns all subdirectories in a directory.
    </description>
  </query>
  
  <query id="GET_SUBDIRECTORY_WITH_NAME" type="HQL">
    <sql>
      SELECT dir
      FROM DirectoryData dir
      WHERE dir.name = :name
      AND dir.parent = :parent
    </sql>
    <description>
      A Hibernate query that returns the a subdirectory with the
      specified name in a given directory.
    </description>
  </query>
  
  <query id="GET_QUOTA_TYPE_WITH_NAME" type="HQL">
    <sql>
      SELECT qt
      FROM QuotaTypeData qt
      WHERE qt.name = :name
    </sql>
    <description>
      A Hibernate query that returns the quota type with the specified 
      name.
    </description>
  </query>
  
  <query id="GET_QUOTA_WITH_NAME" type="HQL">
    <sql>
      SELECT q
      FROM QuotaData q
      WHERE q.name = :name
    </sql>
    <description>
      A Hibernate query that returns the quota with the specified 
      name.
    </description>
  </query>
  
  <query id="GET_GROUP_WITH_NAME" type="HQL">
    <sql>
      SELECT grp
      FROM GroupData grp
      WHERE grp.name = :name
    </sql>
    <description>
      A Hibernate query that returns the group with the specified 
      name.
    </description>
  </query>
  
  <query id="GET_ROLE_WITH_NAME" type="HQL">
    <sql>
      SELECT rle
      FROM RoleData rle
      WHERE rle.name = :name
    </sql>
    <description>
      A Hibernate query that returns the role with the specified 
      name.
    </description>
  </query>
  
  <query id="GET_SOFTWARE_WITH_NAME" type="HQL">
    <sql>
      SELECT sw
      FROM SoftwareData sw
      WHERE sw.name = :name
    </sql>
    <description>
      A Hibernate query that returns the software with the specified 
      name.
    </description>
  </query>
  
  <query id="GET_HARDWARE_WITH_NAME" type="HQL">
    <sql>
      SELECT hw
      FROM HardwareData hw
      WHERE hw.name = :name
    </sql>
    <description>
      A Hibernate query that returns the hardware with the specified 
      name.
    </description>
  </query>
  
  <query id="GET_PLATE_GEOMETRY_WITH_SIZE" type="HQL">
    <sql>
      SELECT pg
      FROM PlateGeometryData pg
      WHERE pg.rows = :rows AND pg.columns = :columns
    </sql>
    <description>
      A Hibernate query that returns the plate geometry with the specified 
      size (rows and columns).
    </description>
  </query>

  <query id="GET_PLATE_MAPPING_WITH_PROPERTIES" type="HQL">
    <sql>
      SELECT pm
      FROM PlateMappingData pm
      WHERE pm.sourceCount = :sourceCount AND pm.sourceGeometry = :sourceGeometry
      AND pm.destinationCount = :destinationCount AND pm.destinationGeometry = :destinationGeometry
    </sql>
    <description>
      A Hibernate query that returns the plate mapping with the specified 
      source and destination properties.
    </description>
  </query>
  
  <query id="GET_TAG_WITH_NAME" type="HQL">
    <sql>
      SELECT tag
      FROM TagData tag
      WHERE tag.name = :name
    </sql>
    <description>
      A Hibernate query that returns the tag with the specified 
      name.
    </description>
  </query>
  
  <query id="GET_ANNOTATION_TYPE_WITH_NAME" type="HQL">
    <sql>
      SELECT at
      FROM AnnotationTypeData at
      WHERE at.name = :name
    </sql>
    <description>
      A Hibernate query that returns the annotation type with the specified 
      name.
    </description>
  </query>
  
  <query id="GET_NEWS_WITH_NAME" type="HQL">
    <sql>
      SELECT nws
      FROM NewsData nws
      WHERE nws.name = :name
    </sql>
    <description>
      A Hibernate query that returns the news with the specified 
      name.
    </description>
  </query>

  <query id="GET_FILE_IN_DIRECTORY" type="HQL">
    <sql>
      SELECT f
      FROM FileData f
      WHERE f.directory = :directory
      AND f.name = :name
    </sql>
    <description>
      A Hibernate query that returns the file with the specified 
      name in a given directory.
    </description>
  </query>

  <query id="GET_PLATEEVENTTYPES_FOR_PROTOCOLTYPE" type="HQL">
    <sql>
      SELECT {1}
      FROM PlateEventTypeData pet
      WHERE pet.protocolType = :subtype
    </sql>
    <description>
      Get the plate events types that uses a protocol type.
    </description>
  </query>
  
  <query id="GET_BIOMATERIALEVENTS_FOR_PROTOCOL" type="HQL">
    <sql>
      SELECT {1}
      FROM BioMaterialEventData bme
      WHERE bme.protocol = :protocol
    </sql>
    <description>
      A Hibernate query that gets biomaterial
      events using a protocol.
    </description>
  </query>

  <query id="GET_PLATEEVENTS_FOR_PROTOCOL" type="HQL">
    <sql>
      SELECT {1}
      FROM PlateEventData pe
      WHERE pe.protocol = :protocol
    </sql>
    <description>
      A Hibernate query thatgets plate events
      using a protocol.
    </description>
  </query>

  <query id="GET_ARRAYBATCHES_FOR_PROTOCOL" type="HQL">
    <sql>
      SELECT {1}
      FROM ArrayBatchData ab
      WHERE ab.protocol = :protocol
    </sql>
    <description>
      A Hibernate query that gets array batches
      using a protocol.
    </description>
  </query>

  <query id="GET_DERIVEDBIOASSAY_FOR_PROTOCOL" type="HQL">
    <sql>
      SELECT {1}
      FROM DerivedBioAssayData dba
      WHERE dba.protocol = :protocol
    </sql>
    <description>
      A Hibernate query that gets derived bioassays
      using a protocol.
    </description>
  </query>

  <query id="GET_RAWBIOASSAYS_FOR_PROTOCOL" type="HQL">
    <sql>
      SELECT {1}
      FROM RawBioAssayData rba
      WHERE rba.protocol = :protocol
    </sql>
    <description>
      A Hibernate query that gets raw bioassays
      using a protocol.
    </description>
  </query>

  <query id="GET_BIOMATERIALEVENTS_FOR_KIT" type="HQL">
    <sql>
      SELECT {1}
      FROM BioMaterialEventData bme
      WHERE bme.kit = :kit
    </sql>
    <description>
      A Hibernate query that gets biomaterial
      events using a kit.
    </description>
  </query>

  <query id="GET_BIOPLATEEVENTS_FOR_KIT" type="HQL">
    <sql>
      SELECT {1}
      FROM BioPlateEventData bpe
      WHERE bpe.kit = :kit
    </sql>
    <description>
      A Hibernate query that gets bioplate events
      events using a kit.
    </description>
  </query>
  
  <query id="GET_DERIVEDBIOASSAYS_FOR_KIT" type="HQL">
    <sql>
      SELECT {1}
      FROM DerivedBioAssayData dba
      WHERE dba.kit = :kit
    </sql>
    <description>
      A Hibernate query that gets derived bioassays using a kit.
    </description>
  </query>

  <query id="FIND_USED_FILES" type="HQL">
    <sql>
      SELECT fad
      FROM net.sf.basedb.core.data.FileAttachableData fad
      WHERE fad.file = :file
    </sql>
    <description>
      Load the files that is used by any FileAttachableData.
    </description>
  </query>

  <query id="GET_FILESETMEMBERS_FOR_FILE" type="HQL">
    <sql>
      SELECT {1}
      FROM FileSetMemberData fsm
      WHERE fsm.file = :file
    </sql>
    <description>
      A Hibernate query that gets file set membership
      for a given file
    </description>
  </query>
  
  <query id="GET_DERIVEDBIOASSAYS_FOR_HARDWARE" type="HQL">
    <sql>
        SELECT {1}
        FROM DerivedBioAssayData dba
        WHERE dba.hardware = :hardware
    </sql>
    <description>
      A Hibernate query that gets derived bioassays which
      uses a given hardware.
    </description>
  </query>
  
  <query id="GET_ARRAYBATCHES_FOR_PRINTROBOT" type="HQL">
    <sql>
      SELECT {1}
      FROM ArrayBatchData ab
      WHERE ab.printRobot = :printrobot
    </sql>
    <description>
      A Hibernate query that gets array batches which
      uses a given print robot (hardware).
    </description>
  </query>
  
  <query id="GET_BIOMATERIALEVENTS_FOR_HARDWARE" type="HQL">
    <sql>
      SELECT {1}
      FROM BioMaterialEventData bme
      WHERE bme.hardware = :hardware
    </sql>
    <description>
      A Hibernate query that gets biomaterial events which
      uses a given hardware.
    </description>
  </query>
  
  <query id="GET_PLATEEVENTS_FOR_HARDWARE" type="HQL">
    <sql>
      SELECT {1}
      FROM PlateEventData ple
      WHERE ple.hardware = :hardware
    </sql>
    <description>
      A Hibernate query that gets plates events which
      uses a given hardware.
    </description>
  </query>

  <query id="GET_REPORTERS_FOR_REPORTERTYPE" type="HQL">
    <sql>
      SELECT {1}
      FROM ReporterData rpt
      WHERE rpt.reporterType = :reporterType
    </sql>
    <description>
      A Hibernate query that gets reporter items
      of the given reporter type.
    </description>
  </query>

  <query id="GET_REPORTER_FOR_EXTERNAL_ID" type="HQL">
    <sql>
      SELECT rpt
      FROM ReporterData rpt
      WHERE rpt.externalId = :externalId
    </sql>
    <description>
      A Hibernate query that finds the reporter with a given external id.
    </description>
  </query>

  <query id="GET_RAWBIOASSAYS_FOR_SOFTWARE" type="HQL">
    <sql>
      SELECT {1}
      FROM RawBioAssayData rba
      WHERE rba.software = :software
    </sql>
    <description>
      A Hibernate query that gets the raw bioassays
      produced from a given software.
    </description>
  </query>

  <query id="GET_DERIVEDBIOASSAYS_FOR_SOFTWARE" type="HQL">
    <sql>
      SELECT {1}
      FROM DerivedBioAssayData dba
      WHERE dba.software = :software
    </sql>
    <description>
      A Hibernate query that gets the derived bioassay
      using a given software.
    </description>
  </query>


  <query id="GET_ANNOTATIONS_FOR_ANNOTATIONTYPE" type="HQL">
    <sql>
      SELECT {1}
      FROM AnnotationData a
      WHERE a.annotationType = :annotationType
    </sql>
    <description>
      A Hibernate query that gets annotations 
      of the given annotation type.
    </description>
  </query>
  
  <query id="GET_EXPERIMENTS_FOR_ANNOTATIONTYPE" type="HQL">
    <sql>
      SELECT {1}
      FROM ExperimentData exp
      JOIN exp.experimentalFactors ef
      WHERE ef = :annotationType
    </sql>
    <description>
      A Hibernate query that gets experiments
      where the given annotation type is used as an experimental factor.
    </description>
  </query>
  
  <query id="GET_PROTOCOLS_FOR_ANNOTATIONTYPE" type="HQL">
    <sql>
      SELECT {1}
      FROM ProtocolData prt
      JOIN prt.parameters pp
      WHERE pp = :annotationType
    </sql>
    <description>
      A Hibernate query that gets protocols
      where the given annotation type is used as a protocol parameter.
    </description>
  </query>

  <query id="GET_SAMPLES_FOR_BIOSOURCE" type="HQL">
    <sql>
      SELECT {1}
      FROM SampleData s
      WHERE s.parent = :biosource
    </sql>
    <description>
      A Hibernate query that gets samples 
      created from a given biosource.
    </description>
  </query>

  <query id="GET_EXTRACTS_FOR_SAMPLE" type="HQL">
    <sql>
      SELECT {1}
      FROM ExtractData e
      WHERE e.parent = :sample
    </sql>
    <description>
      A Hibernate query that gets extracts 
      created from a given sample.
    </description>
  </query>
  
  <query id="GET_EXTRACTS_FOR_TAG" type="HQL">
    <sql>
      SELECT {1}
      FROM ExtractData ext
      WHERE ext.tag = :tag
    </sql>
    <description>
      A Hibernate query that gets extracts with a given tag.
    </description>
  </query>

  <query id="GET_SOURCEEVENTS_FOR_BIOMATERIAL" type="HQL">
    <sql>
      SELECT {1}
      FROM BioMaterialEventData bme
      JOIN bme.sources src
      WHERE src.bioMaterial = :bioMaterial
    </sql>
    <description>
      A Hibernate query that gets the events where a given
      biomaterial has been part of as a source biomaterial, ie. the number 
      of pooled biomaterials that have been created from it.
    </description>
  </query>

  <query id="GET_DERIVEDBIOASSAYS_FOR_EXTRACT" type="HQL">
    <sql>
      SELECT {1}
      FROM DerivedBioAssayData dba
      WHERE dba.extract = :extract
    </sql>
    <description>
      A Hibernate query that gets the derived bioassays
      that are referencing a given extract.
    </description>
  </query>

  <query id="GET_RAWBIOASSAYS_FOR_EXTRACT" type="HQL">
    <sql>
      SELECT {1}
      FROM RawBioAssayData rba
      WHERE rba.parentExtract = :extract
    </sql>
    <description>
      A Hibernate query that gets the raw bioassays
      that are referencing a given extract.
    </description>
  </query>

  <query id="COUNT_UNREAD_MESSAGES_FOR_USER" type="HQL">
    <sql>
      SELECT count(*) 
      FROM MessageData msg
      WHERE msg.to = :user AND msg.read = false AND msg.removedBy IS NULL
    </sql>
    <description>
      A Hibernate query that counts the number of
      unread messages for a given user
    </description>
  </query>
  
  <query id="GET_PLATETYPES_FOR_PLATEGEOMETRY" type="HQL">
    <sql>
      SELECT {1}
      FROM PlateTypeData pt
      WHERE pt.plateGeometry = :plateGeometry
    </sql>
    <description>
      A Hibernate query that gets the
      plate types using a given plate geometry
    </description>
  </query>
  
  <query id="GET_PLATEMAPPINGS_FOR_PLATEGEOMETRY" type="HQL">
    <sql>
      SELECT {1}
      FROM PlateMappingData pm
      WHERE pm.sourceGeometry = :plateGeometry
      OR pm.destinationGeometry = :plateGeometry
    </sql>
    <description>
      A Hibernate query that gets the
      plate mappings using a given plate geometry as source or destination
    </description>
  </query>

  <query id="GET_BIOPLATES_FOR_PLATEGEOMETRY" type="HQL">
    <sql>
      SELECT {1}
      FROM BioPlateData bp
      WHERE bp.plateGeometry = :plateGeometry
    </sql>
    <description>
      A Hibernate query that gets the
      bioplates using of given plate geometry
    </description>
  </query>

  <query id="GET_PLATES_FOR_PLATETYPE" type="HQL">
    <sql>
      SELECT {1}
      FROM PlateData p
      WHERE p.plateType = :plateType
    </sql>
    <description>
      A Hibernate query that gets
      plates of a specific plate type.
    </description>
  </query>

  <query id="GET_PLATEEVENTS_FOR_PLATEEVENTTYPE" type="HQL">
    <sql>
      SELECT {1}
      FROM PlateEventData pe
      WHERE pe.plateEventType = :plateEventType
    </sql>
    <description>
      A Hibernate query that gets
      plate events of the given plate event type.
    </description>
  </query>

  <query id="GET_CHILDPLATES_FOR_PLATE" type="HQL">
    <sql>
      SELECT {1}
      FROM PlateData p
      JOIN p.parents pp
      WHERE pp = :plate
    </sql>
    <description>
      A Hibernate query that gets the
      child plates for a given plate.
    </description>
  </query>

  <query id="GET_ARRAYDESIGNS_FOR_PLATE" type="HQL">
    <sql>
      SELECT {1}
      FROM ArrayDesignData ad
      JOIN ad.plates p
      WHERE p = :plate
    </sql>
    <description>
      A Hibernate query that gets the
      array designs that has used a given plate.
    </description>
  </query>

  <query id="GET_PLATES_FOR_PLATEMAPPING" type="HQL">
    <sql>
      SELECT {1}
      FROM PlateData p
      WHERE p.plateMapping = :plateMapping
    </sql>
    <description>
      A Hibernate query that gets the
      plates that has been created from a given plate mapping.
    </description>
  </query>
  
  <query id="GET_FEATURES_FOR_WELL" type="HQL">
    <sql>
      SELECT {1}
      FROM FeatureData f
      WHERE f.well = :well
    </sql>
    <description>
      A Hibernate query that gets the
      features using a given well.
    </description>
  </query>

  <query id="COUNT_FEATURES_FOR_ARRAYDESIGN" type="HQL">
    <sql>
      SELECT count(*)
      FROM FeatureData f
      WHERE f.arrayDesignBlock.arrayDesign = :arrayDesign
    </sql>
    <description>
      A Hibernate query that counts the number of
      features on a given array design
    </description>
  </query>


  <query id="GET_CHILDWELLS_FOR_WELL" type="HQL">
    <sql>
      SELECT {1}
      FROM Well w
      WHERE w.parent = :well
    </sql>
    <description>
      A Hibernate query that gets the
      child wells of a given well.
    </description>
  </query>

  <query id="GET_PLUGINCONFIGURATIONS_FOR_PLUGINDEFINITION" type="HQL">
    <sql>
      SELECT {1}
      FROM PluginConfigurationData pc
      WHERE pc.pluginDefinition = :pluginDefinition
    </sql>
    <description>
      A Hibernate query that gets plugin configurations
      using a plugin definition.
    </description>
  </query>
  
  <query id="GET_JOBS_FOR_PLUGINCONFIGURATION" type="HQL">
    <sql>
      SELECT {1}
      FROM JobData j
      WHERE j.pluginConfiguration = :pluginConfiguration
    </sql>
    <description>
      A Hibernate query that gets the jobs
      using a specific plugin configuration.
    </description>
  </query>
  
  <query id="GET_JOBS_FOR_PLUGINDEFINITION" type="HQL">
    <sql>
      SELECT {1}
      FROM JobData j
      WHERE j.pluginDefinition = :pluginDefinition
    </sql>
    <description>
      A Hibernate query that gets the jobs
      using a specific plugin definition.
    </description>
  </query>

  <query id="FIND_JOBS_IN_QUEUE" type="HQL">
    <sql>
      SELECT job
      FROM JobData job
      WHERE job.status = :status
      AND job.type = :type
      AND job.removedBy IS NULL
      ORDER BY job.priority ASC, job.scheduled ASC
    </sql>
    <description>
      A Hibernate query that loads plugin jobs in the job queue waiting to be
      executed sorted by priority and waiting time. The query should return all
      jobs, ignoring all settings specifying that the internal job queue should
      not be used.
    </description>
  </query>
  
  <query id="FIND_INTERNAL_JOBS_IN_QUEUE" type="HQL">
    <sql>
      SELECT job
      FROM JobData job
      WHERE job.status = :status
      AND job.type = :type
      AND job.removedBy IS NULL
      AND job.pluginDefinition.useInternalJobQueue = true
      AND job.jobAgentId IS NULL
      ORDER BY job.priority ASC, job.scheduled ASC
    </sql>
    <description>
      A Hibernate query that loads plugin jobs in the job queue waiting to be
      executed sorted by priority and waiting time. It should only return
      jobs where the plug-in setting useInternalJobQueue=true and no
      specific job agent has been selected for the job.
    </description>
  </query>
  
  <query id="FIND_EXTERNAL_JOBS_FOR_STATUS_UPDATE" type="HQL">
    <sql>
      SELECT job
      FROM JobData job
      WHERE job.type = :type
      AND job.removedBy IS NULL
      AND NOT job.signalTransporter IS NULL
    </sql>
    <description>
      A Hibernate query that loads external jobs in the job queue that
      has a non-null signal transporter so that it may be possible to 
      send a signal request for status update to them,
    </description>
  </query>
  
  <query id="GET_ARRAYSLIDES_FOR_BATCH" type="HQL">
    <sql>
      SELECT {1}
      FROM ArraySlideData a
      WHERE a.arrayBatch = :arrayBatch
    </sql>
    <description>
      A Hibernate query that gets the array slides
      in an array batch.
    </description>
  </query>

  <query id="GET_ARRAYSLIDES_WITH_BARCODE" type="HQL">
    <sql>
      SELECT {1}
      FROM ArraySlideData ars
      WHERE ars.barcode = :barcode
    </sql>
    <description>
      A Hibernate query that gets the array slides
      with a given barcode.
    </description>
  </query>


  <query id="GET_ARRAYBATCHES_FOR_ARRAYDESIGN" type="HQL">
    <sql>
      SELECT {1}
      FROM ArrayBatchData a
      WHERE a.arrayDesign = :arrayDesign
    </sql>
    <description>
      A Hibernate query that gets array batches
      that uses a specific array design.
    </description>
  </query>

  <query id="GET_RAWBIOASSAYS_FOR_ARRAYDESIGN" type="HQL">
    <sql>
      SELECT {1}
      FROM RawBioAssayData rba
      WHERE rba.arrayDesign = :arrayDesign
    </sql>
    <description>
      A Hibernate query that gets raw bioassays
      that uses a specific array design.
    </description>
  </query>

  <query id="GET_ROOT_DERIVEDBIOASSAYS_FOR_PHYSICALBIOASSAY" type="HQL">
    <sql>
      SELECT {1}
      FROM DerivedBioAssayData dba
      INNER JOIN dba.physicalBioAssays pba
      WHERE pba = :bioAssay
      AND dba.root = true
    </sql>
    <description>
      A Hibernate query that gets root derived bioassays
      created from a specific physical bioassay.
    </description>
  </query>

  <query id="GET_CHILD_DERIVEDBIOASSAYS_FOR_DERIVEDBIOASSAY" type="HQL">
    <sql>
      SELECT {1}
      FROM DerivedBioAssayData dba
      INNER JOIN dba.parents p
      WHERE p = :bioAssay
    </sql>
    <description>
      A Hibernate query that gets child derived bioassays
      created from a specific derived bioassay.
    </description>
  </query>


  <query id="GET_RAWBIOASSAYS_FOR_DERIVEDBIOASSAY" type="HQL">
    <sql>
      SELECT {1}
      FROM RawBioAssayData rba
      WHERE rba.parentBioAssay = :bioAssay
    </sql>
    <description>
      A Hibernate query that gets raw bioassays
      created from a specific derived bioassay.
    </description>
  </query>

  <query id="PRELOAD_FEATURES" type="HQL">
    <sql>
      SELECT f
      FROM FeatureData f
      JOIN FETCH f.arrayDesignBlock b
      LEFT JOIN FETCH f.reporter
      WHERE b.arrayDesign = :arrayDesign
    </sql>
    <description>
      A Hibernate query that loads features, blocks and reporters
      for a single array design.
    </description>
  </query>
  
  <query id="DELETE_FEATURES_FOR_ARRAYDESIGN" type="HQL">
    <sql>
      DELETE FROM Features f, ArrayDesignBlocks adb
      WHERE adb.id = f.arraydesignblock_id AND adb.arraydesign_id = ?
    </sql>
    <description>
      A Hibernate query that deletes all features for an array design.
    </description>
  </query>

  <query id="GET_PLUGINTYPE_FOR_INTERFACENAME" type="HQL">
    <sql>
      SELECT plt
      FROM PluginTypeData plt
      WHERE plt.interfaceName = :interfaceName
    </sql>
    <description>
      Load a plugin type when you know the interface name.
    </description>
  </query>

  <query id="GET_PLUGINDEFINITION_FOR_CLASSNAME" type="HQL">
    <sql>
      SELECT pd
      FROM PluginDefinitionData pd
      WHERE pd.className = :className
    </sql>
    <description>
      Load a plugin definition when you know the class name.
    </description>
  </query>

  <query id="GET_PLUGINCONFIGURATION_FOR_PLUGIN_WITH_NAME" type="HQL">
    <sql>
      SELECT pc
      FROM PluginConfigurationData pc
      WHERE pc.pluginDefinition.className = :className
      AND pc.name = :name
    </sql>
    <description>
      Load a plugin configuration for a given plug-in and with a given name
    </description>
  </query>


  <query id="GET_EXPERIMENTS_FOR_RAWBIOASSAY" type="HQL">
    <sql>
      SELECT {1}
      FROM ExperimentData xp
      JOIN xp.rawBioAssays rba
      WHERE rba = :rawBioAssay
    </sql>
    <description>
      A Hibernate query that gets the experiments
      using a specific raw bioassay.
    </description>
  </query>
  
  <query id="GET_TRANSFORMATIONS_FOR_RAWBIOASSAY" type="HQL">
    <sql>
      SELECT {1}
      FROM TransformationData trf
      JOIN trf.rawSources rba
      WHERE rba = :rawBioAssay
    </sql>
    <description>
      A Hibernate query that gets the transformations
      using a specifiec raw bioassay.
    </description>
  </query>
  
  <query id="GET_TRANSFORMATIONS_FOR_JOB" type="HQL">
    <sql>
      SELECT {1}
      FROM TransformationData trf
      WHERE trf.job = :job
    </sql>
    <description>
      A Hibernate query that gets transformations
      linked to a job.
    </description>
  </query>
  
  <query id="GET_RAWBIOASSAYS_FOR_JOB" type="HQL">
    <sql>
      SELECT {1}
      FROM RawBioAssayData rba
      WHERE rba.job = :job
    </sql>
    <description>
      A Hibernate query that gets raw bioassays
      linked to a job.
    </description>
  </query>
  
  <query id="GET_ARRAYDESIGNS_FOR_JOB" type="HQL">
    <sql>
      SELECT {1}
      FROM ArrayDesignData ad
      WHERE ad.job = :job
    </sql>
    <description>
      A Hibernate query that gets array designs
      linked to a job.
    </description>
  </query>
  
  <query id="GET_DERIVEDBIOASSAYS_FOR_JOB" type="HQL">
    <sql>
      SELECT {1}
      FROM DerivedBioAssayData dba
      WHERE dba.job = :job
    </sql>
    <description>
      A Hibernate query that gets derived bioassays
      linked to a job.
    </description>
  </query>

  <query id="FIND_CHILD_BIOASSAYSETS" type="HQL">
    <sql>
      SELECT bas 
      FROM BioAssaySetData bas
      WHERE bas.transformation.source = :parent
    </sql>
    <description>
      A Hibernate query that returns all bioassaysets that are 
      children to a specified parent bioassayset.
    </description>
  </query>
  
  <query id="FIND_DATACUBES_FOR_BIOASSAYSETS" type="HQL">
    <sql>
      SELECT DISTINCT cbe
      FROM BioAssaySetData bas
      JOIN bas.dataCubeLayer.dataCube cbe
      WHERE bas IN (:basList)
    </sql>
    <description>
      A Hibernate query that returns all data cubes that are 
      used by the specified list of bioassaysets
    </description>
  </query>
  
  <query id="FIND_DATACUBES_USED_BY_OTHERS" type="HQL">
    <sql>
      SELECT DISTINCT cbe
      FROM BioAssaySetData bas
      JOIN bas.dataCubeLayer.dataCube cbe
      WHERE bas NOT IN (:basList)
      AND cbe IN (:possibleCubes)
    </sql>
    <description>
      A Hibernate query that, given a list of data cubes and bioassaysets,
      returns all of those data cubes that are also used by other bioassaysets.
    </description>
  </query>

  <query id="FIND_DATACUBELAYERS_FOR_BIOASSAYSETS" type="HQL">
    <sql>
      SELECT lay
      FROM BioAssaySetData bas
      JOIN bas.dataCubeLayer lay
      WHERE bas IN (:basList)
    </sql>
    <description>
      A Hibernate query that returns all data cube layers that are 
      used by the specified list of bioassaysets
    </description>
  </query>
  
  <query id="FIND_DATACUBELAYERS_FOR_BIOASSAYSETS_IGNORE_DELETED_DATACUBES" type="HQL">
    <sql>
      SELECT lay
      FROM BioAssaySetData bas
      JOIN bas.dataCubeLayer lay
      WHERE bas IN (:basList)
      AND lay.dataCube NOT IN (:deletedCubes)
    </sql>
    <description>
      A Hibernate query that returns all data cube layers that are 
      used by the specified list of bioassaysets but not are part of the
      list of already deleted data cubes.
    </description>
  </query>

  <query id="FIND_DATACUBELAYERS_USED_BY_OTHERS" type="HQL">
    <sql>
      SELECT lay
      FROM BioAssaySetData bas
      JOIN bas.dataCubeLayer lay
      WHERE bas NOT IN (:basList)
      AND lay IN (:possibleLayers)
    </sql>
    <description>
      A Hibernate query that, given a list of data cube layers and bioassaysets,
      returns all of those data cube layers that are also used by other bioassaysets.
    </description>
  </query>

  <query id="FIND_DATACUBEFILTERS_FOR_BIOASSAYSETS" type="HQL">
    <sql>
      SELECT flt
      FROM BioAssaySetData bas
      JOIN bas.dataCubeFilter flt
      WHERE bas IN (:basList)
    </sql>
    <description>
      A Hibernate query that returns all data cube filters that are 
      used by the specified list of bioassaysets
    </description>
  </query>
  
  <query id="FIND_DATACUBEFILTERS_FOR_BIOASSAYSETS_IGNORE_DELETED_DATACUBES" type="HQL">
    <sql>
      SELECT flt
      FROM BioAssaySetData bas
      JOIN bas.dataCubeFilter flt
      WHERE bas IN (:basList)
      AND flt.dataCube NOT IN (:deletedCubes)
    </sql>
    <description>
      A Hibernate query that returns all data cube filters that are 
      used by the specified list of bioassaysets but not are part of the
      list of already deleted data cubes.
    </description>
  </query>

  <query id="FIND_DATACUBEFILTERS_USED_BY_OTHERS" type="HQL">
    <sql>
      SELECT flt
      FROM BioAssaySetData bas
      JOIN bas.dataCubeFilter flt
      WHERE bas NOT IN (:basList)
      AND flt IN (:possibleFilters)
    </sql>
    <description>
      A Hibernate query that, given a list of data cube filters and bioassaysets,
      returns all of those data cube filters that are also used by other bioassaysets.
    </description>
  </query>

  <query id="FIND_DATACUBEEXTRAVALUES_FOR_BIOASSAYSETS" type="HQL">
    <sql>
      SELECT dcev
      FROM BioAssaySetData bas
      JOIN bas.extraValues ev
      JOIN ev.dataCubeExtraValue dcev
      WHERE bas IN (:basList)
    </sql>
    <description>
      A Hibernate query that returns all data cube extra values that are 
      used by the specified list of bioassaysets
    </description>
  </query>
  
  <query id="FIND_DATACUBEEXTRAVALUES_FOR_BIOASSAYSETS_IGNORE_DELETED_DATACUBES" type="HQL">
    <sql>
      SELECT dcev
      FROM BioAssaySetData bas
      JOIN bas.extraValues ev
      JOIN ev.dataCubeExtraValue dcev
      WHERE bas IN (:basList)
      AND dcev.dataCube NOT IN (:deletedCubes)
    </sql>
    <description>
      A Hibernate query that returns all data cube extra values that are 
      used by the specified list of bioassaysets but not are part of the
      list of already deleted data cubes.
    </description>
  </query>

  <query id="FIND_DATACUBEEXTRAVALUES_USED_BY_OTHERS" type="HQL">
    <sql>
      SELECT dcev
      FROM BioAssaySetData bas
      JOIN bas.extraValues ev
      JOIN ev.dataCubeExtraValue dcev
      WHERE bas NOT IN (:basList)
      AND dcev IN (:possibleExtraValues)
    </sql>
    <description>
      A Hibernate query that, given a list of data cube extra values and bioassaysets,
      returns all of those data cube extra values that are also used by other bioassaysets.
    </description>
  </query>

  <query id="GET_EXTRAVALUETYPE_FOR_EXTERNAL_ID" type="HQL">
    <sql>
      SELECT evt
      FROM ExtraValueTypeData evt
      WHERE evt.externalId = :externalId
    </sql>
    <description>
      Load an extra value type when you know the external id.
    </description>
  </query>

  <query id="GET_EXTRAVALUES_FOR_EXTRAVALUETYPE" type="HQL">
    <sql>
      SELECT {1}
      FROM ExtraValueData ev
      WHERE ev.extraValueType = :extraValueType
    </sql>
    <description>
      A Hibernate query that gets extra values
      of a specific type.
    </description>
  </query>
  
  <query id="LOAD_CONTEXT_NAMES" type="HQL">
    <sql>
      SELECT ctx.id, ctx.name
      FROM ContextData ctx
      WHERE ctx.client = :client AND 
      (ctx.user = :user OR ctx.public = true) 
      AND ctx.itemType = :itemType
      AND ctx.subContext = :subContext
      ORDER BY ctx.name
    </sql>
    <description>
      A Hibernate query that selects the id and name of all contexts for
      a user and item type. The names should be sorted in ascending order.
    </description>
  </query>
  
  <query id="LOAD_CONTEXT_BY_NAME" type="HQL">
    <sql>
      SELECT ctx
      FROM ContextData ctx
      WHERE ctx.user = :user
      AND ctx.client = :client
      AND ctx.itemType = :itemType
      AND ctx.subContext  = :subContext
      AND ctx.name = :name
    </sql>
    <description>
      A Hibernate query that load a context given the user, client,
      item type, subcontext and name of the context.
    </description>
  </query>
  
  <query id="LOAD_USER_CONTEXTS" type="HQL">
    <sql>
      SELECT ctx
      FROM ContextData ctx
      WHERE ctx.user.id = :user
      AND ctx.client.id = :client
      AND ctx.name = :name
    </sql>
    <description>
      A Hibernate query that loads all saved context information
      with a given name for a specific user/client.
    </description>
  </query>

  <query id="COUNT_PLUGINS_BY_TYPE_FOR_CONTEXT" type="HQL">
    <sql>
      SELECT plg.mainType, count(DISTINCT plg.id)
      FROM PluginDefinitionData plg
      JOIN plg.guiContexts gcx
      LEFT JOIN plg.configurations cfg
      WITH true = :hasConfigPermission OR cfg.owner.id = :owner 
        OR cfg.itemKey.id IN (:itemKeys) OR cfg.projectKey.id IN (:projectKeys)
      WHERE 
        (true = :hasPluginPermission OR plg.owner.id = :owner 
        OR plg.itemKey.id IN (:itemKeys) OR plg.projectKey.id IN (:projectKeys))
      AND gcx.itemType = :itemType AND gcx.contextType = :contextType
      AND (
        (plg.requiresConfiguration = false)
        OR
        (plg.requiresConfiguration = true AND cfg.parameterVersion > 0)
      )
      AND plg.disabled = false
      GROUP BY plg.mainType
    </sql>
    <description>
      A Hibernate query that counts the number of plugins available for a 
      given GUI context grouped by the main type of the plugins taking
      the requirement of configurations and user permissions into account.
    </description>
  </query>
  
  <query id="GET_FORMULA_WITH_NAME_AND_CHANNELS" type="HQL">
    <sql>
      SELECT fml 
      FROM FormulaData fml
      WHERE fml.name = :name
      AND fml.channels = :channels
    </sql>
    <description>
      A Hibernate query that loads a formula with a given name and number
      of channels.
    </description>
  </query>

  <query id="GET_FORMULA_WITH_NAME_AND_TYPE" type="HQL">
    <sql>
      SELECT fml 
      FROM FormulaData fml
      WHERE fml.name = :name
      AND fml.rawDataType = :rawDataType
    </sql>
    <description>
      A Hibernate query that loads a formula with a given name and raw data type.
    </description>
  </query>
  
  <query id="GET_HELP_FOR_EXTERNAL_ID" type="HQL">
    <sql>
      SELECT hlp
      FROM HelpData hlp
      WHERE hlp.externalId = :externalId AND hlp.client = :client
    </sql>
    <description>
      A Hibernate query that loads a help text.
    </description>
  </query>
  
  <query id="GET_SCHEMA_VERSION_FOR_APP" type="HQL">
    <sql>
      SELECT sv
      FROM SchemaVersionData sv
      WHERE sv.appId = :appId
    </sql>
    <description>
      A Hibernate query that loads the schema version for a
      given application (there should only be one record since appId is unique).
    </description>
  </query>
  
  <query id="SET_SCHEMA_VERSION_FOR_APP" type="HQL">
    <sql>
      UPDATE SchemaVersionData sv
      SET sv.schemaVersion = :schemaVersion,
      sv.build = :build
      WHERE sv.appId = :appId
    </sql>
    <description>
      A Hibernate query that updates the schema version and build number.
    </description>
  </query>
  
  <query id="GET_PRIMARY_ANNOTATION" type="HQL">
    <sql>
      SELECT ad
      FROM AnnotationData ad
      WHERE ad.annotationType = :annotationType
      AND ad.annotationSet = :annotationSet
      AND ad.source = 0
    </sql>
    <description>
      A Hibernate query that loads the primary annotation of a specific
      annotation type for a given annotation set.
    </description>
  </query>
  
  <query id="LOAD_ANNOTATIONSET_INHERITING_ANNOTATIONTYPE" type="SQL">
    <sql>
      SELECT [a].[annotationset_id] FROM [Annotations] [a]
      WHERE [a].[annotationtype_id] = :annotationType
      AND [a].[source] != 0
    </sql>
    <description>
      An SQL query that load the ID of all annotation sets that
      are inheriting a given annotation type.
    </description>
  </query>
  
  <query id="DELETE_INHERITED_ANNOTATIONS" type="SQL">
    <sql>
      DELETE FROM [Annotations]
      WHERE [annotationtype_id] = :annotationType
      AND [source] != 0
    </sql>
    <description>
      An SQL query that delete all inherited annotations of the specified 
      annotation type.
    </description>
  </query>
  
  <query id="NULLIFY_LINK_FROM_CLONES" type="HQL">
    <sql>
      UPDATE AnnotationData ad
      SET ad.inheritedFrom = null
      WHERE ad.inheritedFrom = :targetId
      AND ad.source = 2
    </sql>
    <description>
      A HQL query that nullify the link from all cloned annotations
      to a specified target annotation.
    </description>
  </query>
  
  <query id="UPDATE_BYTES_FOR_EXPERIMENT" type="HQL">
    <sql>
      UPDATE ExperimentData xpm
      SET xpm.bytes = xpm.bytes + :addedBytes
      WHERE xpm.id = :experiment
    </sql>
    <description>
      A Hibernate query that updates the number of bytes used by an experiment.
    </description>
  </query>

  <query id="UPDATE_BYTES_FOR_DATACUBE" type="HQL">
    <sql>
      UPDATE DataCubeData dcd
      SET dcd.bytes = dcd.bytes + :addedBytes
      WHERE dcd.id = :dataCube
    </sql>
    <description>
      A Hibernate query that updates the number of bytes used by a data cube.
    </description>
  </query>
  
  <query id="GET_REMOVED_ITEMS" type="HQL">
    <sql>
      SELECT trash
      FROM net.sf.basedb.core.data.RemovableData trash
      WHERE NOT trash.removedBy IS NULL
    </sql>
    <description>
      A Hibernate query that loads all items flagged for deletion.
    </description>
  </query>
  
  <query id="UPDATE_REMAINING_QUANTITY" type="HQL">
    <sql>
      UPDATE MeasuredBioMaterialData mbm 
      SET mbm.remainingQuantity = mbm.remainingQuantity - :used
      WHERE mbm = :bioMaterial
    </sql>
    <description>
      A Hibernate query that adds/removes the remaining quantity on a
      measuered biomaterial.
    </description>
  </query>
  
  <query id="GET_REMAINING_QUANTITY" type="HQL">
    <sql>
      SELECT mbm.remainingQuantity
      FROM MeasuredBioMaterialData mbm
      WHERE mbm = :bioMaterial
    </sql>
    <description>
      A Hibernate query that load the remaining quantity for a
      measuered biomaterial.
    </description>
  </query>

  <query id="GET_ANYTOANY_FOR_NAME" type="HQL">
    <sql>
      SELECT ata
      FROM AnyToAnyData ata
      WHERE ata.fromId = :fromId AND ata.fromType = :fromType AND ata.name = :name
    </sql>
    <description>
      A Hibernate query that loads the any-to-any link with the specified name
      for an item.
    </description>
  </query>

  <query id="DELETE_ANYTOANY_FROM" type="HQL">
    <sql>
      DELETE FROM AnyToAnyData ata 
      WHERE ata.fromId = :fromId AND ata.fromType = :fromType AND ata.name = :name
    </sql>
    <description>
      A Hibernate query that deletes a names any-to-any link leading out from
      an item.
    </description>
  </query>


  <query id="DELETE_ALL_ANYTOANY_FROM" type="HQL">
    <sql>
      DELETE FROM AnyToAnyData ata 
      WHERE ata.fromId = :fromId AND ata.fromType = :fromType
    </sql>
    <description>
      A Hibernate query that deletes all any-to-any links leading out from
      an item.
    </description>
  </query>
  
  <query id="DELETE_ALL_ANYTOANY_TO" type="HQL">
    <sql>
      DELETE FROM AnyToAnyData ata 
      WHERE ata.toId = :toId AND ata.toType = :toType
    </sql>
    <description>
      A Hibernate query that deletes all any-to-any links leading in to an item.
    </description>
  </query>

  <query id="DELETE_UNUSED_ANYTOANY_TO" type="HQL">
    <sql>
      DELETE FROM AnyToAnyData ata 
      WHERE ata.toId = :toId AND ata.toType = :toType AND ata.usingTo = false
    </sql>
    <description>
      A Hibernate query that deletes all any-to-any links leading in to
      an item that doesn't count as using the item.
    </description>
  </query>

  <query id="COUNT_USED_ANYTOANY_TO" type="HQL">
    <sql>
      SELECT count(*)
      FROM AnyToAnyData ata
      WHERE ata.toId = :toId AND ata.toType = :toType AND ata.usingTo = true
    </sql>
    <description>
      A Hibernate query that counts the number of any-to-any links
      to a given item that counts as using the item.
    </description>
  </query>

  <query id="FIND_USING_ANYTOANY" type="HQL">
    <sql>
      SELECT ana.fromId, ana.fromType
      FROM AnyToAnyData ana
      WHERE ana.toId = :toId AND ana.toType = :toType AND ana.usingTo = true
    </sql>
    <description>
      A Hibernate query that finds the any-to-any links
      to a given item that counts as using the item.
    </description>
  </query>

  
  <query id="UPDATE_DATACUBENO_FOR_VIRTUALDB" type="HQL">
    <sql>
      UPDATE VirtualDbData vdb
      SET vdb.cubes = vdb.cubes + 1
      WHERE vdb.id = :virtualDb
    </sql>
    <description>
      A Hibernate query that updates the number of data cubes
      for the specified virtual database.
    </description>
  </query>

  <query id="GET_DATACUBENO_FOR_VIRTUALDB" type="HQL">
    <sql>
      SELECT vdb.cubes
      FROM VirtualDbData vdb
      WHERE vdb.id = :virtualDb
    </sql>
    <description>
      A Hibernate query that gets the current number of data cubes
      for the specified virtual database.
    </description>
  </query>
  
  <query id="UPDATE_FILTERNO_FOR_DATACUBE" type="HQL">
    <sql>
      UPDATE DataCubeData dcb
      SET dcb.numFilters = dcb.numFilters + 1
      WHERE dcb.id = :dataCube
    </sql>
    <description>
      A Hibernate query that updates the number of filters
      for the specified data cube.
    </description>
  </query>

  <query id="GET_FILTERNO_FOR_DATACUBE" type="HQL">
    <sql>
      SELECT dcb.numFilters
      FROM DataCubeData dcb
      WHERE dcb.id = :dataCube
    </sql>
    <description>
      A Hibernate query that gets the current number of filters
      for the specified data cube.
    </description>
  </query>

  <query id="UPDATE_EXTRAVALUENO_FOR_DATACUBE" type="HQL">
    <sql>
      UPDATE DataCubeData dcb
      SET dcb.numExtraValues = dcb.numExtraValues + 1
      WHERE dcb.id = :dataCube
    </sql>
    <description>
      A Hibernate query that updates the number of extra values
      for the specified data cube.
    </description>
  </query>

  <query id="GET_EXTRAVALUENO_FOR_DATACUBE" type="HQL">
    <sql>
      SELECT dcb.numExtraValues
      FROM DataCubeData dcb
      WHERE dcb.id = :dataCube
    </sql>
    <description>
      A Hibernate query that gets the current number of extra values
      for the specified data cube.
    </description>
  </query>

  <query id="UPDATE_LAYERNO_FOR_DATACUBE" type="HQL">
    <sql>
      UPDATE DataCubeData dcb
      SET dcb.numLayers = dcb.numLayers + 1
      WHERE dcb.id = :dataCube
    </sql>
    <description>
      A Hibernate query that updates the number of layers
      for the specified data cube.
    </description>
  </query>

  <query id="GET_LAYERNO_FOR_DATACUBE" type="HQL">
    <sql>
      SELECT dcb.numLayers
      FROM DataCubeData dcb
      WHERE dcb.id = :dataCube
    </sql>
    <description>
      A Hibernate query that gets the current number of layers
      for the specified data cube.
    </description>
  </query>

  <query id="UPDATE_COLUMNNO_FOR_DATACUBE" type="HQL">
    <sql>
      UPDATE DataCubeData dcb
      SET dcb.numColumns = dcb.numColumns + 1
      WHERE dcb.id = :dataCube
    </sql>
    <description>
      A Hibernate query that updates the number of columns
      for the specified data cube.
    </description>
  </query>

  <query id="GET_COLUMNNO_FOR_DATACUBE" type="HQL">
    <sql>
      SELECT dcb.numColumns
      FROM DataCubeData dcb
      WHERE dcb.id = :dataCube
    </sql>
    <description>
      A Hibernate query that gets the current number of columns
      for the specified data cube.
    </description>
  </query>

  <query id="GET_JOBAGENT_FOR_EXTERNALID" type="HQL">
    <sql>
      SELECT jag
      FROM JobAgentData jag
      WHERE jag.externalId = :externalId
    </sql>
    <description>
      A Hibernate query that loads the job agent with the specified external ID.
    </description>
  </query>

  <query id="GET_KEYS_FOR_PLUGIN" type="HQL">
    <sql>
      SELECT pdk
      FROM PluginKeys pdk
      WHERE pdk.pluginDefinitionId = :pluginId
      ORDER BY pdk.keyId
    </sql>
    <description>
      A Hibernate query that loads all PluginDefinitionKeys for a specified plugin ID.
    </description>
  </query>
  
  <query id="LOAD_DEFAULT_GROUPS" type="HQL">
    <sql>
      SELECT grp
      FROM GroupData grp
      WHERE grp.default = true
    </sql>
    <description>
      A HQL query that loads all groups which are marked as default
      groups.
    </description>
  </query>
  
  <query id="LOAD_DEFAULT_ROLES" type="HQL">
    <sql>
      SELECT rle
      FROM RoleData rle
      WHERE rle.default = true
    </sql>
    <description>
      A HQL query that loads all roles which are marked as default
      roles.
    </description>
  </query>
  
  <query id="GET_RAWBIOASSAYS_FOR_PLATFORM" type="HQL">
    <sql>
      SELECT {1}
      FROM RawBioAssayData rba
      WHERE rba.platform = :platform
    </sql>
    <description>
      A Hibernate query that gets raw bioassays
      with a given platform.
    </description>
  </query>

  <query id="GET_ARRAYDESIGNS_FOR_PLATFORM" type="HQL">
    <sql>
      SELECT {1}
      FROM ArrayDesignData ad
      WHERE ad.platform = :platform
    </sql>
    <description>
      A Hibernate query that gets array designs
      with a given platform.
    </description>
  </query>
  
  <query id="GET_RAWBIOASSAYS_FOR_VARIANT" type="HQL">
    <sql>
      SELECT {1}
      FROM RawBioAssayData rba
      WHERE rba.variant = :variant
    </sql>
    <description>
      A Hibernate query that gets raw bioassays
      with a given platform variant.
    </description>
  </query>

  <query id="GET_ARRAYDESIGNS_FOR_VARIANT" type="HQL">
    <sql>
      SELECT {1}
      FROM ArrayDesignData ad
      WHERE ad.variant = :variant
    </sql>
    <description>
      A Hibernate query that gets array designs
      with a given platform variant.
    </description>
  </query>
  
  <query id="GET_PLATFORM_FOR_EXTERNAL_ID" type="HQL">
    <sql>
      SELECT plf
      FROM PlatformData plf
      WHERE plf.externalId = :externalId
    </sql>
    <description>
      A Hibernate query that loads a platform by external ID.
    </description>
  </query>
  
  <query id="GET_PLATFORMVARIANT_FOR_EXTERNAL_ID" type="HQL">
    <sql>
      SELECT plv
      FROM PlatformVariantData plv
      WHERE plv.externalId = :externalId
    </sql>
    <description>
      A Hibernate query that loads a platform variant by external ID.
    </description>
  </query>
  
  <query id="GET_DATAFILETYPE_FOR_EXTERNAL_ID" type="HQL">
    <sql>
      SELECT dft
      FROM DataFileTypeData dft
      WHERE dft.externalId = :externalId
    </sql>
    <description>
      A Hibernate query that loads a data file type by external ID.
    </description>
  </query>

  <query id="GET_FILESETMEMBERS_FOR_DATAFILETYPE" type="HQL">
    <sql>
      SELECT {1}
      FROM FileSetMemberData mbr
      WHERE mbr.dataFileType = :dataFileType
    </sql>
    <description>
      A Hibernate query that gets file set members of a specific 
      data file type.
    </description>
  </query>

  <query id="GET_PLATFORMFILETYPE_FOR_DATAFILETYPE" type="HQL">
    <sql>
      SELECT {1}
      FROM PlatformFileTypeData pft
      WHERE pft.dataFileType = :dataFileType
    </sql>
    <description>
      A Hibernate query that gets platform file types of a specific 
      data file type.
    </description>
  </query>
  
  <query id="GET_ITEMSUBTYPES_FOR_DATAFILETYPE" type="HQL">
    <sql>
      SELECT {1}
      FROM ItemSubtypeFileTypeData sft
      WHERE sft.dataFileType = :dataFileType
    </sql>
    <description>
      A Hibernate query that gets item subtype file types for a specific 
      data file type.
    </description>
  </query>
  
  
  <query id="GET_FILESETMEMBER_FOR_DATAFILETYPE" type="HQL">
    <sql>
      SELECT mbr
      FROM FileSetMemberData mbr
      WHERE mbr.dataFileType.externalId = :externalId
      AND mbr.fileSet = :fileSet
    </sql>
    <description>
      A Hibernate query that loads a member in a given file set
      if we know the external ID of the data file type.
    </description>
  </query>

  
  <query id="UPDATE_JOB_STATUS" type="HQL">
    <sql>
      UPDATE JobData job
      SET 
        job.percentComplete = :percent,
        job.statusMessage = :statusMessage
      WHERE job.id = :id
    </sql>
    <description>
      A HQL query that updates the progress information on a specific job.
    </description>
  </query>
  
  <query id="APPEND_JOB_STATUS" type="HQL">
    <sql>
      UPDATE JobData job
      SET 
        job.statusMessage = job.statusMessage || :statusMessage
      WHERE job.id = :id
    </sql>
    <description>
      A HQL query that appends a string to the status message on a specific job.
    </description>
  </query>

  <query id="LOAD_RAWBIOASSAY_JOBS_IN_EXPERIMENT" type="HQL">
    <sql>
      SELECT DISTINCT rba.job.id
      FROM RawBioAssayData rba
      WHERE rba.job.experiment = :experiment
    </sql>
    <description>
      A HQL query that loads the ID:s of all jobs that are part
      of a given experiment and also has been assigned to at 
      least one raw bioassay.
    </description>
  </query>
  
  <query id="LOAD_ARRAYDESIGN_JOBS_IN_EXPERIMENT" type="HQL">
    <sql>
      SELECT ad.job.id
      FROM ArrayDesignData ad
      WHERE ad.job.experiment = :experiment
    </sql>
    <description>
      A HQL query that loads the ID:s of all jobs that are part
      of a given experiment and also has been assigned to at 
      least one array design.
    </description>
  </query>

  <query id="UNLINK_JOBS_FROM_EXPERIMENT" type="HQL">
    <sql>
      UPDATE JobData job
      SET job.experiment = null
      WHERE job.id IN (:list)
    </sql>
    <description>
      A HQL query that set the experiment property to null for
      a given set of jobs.
    </description>
  </query>
  
  <query id="GET_UNIT_WITH_NAME_FOR_QUANTITY" type="HQL">
    <sql>
      SELECT unt
      FROM UnitData unt
      WHERE unt.quantity = :quantity
      AND unt.name = :name
    </sql>
    <description>
      A HQL query that finds the unit for a quantity 
      with a given name.
    </description>
  </query>

  <query id="GET_UNITS_FOR_QUANTITY" type="HQL">
    <sql>
      SELECT {1}
      FROM UnitData unt
      WHERE unt.quantity = :quantity
    </sql>
    <description>
      A Hibernate query that gets units
      for a given quantity.
    </description>
  </query>

  <query id="GET_ANNOTATIONTYPES_FOR_QUANTITY" type="HQL">
    <sql>
      SELECT {1}
      FROM AnnotationTypeData at
      WHERE at.quantity = :quantity
    </sql>
    <description>
      A Hibernate query that gets annotation types
      that are using a given quantity.
    </description>
  </query>
  
  <query id="GET_ANNOTATIONTYPES_FOR_UNIT" type="HQL">
    <sql>
      SELECT {1}
      FROM AnnotationTypeData at
      WHERE at.defaultUnit = :unit
    </sql>
    <description>
      A Hibernate query that gets annotation types
      that are using a given unit as default unit.
    </description>
  </query>
  
  <query id="GET_ANNOTATIONS_FOR_UNIT" type="HQL">
    <sql>
      SELECT {1}
      FROM AnnotationData a
      WHERE a.unit = :unit
    </sql>
    <description>
      A Hibernate query that gets annotations
      that are using a given unit.
    </description>
  </query>
  
  <query id="GET_UNIT_WITH_SYMBOL_FOR_QUANTITY" type="HQL">
    <sql>
      SELECT unt
      FROM UnitData unt
      JOIN unt.symbols smb
      WHERE unt.quantity = :quantity
      AND smb.symbol = :symbol
    </sql>
    <description>
      A HQL query that finds the unit for a quantity 
      with a given symbol.
    </description>
  </query>
  
  <query id="GET_UNIT_WITH_SYMBOL_FOR_UNIT" type="HQL">
    <sql>
      SELECT smb.unit
      FROM UnitSymbolData smb
      JOIN smb.quantity qnt
      JOIN qnt.units unt
      WHERE unt = :unit
      AND smb.symbol = :symbol
    </sql>
    <description>
      A HQL query that finds the unit with a given symbol
      that has the same quantity as another unit.
    </description>
  </query>
  
  <query id="SET_UNIT_TO_NULL_ON_PROPERTY_FILTERS" type="SQL">
    <sql>
      UPDATE [PropertyFilters]
      SET [unit_id] = null 
      WHERE [unit_id] = :unit
    </sql>
    <description>
      A SQL query that sets the unit to null for all properties
      with a given unit (about to be deleted).
    </description>
  </query>
  
  <query id="RECALCULATE_ANNOTATIONS_WITH_ANNOTATIONTYPE" type="SQL">
    <sql>
      UPDATE [{1}] 
      SET [value] = [value] * :factor + :offset
      WHERE [id] IN 
      (
        SELECT [value_id] 
        FROM [Annotations] 
        WHERE [annotationtype_id] = :annotationType
      )
    </sql>
    <description>
      A SQL query that recalculates the annotation values for
      a given annotation type.
    </description>
  </query>
  
  <query id="SET_UNIT_ON_ANNOTATIONS_WITH_ANNOTATIONTYPE" type="HQL">
    <sql>
      UPDATE AnnotationData a
      SET a.unit = :unit
      WHERE a.annotationType = :annotationType
    </sql>
    <description>
      A HQL query that changes the unit for all annotations with a given
      annotation type.
    </description>
  </query>
  
  <query id="RECALCULATE_ANNOTATIONS_FOR_UNIT" type="SQL">
    <sql>
      UPDATE [{1}] SET [value] = [value] * :factor + :offset
      WHERE [id] IN 
      (
        SELECT [a].[value_id]
        FROM [Annotations] [a]
        JOIN [AnnotationTypes] [at] ON [at].[id] = [a].[annotationtype_id]
        WHERE [at].[value_type] = :valueType
        AND 
        (
          (:case = 1 AND [a].[unit_id] = :unit AND [at].[default_unit_id] &lt;&gt; :unit)
          OR
          (:case = 2 AND [a].[unit_id] &lt;&gt; :unit AND [at].[default_unit_id] = :unit)
        )
      )
    </sql>
    <description>
      A SQL query that recalculates the annotation values for
      when reference factor and/or offset changes. The query must handle
      two cases where either the annotation type's default unit 
      or the annotation's unit matched. More info in doc for the
      Unit.changeReferenceFactorAndOffset() method.
    </description>
  </query>

  <query id="UPDATE_ITEMLIST_SIZE" type="SQL">
    <sql>
      UPDATE [ItemLists] 
      SET [size] = [size] + :delta
      WHERE [member_type] = :memberType 
      AND [id] = ANY(
        SELECT [list_id]
        FROM [ItemListMembers]
        WHERE [item_id] = :itemId
      )
    </sql>
    <description>
      An update query that changes the size for all item lists
      where a given item is a member. Mainly used to decrease
      the size when an item is deleted.
    </description>
  </query>
  
  <query id="DELETE_ITEMLIST_MEMBER" type="SQL">
    <sql>
      DELETE FROM [ItemListMembers]
      WHERE [item_id] = :itemId
      AND [list_id] = ANY(
        SELECT [id]
        FROM [ItemLists]
        WHERE [member_type] = :memberType
      )
    </sql>
    <description>
      An update query that delete the list member entries
      for all lists where the given item is a member.
    </description>
  </query>
  
  <query id="GET_BIOMATERIAL_ON_PLATE" type="HQL">
    <sql>
      SELECT {1}
      FROM MeasuredBioMaterialData mbm
      JOIN mbm.bioWell bw
      WHERE bw.bioPlate = :bioPlate
    </sql>
    <description>
      A HQL query that gets MeasuredBioMaterial:s 
      located on a given bioplate.
    </description>
  </query>
  <query id="FIND_USED_TYPES_IN_ANYTOANY" type="SQL">
    <sql>
      SELECT [a].[from_type] FROM [AnyToAny] [a]
      UNION 
      SELECT [a].[to_type] FROM [AnyToAny] [a]
    </sql>
    <description>
      An SQL query that selects all used item types in any-to-any
      links. It must select both the the 'from' and 'to' item type.
    </description>
  </query>
  <query id="SELECT_STRAY_ANYTOANY" type="SQL">
    <sql>
      SELECT [a].[id]
      FROM [AnyToAny] [a] 
      LEFT JOIN [{1}] [t] 
        ON ([t].[id] = [a].[from_id] AND [a].[from_type] = :type)
        OR ([t].[id] = [a].[to_id] AND [a].[to_type] = :type) 
      WHERE [t].[id] IS NULL 
      AND ([a].[from_type] = :type OR [a].[to_type] = :type)
    </sql>
    <description>
      An SQL query that selects the ID of all any-to-any links were
      either the 'from' or 'to' item is missing. A single query
      is used to delete all items of a specific type (both
      'from' and 'to).
    </description>
  </query>
  <query id="DELETE_STRAY_ANYTOANY" type="HQL">
    <sql>
      DELETE FROM AnyToAnyData
      WHERE id IN (:ids)
    </sql>
    <description>
      A HQL query that deletes all any-to-any links with the
      id's given in the list.
    </description>
  </query>
  <query id="FIND_USED_TYPES_IN_CHANGEHISTORY" type="HQL">
    <sql>
      SELECT DISTINCT ch.itemType FROM ChangeHistoryDetailData ch
    </sql>
    <description>
      An HQL query that selects all used item types in the change
      history table.
    </description>
  </query>
  <query id="DELETE_STRAY_CHANGEHISTORY" type="HQL">
    <sql>
      DELETE FROM ChangeHistoryDetailData
      WHERE id IN (:ids)
    </sql>
    <description>
      A HQL query that deletes all change history entries with the
      id's given in the list.
    </description>
  </query>
  <query id="SELECT_STRAY_CHANGEHISTORY" type="SQL">
    <sql>
      SELECT [ch].[id]
      FROM [ChangeHistoryDetails] [ch] 
      LEFT JOIN [{1}] [t] 
        ON ([t].[id] = [ch].[item_id] AND [ch].[item_type] = :type)
      WHERE [t].[id] IS NULL 
      AND [ch].[item_type] = :type
    </sql>
    <description>
      An SQL query that selects the ID of all change history entries 
      that references a missing item of a specified type.
    </description>
  </query>
  <query id="DBLOG_GET_ANNOTATIONTYPE_INFO" type="HQL">
    <sql>
      SELECT at.name, at.valueType, at.disableLogOfValues
      FROM AnnotationTypeData at
      WHERE at.id = :annotationTypeId
    </sql>
    <description>
      An HQL query that loads the 'name', 'valueType' and 'disableLogOfValues' flag
      for an annotation type given the ID.
    </description>
  </query>
  <query id="DBLOG_GET_ANNOTATION_ITEMTYPE" type="HQL">
    <sql>
      SELECT a.itemType 
      FROM AnnotationSetData a 
      WHERE a.id = :annotationSetId
    </sql>
    <description>
      An HQL query that loads the item type value an annotation
      set with a given ID belongs to.
    </description>
  </query>
  <query id="DBLOG_GET_ITEMID_WITH_ANNOTATION" type="HQL">
    <sql>
      SELECT i.id 
      FROM {1} i 
      WHERE i.annotationSet = :annotationSetId
    </sql>
    <description>
      An HQL query that loads the ID of the item that
      is associated with a given annotation set.
    </description>
  </query>
  <query id="DBLOG_GET_NAME_FOR_ITEM" type="HQL">
    <sql>
      SELECT i.name
      FROM {1} i
      WHERE i.id = :id
    </sql>
    <description>
      An HQL query that loads the name of a an item.
    </description>
  </query>
  <query id="DBLOG_GET_FILESET_ITEMTYPE" type="HQL">
    <sql>
      SELECT fs.itemType 
      FROM FileSetData fs 
      WHERE fs.id = :fileSetId
    </sql>
    <description>
      An HQL query that loads the item type value a file set
      set with a given ID belongs to.
    </description>
  </query>
  <query id="DBLOG_GET_ITEMID_WITH_FILESET" type="HQL">
    <sql>
      SELECT i.id 
      FROM {1} i 
      WHERE i.fileSet = :fileSetId
    </sql>
    <description>
      An HQL query that loads the ID of the item that
      is associated with a given file set.
    </description>
  </query>
  <query id="DBLOG_INSERT_INTO_CHANGEHISTORYDETAILS" type="SQL">
    <sql>
      INSERT INTO [ChangeHistoryDetails] 
        ([id], [version], [history_id], [change_type], [item_id], [item_type], [change_info], [old_value], [new_value]) 
      VALUES (nextval('hibernate_sequence'), 0, ?, ?, ?, ?, ?, ?, ?)
    </sql>
    <description>
      SQL query for inserting rows into the ChangeHistoryDetails table.
      The primary key (id) must be auto-generated.
      Parameters: history_id, change_type, item_id, item_type, change_info, old_value, new_value
    </description>
  </query>
  <query id="GET_GROUPS_WITH_NONHIDDENMEMBERS" type="HQL">
    <sql>
      SELECT grp.id 
      FROM GroupData grp
      WHERE grp.hiddenMembers = false
      AND grp.id IN (:groups)
    </sql>
    <description>
      A HQL query that selects the ID of the groups among a given set of
      groups that has 'hiddenMembers=false'
    </description>
  </query>
  <query id="GET_BIOPLATES_FOR_BIOPLATETYPE" type="HQL">
    <sql>
      SELECT {1}
      FROM BioPlateData bpl
      WHERE bpl.bioPlateType = :bioPlateType
    </sql>
    <description>
      A HQL query that gets the bioplates using a given type.
    </description>
  </query>
  
  <query id="GET_BIOPLATETYPE_WITH_NAME" type="HQL">
    <sql>
      SELECT bpt
      FROM BioPlateTypeData bpt
      WHERE bpt.name = :name
    </sql>
    <description>
      A HQL query that gets the bioplate type with a given name.
    </description>
  </query>
  <query id="GET_PROJECTS_FOR_PERMISSION_TEMPLATE" type="HQL">
    <sql>
      SELECT {1}
      FROM ProjectData prj
      WHERE prj.permissionTemplate = :permissionTemplate
    </sql>
    <description>
      A HQL query that gets the projects that are using a given permission
      template.
    </description>
  </query>

  <query id="SET_GROUP_TO_NULL_ON_DISK_USAGE" type="HQL">
    <sql>
      UPDATE DiskUsageData du
        SET du.group = null
        WHERE du.group = :group
    </sql>
    <description>
      An HQL update-query that sets group to null on all 
      diskusage that are associated with a given group.
    </description>
  </query>

  <query id="CLEAR_ORIGINAL_BIOMATERIAL_ON_BIOWELLS" type="HQL">
    <sql>
      UPDATE BioWellData bw
      SET bw.originalBioMaterial = null
      WHERE bw.originalBioMaterial = :bioMaterial
    </sql>
    <description>
      An HQL update-query that for a given biomaterial clears the 
      link on all biowells were it is set as the original biomaterial.
    </description>
  </query>

  <query id="CLEAR_PARTICIPANT_ON_BIOMATERIALEVENTS_FOR_BIOPLATEEVENT" type="HQL">
    <sql>
      UPDATE BioMaterialEventData bme
      SET bme.bioPlateEventParticipant = null
      WHERE bme.bioPlateEventParticipant =ANY (
        SELECT bep FROM BioPlateEventParticipantData bep
        WHERE bep.event = :event
      )
    </sql>
    <description>
      An HQL update-query that clears the references to a given
      bioplate event on all biomaterial events that links to it
      (via the bioplate event participant table).
    </description>
  </query>

  <query id="CLEAR_PARTICIPANT_ON_BIOMATERIALEVENTS_FOR_BIOPLATE" type="HQL">
    <sql>
      UPDATE BioMaterialEventData bme
      SET bme.bioPlateEventParticipant = null
      WHERE bme.bioPlateEventParticipant =ANY (
        SELECT bep FROM BioPlateEventParticipantData bep
        WHERE bep.bioPlate = :bioPlate
      )
    </sql>
    <description>
      An HQL update-query that clears the references to all bioplate
      event participants on biomaterial events for a given bioplate.
    </description>
  </query>

  <query id="CLEAR_PARTICIPANT_ON_BIOMATERIALEVENTS_FOR_PARTICIPANT" type="HQL">
    <sql>
      UPDATE BioMaterialEventData bme
      SET bme.bioPlateEventParticipant = null
      WHERE bme.bioPlateEventParticipant = :participant
    </sql>
    <description>
      An HQL update-query that clears the references to a given bioplate 
      event participant on all related biomaterial events.
    </description>
  </query>

  <query id="GET_BIOPLATEEVENTS_FOR_BIOPLATEEVENTTYPE" type="HQL">
    <sql>
      SELECT {1}
      FROM BioPlateEventData bpe
      WHERE bpe.eventType = :eventType
    </sql>
    <description>
      An HQL update-query that gets the bioplate events that are
      of a given bioplate event type.
    </description>
  </query>
  
  <query id="GET_JAR_PATH_FROM_TABLE" type="SQL">
    <sql>
      SELECT [id], [jar_path] FROM [{1}] [t] 
      where [t].[jar_file] IS NULL AND NOT [t].[jar_path] IS NULL
    </sql>
    <description>
      An SQL query that selects the ID and JAR_PATH column from a given table
      where the existing JAR_PATH has a value and the existing JAR_FILE is
      null.
    </description>
  </query>

  <query id="SET_JAR_FILE_IN_TABLE" type="SQL">
    <sql>
      UPDATE [{1}] SET [jar_file] = :file WHERE id = :id
    </sql>
    <description>
      An SQL query that updates the JAR_FILE with the given value.
    </description>
  </query>
  
  <query id="DROP_COLUMN" type="SQL">
    <sql>
      ALTER TABLE [{1}] DROP COLUMN [{2}]
    </sql>
    <description>
      An SQL query that drops a column (2) from a table (1).
    </description>
  </query>
  
  <query id="DROP_NOT_NULL_CONSTRAINT" type="SQL">
    <sql>
      ALTER TABLE [{1}] ALTER COLUMN [{2}] DROP NOT NULL
    </sql>
    <description>
      An SQL query that drops a NOT NULL contraint from column (2) in a table (1).
    </description>
  </query>

  <query id="DROP_TABLE" type="SQL">
    <sql>
      DROP TABLE [{1}]
    </sql>
    <description>
      An SQL query that drops a table (1).
    </description>
  </query>

  <query id="CONVERT_LABELEDEXTRACTS_TO_EXTRACTS" type="SQL">
    <sql>
      UPDATE [BioMaterials]
      SET [discriminator] = 3
      WHERE [discriminator] = 4
    </sql>
    <description>
      An SQL query that convert labeled extract to extract.
    </description>
  </query>

  <query id="GET_HYBRIDIZATIONS" type="SQL">
    <sql>
      SELECT 
        [id], [version], 
        [arrayslide_id], [num_arrays], 
        [annotationset_id], [name], 
        [description], [removed], 
        [itemkey_id], [projectkey_id], 
        [owner]
      FROM 
        [Hybridizations]
    </sql>
    <description>
      An SQL query that load all BASE 2.17 hybridizations.
    </description>
  </query>

  <query id="UPDATE_BIOASSAYID_FROM_HYBID" type="SQL">
    <sql>
      UPDATE [BioMaterialEvents]
      SET [physicalbioassay_id] = :bioAssayId
      WHERE [hybridization_id] = :hybId
    </sql>
    <description>
      An SQL query that sets the physicalbioassay_id
      for a given hybridization_id
    </description>
  </query>

  <query id="GET_SCANS" type="SQL">
    <sql>
      SELECT 
        [id], [version], 
        [entry_date], [hybridization_id], 
        [hardware_id], [protocol_id], 
        [annotationset_id], [name], 
        [description], [removed], 
        [itemkey_id], [projectkey_id], 
        [owner]
      FROM 
        [Scans]
    </sql>
    <description>
      An SQL query that load all BASE 2.17 scans.
    </description>
  </query>

  <query id="GET_IMAGES" type="SQL">
    <sql>
      SELECT 
        [id], [version], 
        [file_id]
      FROM 
        [Images]
      WHERE [scan_id] = :scanId
    </sql>
    <description>
      An SQL query that load BASE 2.17 image files for a given scan.
    </description>
  </query>

  <query id="GET_PROTOCOLTYPES" type="SQL">
    <sql>
      SELECT 
        [id], [version], 
        [entry_date], [name], 
        [description], [removed], 
        [system_id]
      FROM 
        [ProtocolTypes]
    </sql>
    <description>
      An SQL query that load all BASE 2.17 protocol types.
    </description>
  </query>

  <query id="GET_HARDWARETYPES" type="SQL">
    <sql>
      SELECT 
        [id], [version], 
        [entry_date], [name], 
        [description], [removed], 
        [system_id]
      FROM 
        [HardwareTypes]
    </sql>
    <description>
      An SQL query that load all BASE 2.17 hardware types.
    </description>
  </query>
  
  <query id="GET_SOFTWARETYPES" type="SQL">
    <sql>
      SELECT 
        [id], [version], 
        [entry_date], [name], 
        [description], [system_id]
      FROM 
        [SoftwareTypes]
    </sql>
    <description>
      An SQL query that load all BASE 2.17 software types.
    </description>
  </query>

  <query id="GET_FILETYPES" type="SQL">
    <sql>
      SELECT 
        [id], [version], 
        [entry_date], [name], 
        [description], [system_id]
      FROM 
        [FileTypes]
    </sql>
    <description>
      An SQL query that load all BASE 2.17 file types.
    </description>
  </query>

  <query id="GET_RAWBIOASSAYS" type="SQL">
    <sql>
      SELECT
        [id], [scan_id],
        [array_num]
      FROM [RawBioAssays]
      WHERE NOT [scan_id] IS NULL
    </sql>
    <description>
      An SQL query that load scan and array num for all raw bioassays
      that has a scan parent.
    </description>
  </query>

  <query id="FIND_EXTRACT_FOR_RAWBIOASSAY_POSITION" type="SQL">
    <sql>
      SELECT bm2.[biomaterial_id]
      FROM [DerivedBioAssays] dba
      INNER JOIN [ParentPhysicalBioAssays] pba ON pba.[derivedbioassay_id] = dba.[id]
      INNER JOIN [BioMaterialEvents] bme ON bme.[physicalbioassay_id] = pba.[physicalbioassay_id]
      INNER JOIN [BioMaterialEventSources2] bm2 ON bm2.[event_id]=bme.[id]
      WHERE bm2.[position] = :position AND dba.[id] = :derivedBioAssayId
    </sql>
    <description>
      An SQL query that tries to find the extract id given a
      derived bioassay and the bioassay position.
    </description>
  </query>
  
  <query id="UPDATE_RAWBIOASSAY" type="SQL">
    <sql>
      UPDATE [RawBioAssays]
      SET [bioassay_id] = :parentBioAssayId, 
      [extract_id] = :extractId
      WHERE [id] = :rawBioAssayId
    </sql>
    <description>
      An SQL query that update the parent bioassay and extract
      for a given raw bioassay.
    </description>
  </query>


  <query id="COPY_BIOMATERIALEVENTSOURCES" type="SQL">
    <sql>
      INSERT INTO [BioMaterialEventSources2]
      (
        [id], [version], 
        [biomaterial_id], [event_id],
        [used_quantity], [position]
      )
      SELECT 
        {1}, 0, 
        [biomaterial_id], [event_id], 
        [used_quantity], [dummy]
      FROM [BioMaterialEventSources]
    </sql>
    <description>
      An SQL query that load copy BASE 2.17 biomaterial
      event sources to the new table.
    </description>
  </query>

  <query id="COPY_SAMPLE_BIOSOURCE_PARENT_LINK" type="SQL">
    <sql>
      INSERT INTO [BioMaterialEventSources2]
      (
        [id], [version], 
        [biomaterial_id], [event_id],
        [used_quantity], [position]
      )
      SELECT 
        {1}, 0, 
        bm.[parent_id], evt.[id], 
        null, 1
      FROM [BioMaterials] bm
      INNER JOIN [BioMaterialEvents] evt ON bm.[id]=evt.[biomaterial_id] AND evt.[event_type]=1
      WHERE bm.[discriminator] = 2 AND NOT bm.[parent_id] IS NULL
    </sql>
    <description>
      An SQL query that copy Sample--BioSource parent
      links to the BioMaterialEventSources2 table.
    </description>
  </query>

  <query id="NULLIFY_ALL_BIOMATERIAL_PARENTS" type="SQL">
    <sql>
      UPDATE [BioMaterials]
      SET [parent_type] = NULL, [parent_id] = NULL
    </sql>
    <description>
      An SQL query that nullify all biomaterial parent
      information.
    </description>
  </query>

  <query id="GET_BIOMATERIAL_PARENT_INFO" type="SQL">
    <sql>
      SELECT bm.[id], bm.[discriminator], evt.[biomaterial_id]
      FROM [BioMaterialEventSources2] bm2
      INNER JOIN [BioMaterialEvents] evt ON bm2.[event_id]=evt.[id] AND evt.[event_type]=1
      INNER JOIN [BioMaterials] bm ON bm2.[biomaterial_id]=bm.[id]
      ORDER BY evt.[biomaterial_id]
    </sql>
    <description>
      An SQL query that get parent biomaterial information. We need
      parent_id, parent_type and child_id ordered by child_id
    </description>
  </query>


  <query id="SET_BIOMATERIAL_PARENT" type="SQL">
    <sql>
      UPDATE [BioMaterials]
      SET [parent_type] = :parentType, [parent_id] = :parentId
      WHERE [id] = :childId
    </sql>
    <description>
      An SQL query that set the biomaterial parent info for a single
      biomaterial.
    </description>
  </query>

  <query id="SET_LABELEDEXTRACT_SUBTYPE" type="SQL">
    <sql>
      UPDATE [BioMaterials] 
      SET [subtype_id]=:subtype 
      WHERE [label_id] IS NOT NULL
    </sql>
    <description>
      An SQL query that sets the subtype of labeled extracts
    </description>
  </query>

  <query id="SET_SUBTYPE_ON_ALL" type="SQL">
    <sql>
      UPDATE [{1}] 
      SET [subtype_id]=:subtype
    </sql>
    <description>
      An SQL query that sets the subtype 
      of all items in a table
    </description>
  </query>

  <query id="UPDATE_ANNOTATIONSET_ITEM" type="SQL">
    <sql>
      UPDATE [AnnotationSets]
      SET [item_id] = :newId, [item_type] = {1}
      WHERE [id] = :id
    </sql>
    <description>
      An SQL query that update the item_type and item_id
      on annotation set.
    </description>
  </query>

  <query id="UPDATE_ANYTOANY_FROMITEM" type="SQL">
    <sql>
      UPDATE [AnyToAny]
      SET [from_id] = :newId, [from_type] = {2}
      WHERE [from_id] = :oldId AND [from_type] = {1}
    </sql>
    <description>
      An SQL query that update the from_type and from_id
      on any-to-any.
    </description>
  </query>
  
  <query id="UPDATE_ANYTOANY_TOITEM" type="SQL">
    <sql>
      UPDATE [AnyToAny]
      SET [to_id] = :newId, [to_type] = {2}
      WHERE [to_id] = :oldId AND [to_type] = {1}
    </sql>
    <description>
      An SQL query that update the to_type and to_id
      on any-to-any.
    </description>
  </query>
  
  <query id="UPDATE_CHANGEHISTORYDETAILS_ITEM" type="SQL">
    <sql>
      UPDATE [ChangeHistoryDetails]
      SET [item_id] = :newId, [item_type] = {2}
      WHERE [item_id] = :oldId AND [item_type] = {1}
    </sql>
    <description>
      An SQL query that update the item_type and item_id
      on change history details.
    </description>
  </query>
  
  <query id="UPDATE_ITEMVALUES_ITEM" type="SQL">
    <sql>
      UPDATE [ItemValues]
      SET [data_class_id] = :newId, [data_class] = :newClass
      WHERE [data_class_id] = :oldId AND [data_class] = :oldClass
    </sql>
    <description>
      An SQL query that update the data_class_id and data_class
      on item values.
    </description>
  </query>

  <query id="UPDATE_ITEMVALUES_CLASS" type="SQL">
    <sql>
      UPDATE [ItemValues]
      SET [data_class] = :newClass
      WHERE [data_class] = :oldClass
    </sql>
    <description>
      An SQL query that update the data_class
      on item values.
    </description>
  </query>

  <query id="UPDATE_ITEMTYPE" type="SQL">
    <sql>
      UPDATE [{1}]
      SET [{2}] = {4}
      WHERE [{2}] = {3}
    </sql>
    <description>
      An SQL query that update the item-type column on
      a generic table.
    </description>
  </query>

  <query id="UPDATE_SUBTYPEID_FROM_OLDTYPEID" type="SQL">
    <sql>
      UPDATE [{1}]
      SET [{2}] = :subtypeId
      WHERE [{3}] = :oldTypeId
    </sql>
    <description>
      An SQL query that update the subtype_id column on
      a generic table.
    </description>
  </query>


  <query id="DELETE_PLUGINGUICONTEXTS_FOR_ITEMTYPE" type="SQL">
    <sql>
      DELETE FROM [PluginDefinitionGuiContexts] 
      WHERE [item_type] = :itemType
    </sql>
    <description>
      An SQL query that delete plug-in gui contexts for
      a given item type.
    </description>
  </query>

  <query id="DELETE_PLUGINKEYS_FOR_ITEMTYPE" type="SQL">
    <sql>
      DELETE FROM [PluginKeys] 
      WHERE [key_id] IN (
        SELECT k.[id]
        FROM [Keys] k
        WHERE k.[item_type] = :itemType
      )
    </sql>
    <description>
      An SQL query that delete plug-in keys referencing keys
      for a given item type.
    </description>
  </query>


  <query id="GET_SUBTYPABLE_ITEMS_FOR_SUBTYPE_OF_CLASS" type="HQL">
    <sql>
      SELECT {1}
      FROM {2} sub
      WHERE sub.itemSubtype = :subtype
    </sql>
    <description>
      Get all items that are subtyped with a subtype for a given class.
    </description>
  </query>
  
  <query id="GET_ITEMLISTS_FOR_SUBTYPE" type="HQL">
    <sql>
      SELECT {1}
      FROM ItemListData il
      WHERE il.itemSubtype = :subtype
    </sql>
    <description>
      A Hibernate query that gets ITEMLISTS for a given item subtype.
    </description>
  </query>
  
  <query id="GET_MIMETYPES_FOR_FILETYPE" type="HQL">
    <sql>
      SELECT {1}
      FROM MimeTypeData mt
      WHERE mt.fileType = :subtype
    </sql>
    <description>
      A Hibernate query that gets MIME types for a given item subtype.
    </description>
  </query>
  
  <query id="GET_DATAFILETYPES_FOR_FILETYPE" type="HQL">
    <sql>
      SELECT {1}
      FROM DataFileTypeData dft
      WHERE dft.genericType = :subtype
    </sql>
    <description>
      A Hibernate query that gets Data file types for a given item subtype.
    </description>
  </query>
  
  <query id="UPDATE_FILESETMEMBER_FILETYPE" type="HQL">
    <sql>
      UPDATE FileSetMemberData mbr
      SET mbr.dataFileType = :newType
      WHERE mbr.dataFileType = :oldType
    </sql>
    <description>
      A Hibernate query that update the data file type of all
      file set members with a given old data file type.
    </description>
  </query>
  
  <query id="DISABLE_ALL_PLUGINS" type="HQL">
    <sql>
      UPDATE PluginDefinitionData pl
      SET pl.disabled = true
    </sql>
    <description>
      A Hibernate query that disable all plug-ins.
    </description>
  </query>
  
  <query id="GET_PROJECT_DEFAULT_ANYTOANY" type="HQL">
    <sql>
      SELECT a FROM AnyToAnyData a
      WHERE a.fromType = 24 AND a.name LIKE 'default_%'
    </sql>
    <description>
      A Hibernate query that load all any-to-any links containing
      project default items.
    </description>
  </query>
  
  <query id="GET_MD5_PASSWORDS" type="SQL">
    <sql>
      SELECT [id], [md5password] FROM [Passwords]
    </sql>
    <description>
      An SQL query that load all md5 passwords.
    </description>
  </query>

  <query id="SET_ENCRYPTED_PASSWORD" type="SQL">
    <sql>
      UPDATE [Passwords] 
      SET [crypted_password] = :cryptedPassword 
      WHERE [id] = :id
    </sql>
    <description>
      An SQL query that set the encrypted password for a given entry.
    </description>
  </query>
  
  <query id="GET_VIRTUALDBS_FOR_REPORTERCLONETEMPLATE" type="HQL">
    <sql>
      SELECT {1}
      FROM VirtualDbData vdb
      WHERE vdb.reporterCloneTemplate = :reporterCloneTemplate
    </sql>
    <description>
      A Hibernate query that get virtual databases
      that are using a given reporter clone template.
    </description>
  </query>

  <query id="GET_ALL_ANNOTATIONTYPE_IDS_FOR_USER" type="SQL">
    <sql>
      SELECT [at].[id]
      FROM [AnnotationTypes] [at]
      WHERE [at].[owner] = :owner
      OR [at].[itemkey_id] IN (:itemKeys)
      OR [at].[projectkey_id] IN (:projectKeys)
    </sql>
    <description>
      An SQL query that load the ID of all the annotation types
      that the current user has access to. We need to set owner,
      item keys and project keys as parameters.
    </description>
  </query>

  <query id="COPY_PARENT_PHYSICAL_BIOASSAYS" type="SQL">
    <sql>
      INSERT INTO [ParentPhysicalBioAssays] ([physicalbioassay_id], [derivedbioassay_id])
      SELECT [bioassay_id], [id] FROM [DerivedBioAssays]
    </sql>
    <description>
      An SQL query that copy the parent physical bioassays
      to the new (in BASE 3.2) ParentPhysicalBioAssays table
    </description>
  </query>


  <query id="COPY_PARENT_DERIVED_BIOASSAYS" type="SQL">
    <sql>
      INSERT INTO [ParentDerivedBioAssays] ([parentbioassay_id], [derivedbioassay_id])
      SELECT [parent_id], [id] FROM [DerivedBioAssays] WHERE NOT [parent_id] IS NULL
    </sql>
    <description>
      An SQL query that copy the parent derived bioassays
      to the new (in BASE 3.2) ParentDerivedBioAssays table
    </description>
  </query>

  <query id="SET_ISROOT_ON_DERIVED_BIOASSAYS" type="SQL">
    <sql>
      UPDATE [DerivedBioAssays] SET [is_root] = ([parent_id] IS NULL)
    </sql>
    <description>
      An SQL query that set the is_root property on DerivedBioAssays table.
    </description>
  </query>
  
  <query id="GET_ITEMSUBTYPE_WITH_NAME_AND_ITEMTYPE" type="HQL">
    <sql>
      SELECT st FROM ItemSubtypeData st
      WHERE st.name = :name AND st.itemType = :itemType
    </sql>
    <description>
      A Hibernate query that load an item subtype given the name
      and main item type.
    </description>
  </query>
  
  <query id="SET_DISABLE_LOG_FOR_ANNOTATION_TYPES" type="HQL">
    <sql>
      UPDATE AnnotationTypeData at
      SET at.disableLogOfValues = false
      WHERE at.disableLogOfValues IS NULL
    </sql>
    <description>
      An HQL query that set the disableLogOfValues=false for all annotation types
      with a null value.
    </description>
  </query>

  <query id="AB_LOAD_ANNOTATION_INFO" type="SQL">
    <sql>
      SELECT [annotationtype_id], [id], [version], [unit_id], [value_id], [last_update], [project_id], [override_id]
      FROM [Annotations] 
      WHERE [annotationset_id] = :annotationSet AND [source] = 0 AND ([project_id] = :defaultProject OR [project_id] = :activeProject)
    </sql>
    <description>
      SQL query for loading current (primary) annotations for 
      a given item.
      Used by the AnnotationBatcher as a SQL query via Hibernate.
    </description>
  </query>

  <query id="AB_LOAD_ANNOTATION_VALUES" type="SQL">
    <sql>
      SELECT [id], [value]
      FROM [{1}] 
      WHERE [id] IN (:listOfIds)
    </sql>
    <description>
      SQL query for loading current annotation values
      for a given list of annotation value IDs.
      Used by the AnnotationBatcher as a SQL query via Hibernate.
    </description>
  </query>

  <query id="AB_INSERT_INTO_PARAMETERVALUES" type="SQL">
    <sql>
      INSERT INTO [ParameterValues] ([id], [discriminator], [version]) 
      VALUES (nextval('hibernate_sequence'), ?, 0)
    </sql>
    <description>
      SQL query for inserting rows into the ParameterValues table.
      The primary key (id) must be auto-generated.
      Parameters: discriminator
    </description>
  </query>

  <query id="AB_INSERT_INTO_ANNOTATIONS" type="SQL">
    <sql>
      INSERT INTO [Annotations] ([id], [version], [annotationset_id], [annotationtype_id], [unit_id], [value_id], [last_update], [source], [project_id], [override_id]) 
      VALUES (nextval('hibernate_sequence'), 0, ?, ?, ?, ?, ?, 0, ?, ?)
    </sql>
    <description>
      SQL query for inserting rows into the Annotations table.
      The primary key (id) must be auto-generated.
      Parameters: annotationset_id, annotationtype_id, unit_id, value_id, last_updated, project_id, override_id
    </description>
  </query>

  <query id="AB_UPDATE_ANNOTATIONS" type="SQL">
    <sql>
      UPDATE [Annotations] 
      SET [version] = ?, [unit_id] = ?, [last_update] = ?
      WHERE [id] = ? AND [version] = ?
    </sql>
    <description>
      SQL query for updating rows into the Annotations table.
      Parameters: version (new), unit_id, last_updated, id, version (old)
    </description>
  </query>

  <query id="AB_INSERT_INTO_ANNOTATIONSETS" type="SQL">
    <sql>
      INSERT INTO [AnnotationSets] ([id], [version], [item_type], [item_id]) 
      VALUES (nextval('hibernate_sequence'), 0, {1}, ?)
    </sql>
    <description>
      SQL query for inserting rows into the AnnotationSets table.
      The primary key (id) must be auto-generated.
      Parameters: item_id
    </description>
  </query>
  
  <query id="AB_UPDATE_ITEMTABLE" type="SQL">
    <sql>
      UPDATE [{1}] 
      SET [annotationset_id] = ?
      WHERE [id] = ?
    </sql>
    <description>
      SQL query for updating the annotationset_id column in any
      table it exists in.
      Parameters: annotationset_id, item_id
    </description>
  </query>

  <query id="AB_NULLIFY_CLONED_ANNOTATIONS" type="SQL">
    <sql>
      UPDATE [Annotations] 
      SET [inherited_id] = null 
      WHERE [inherited_id] = ? and [source] = 2
    </sql>
    <description>
      SQL query for setting the 'inherited_id' column to null
      for cloned annotations that reference the annotation that
      is about to be deleted.
      Parameters: inherited_id
    </description>
  </query>

  <query id="AB_DELETE_INHERITED_ANNOTATIONS" type="SQL">
    <sql>
      DELETE FROM [Annotations] 
      WHERE [inherited_id] = ? and [source] = 1
    </sql>
    <description>
      SQL query for deleting inherited annotations that reference 
      the annotation that is about to be deleted.
      Parameters: inherited_id
    </description>
  </query>

  <query id="AB_DELETE_FROM_ANNOTATIONS" type="SQL">
    <sql>
      DELETE FROM [Annotations] 
      WHERE [id] = ?
    </sql>
    <description>
      SQL query for deleting an annotation with a given id.
      Used by the AnnotationBatcher as a PreparedStatement.
      Parameters: id
    </description>
  </query>

  <query id="AB_DELETE_FROM_PARAMETERVALUES" type="SQL">
    <sql>
      DELETE FROM [ParameterValues] WHERE [id] = ?
    </sql>
    <description>
      SQL query for deleting a parameter value with a given id.
      Used by the AnnotationBatcher as a PreparedStatement.
    </description>
  </query>

  <query id="AB_DELETE_FROM_VALUES" type="SQL">
    <sql>
      DELETE FROM [{1}] WHERE [id] = ?
    </sql>
    <description>
      SQL query for deleting all actual annotation values with a given id.
      The {1} parameter is the table the value are stored in, eg. StringValues,
      IntegerValues, FloatValues, etc.
      Used by the AnnotationBatcher as a PreparedStatement.
    </description>
  </query>
  
  <query id="AB_INSERT_INTO_VALUES" type="SQL">
    <sql>
      INSERT INTO [{1}] ([id], [value]) VALUES (?, ?)
    </sql>
    <description>
      SQL query for inserting annotation values in their respective 
      table (eg. StringValues, IntegerValues, FloatValues, etc.).
      Used by the AnnotationBatcher as a PreparedStatement.
    </description>
  </query>
  
  <query id="AB_UPDATE_OVERRIDE_ID" type="SQL">
    <sql>
      UPDATE [Annotations] 
      SET [override_id] = ?
      WHERE [annotationset_id] = ?
      AND [annotationtype_id] = ?
      AND [source] = 0 
      AND [project_id] &lt;&gt; 0
    </sql>
    <description>
      Updates the "override_id" column on project-specific annotations
      to point to a newly created default annotation of the same 
      annotation type (PRIMARY annotations only).
      Used by the AnnotationBatcher as a PreparedStatement.
      Parameters: override_id, annotationset_id, annotationtype_id
    </description>
  </query>
  
  
  <query id="PS_UPDATE_PROJECT_ANNOTATION_OVERRIDE_REF" type="SQL">
    <sql>
      UPDATE [Annotations] 
      SET [override_id] = :annotationId
      WHERE [annotationset_id] = :annotationSetId
      AND [annotationtype_id] = :annotationTypeId
      AND [source] = 0 
      AND [project_id] &lt;&gt; 0
    </sql>
    <description>
      Updates the "override_id" column on project-specific annotations
      to point to a newly created default annotation of the same 
      annotation type (PRIMARY annotations only).
    </description>
  </query>
  
  <query id="PS_FIND_OVERRIDE_ID_FOR_PROJECT_ANNOTATION" type="SQL">
    <sql>
      UPDATE [Annotations] 
      SET [override_id] = COALESCE(
        (SELECT [id] FROM [Annotations] 
        WHERE [annotationset_id] = :annotationSetId
        AND [annotationtype_id] = :annotationTypeId
        AND [source] = 0 AND [project_id] = 0)
        , 0)
      WHERE id = :annotationId
    </sql>
    <description>
      Updates the "override_id" column on a newly created project-specific 
      (PRIMARY) annotation to point to the existing default annotation id
      or 0 if no default annotation exists.
    </description>
  </query>
  
  <query id="PS_UPDATE_PROJECT_ANNOTATION_OVERRIDE_REF_INHERITED" type="HQL">
    <sql>
      UPDATE [Annotations] 
      SET [override_id] = :annotationId
      WHERE [annotationset_id] = :annotationSetId
      AND [inherited_id] IN (
        SELECT [id] FROM [Annotations]
        WHERE [annotationset_id] = :parentSetId
        AND [override_id] = :parentId
      )
    </sql>
    <description>
      Updates the "override_id" column on project-specific annotations
      to point to a newly created default annotation (INHERITED and 
      CLONED annotations). The subquery will find project-specific annotation
      on the parent annotation set that is overriding the inherited annotation.
    </description>
  </query>
  
  <query id="PS_FIND_OVERRIDE_ID_FOR_PROJECT_ANNOTATION_INHERITED" type="SQL">
    <sql>
      UPDATE [Annotations] 
      SET [override_id] = COALESCE(
        (SELECT [id] FROM [Annotations] 
        WHERE [annotationset_id] = :annotationSetId
        AND [inherited_id] = :parentOverrideId
        AND [source] &lt;&gt; 0 
        AND [project_id] = 0)
        , 0)
      WHERE id = :annotationId
    </sql>
    <description>
      Updates the "override_id" column on a newly created project-specific 
      (CLONED or INHERITED) annotation to point to the existing default 
      annotation id or 0 if no default annotation exists.
    </description>
  </query>
  
  <query id="PS_RESET_OVERRIDE_ON_PROJECT_ANNOTATIONS" type="HQL">
    <sql>
      UPDATE [Annotations]  
      SET [override_id] = 0
      WHERE [override_id] IN (:deletedAnnotations)
      OR [inherited_id] IN (
        SELECT [id] FROM [Annotations] 
        WHERE [override_id] IN (:deletedPrimaryAnnotations)
      )
    </sql>
    <description>
      Reset the "override_id" column on project-specific annotations
      that points to a default annotation that has been removed.
    </description>
  </query>
    
  <query id="PS_LOAD_ANNOTATIONS_IN_NON_EXISTING_PROJECTS" type="SQL">
    <sql>
      SELECT a.[id], a.[annotationset_id], a.[value_id], a.[project_id], at.[value_type] 
      FROM [Annotations] a
      INNER JOIN [AnnotationTypes] at ON at.[id] = a.[annotationtype_id]
      WHERE a.[project_id] &lt;&gt; 0 AND a.[project_id] NOT IN (SELECT [id] FROM [Projects])
    </sql>
    <description>
      SQL query for loading information about annotations
      that are project-specific annotations for a given
      list of projects.
      Used by the ProjectSpecificAnnotationsManager when
      a project has been deleted.
    </description>
  </query>
  
  <query id="PS_DELETE_FROM_PARAMETERVALUES" type="SQL">
    <sql>
      DELETE FROM [ParameterValues] WHERE [id] IN (:deletedValues)
    </sql>
    <description>
      SQL query for deleting mutliple parameter values with a given id's.
      Used by the ProjectSpecificAnnotationsManager.
    </description>
  </query>

  <query id="PS_DELETE_FROM_VALUES" type="SQL">
    <sql>
      DELETE FROM [{1}] WHERE [id] IN (:deletedValues)
    </sql>
    <description>
      SQL query for deleting all actual annotation values with given id's.
      The {1} parameter is the table the value are stored in, eg. StringValues,
      IntegerValues, FloatValues, etc.
      Used by the ProjectSpecificAnnotationsManager.
    </description>
  </query>
  
  <query id="PS_DELETE_FROM_ANNOTATIONS_IN_PROJECTS" type="SQL">
    <sql>
      DELETE FROM [Annotations] WHERE [project_id] IN (:deletedProjects)
    </sql>
    <description>
      SQL query for deleting all annotation entries referenceing
      given list of projects.
      Used by the ProjectSpecificAnnotationsManager.
    </description>
  </query>
  
  <query id="PS_FIND_PROJECT_SPECIFIC_ANNOTATION" type="HQL">
    <sql>
      SELECT ad FROM AnnotationData ad
      WHERE ad.projectId = :activeProject
      AND ad.overrideId = :defaultAnnotation
      AND ad.annotationSet = :annotationSet
    </sql>
    <description>
      HQL query for locating a project-specific annotation
      overriding a specified default annotation.
      Used by the ProjectSpecificAnnotationsManager.
    </description>
  </query>
  
  <query id="COUNT_PROJECT_ANNOTATIONS_FOR_ANNOTATIONTYPE" type="HQL">
    <sql>
      SELECT count(*)
      FROM AnnotationData ad
      WHERE ad.annotationType = :annotationType 
      AND ad.projectId &lt;&gt; 0
    </sql>
    <description>
      HQL query that counts the number of project-specific annotations
      for an annotation type.
    </description>
  </query>
  
  <query id="GET_USER_DEVICE" type="HQL">
    <sql>
      SELECT dev
      FROM UserDeviceData dev
      WHERE dev.user = :userId
      AND dev.client = :clientId
      AND dev.token = :token
    </sql>
    <description>
      HQL query that selects a device for a given user and client
      with a given device token.
    </description>
  </query>

</predefined-queries>