private List getListTracksTrend(String event) {
    List listTracksTrend = new ArrayList<Object[]>();

    String sql =
        "SELECT date_part('doy', timestamp) AS day, COUNT(timestamp)"
            + " FROM listtrack WHERE event='"
            + event
            + "'"
            + " GROUP BY date_part('doy', timestamp)";
    Connection connection = null;
    Calendar calendar = Calendar.getInstance();
    try {
      connection = ((ObjectStoreInterMineImpl) uos).getConnection();
      Statement stm = connection.createStatement();
      ResultSet rs = stm.executeQuery(sql);
      int dayOfYear;
      Object[] track;
      while (rs.next()) {
        track = new Object[2];
        dayOfYear = rs.getInt(1);
        calendar.set(Calendar.DAY_OF_YEAR, dayOfYear);
        track[0] = calendar.getTime();
        track[1] = rs.getInt(2);
        listTracksTrend.add(track);
      }
      ((ObjectStoreInterMineImpl) uos).releaseConnection(connection);
    } catch (SQLException sqle) {
      sqle.printStackTrace();
    }
    return listTracksTrend;
  }
 public List getTracksDataTable(String sqlQuery) {
   List<Object[]> trackTable = new ArrayList<Object[]>();
   Connection connection = null;
   try {
     connection = ((ObjectStoreInterMineImpl) uos).getConnection();
     Statement stm = connection.createStatement();
     ResultSet rs = stm.executeQuery(sqlQuery);
     Object[] track;
     while (rs.next()) {
       track = new Object[3];
       track[0] = rs.getString(1);
       track[1] = rs.getInt(2);
       track[2] = rs.getInt(3) + rs.getInt(4);
       trackTable.add(track);
     }
     ((ObjectStoreInterMineImpl) uos).releaseConnection(connection);
   } catch (SQLException sqle) {
     sqle.printStackTrace();
   }
   return trackTable;
 }
 /** {@inheritDoc} */
 @Override
 public void startElement(String uri, String localName, String qName, Attributes attrs)
     throws SAXException {
   if ("userprofiles".equals(qName)) {
     String value = attrs.getValue(MetadataManager.PROFILE_FORMAT_VERSION);
     if (value == null) {
       version = 0;
     } else {
       version = Integer.parseInt(value);
     }
     ObjectStoreWriter userprofileOsw = profileManager.getProfileObjectStoreWriter();
     Connection con = null;
     try {
       con = ((ObjectStoreInterMineImpl) userprofileOsw).getConnection();
       if (!DatabaseUtil.tableExists(con, "bagvalues")) {
         DatabaseUtil.createBagValuesTables(con);
       }
     } catch (SQLException sqle) {
       LOG.error("Problem retrieving connection", sqle);
     } finally {
       ((ObjectStoreInterMineImpl) userprofileOsw).releaseConnection(con);
     }
     sharedBagsByUsers = new HashedMap();
   }
   if ("userprofile".equals(qName)) {
     startTime = System.currentTimeMillis();
     profileHandler = new ProfileHandler(profileManager, osw, version, sharedBagsByUsers);
   }
   if (profileHandler != null) {
     profileHandler.startElement(uri, localName, qName, attrs);
   }
   if ("tracks".equals(qName)) {
     trackHandler = new TrackManagerHandler(profileManager.getProfileObjectStoreWriter());
   }
   if (trackHandler != null) {
     trackHandler.startElement(uri, localName, qName, attrs);
   }
 }
  /**
   * Return a Set of PrimaryKeys relevant to a given Source for a ClassDescriptor. The Set contains
   * all the primary keys that exist on a particular class that are used by the source, without
   * performing any recursion. The Model.getClassDescriptorsForClass() method is recommended if you
   * wish for all the primary keys of the class' parents as well.
   *
   * @param cld the ClassDescriptor
   * @param source the Source
   * @param os the ObjectStore that these PrimaryKeys are used in, for creating indexes
   * @return a Set of PrimaryKeys
   */
  public static Set<PrimaryKey> getPrimaryKeys(ClassDescriptor cld, Source source, ObjectStore os) {
    GetPrimaryKeyCacheKey key = new GetPrimaryKeyCacheKey(cld, source);
    synchronized (getPrimaryKeyCache) {
      Set<PrimaryKey> keySet = getPrimaryKeyCache.get(key);
      if (keySet == null) {
        keySet = new LinkedHashSet<PrimaryKey>();
        Properties keys = getKeyProperties(source);
        if (keys != null) {
          if (!verifiedSources.contains(source)) {
            String packageNameWithDot =
                cld.getName().substring(0, cld.getName().lastIndexOf('.') + 1);
            LOG.info(
                "Verifying primary key config for source "
                    + source
                    + ", packageName = "
                    + packageNameWithDot);
            for (Map.Entry<Object, Object> entry : keys.entrySet()) {
              String cldName = (String) entry.getKey();
              String keyList = (String) entry.getValue();
              if (!cldName.contains(".")) {
                ClassDescriptor iCld =
                    cld.getModel().getClassDescriptorByName(packageNameWithDot + cldName);
                if (iCld != null) {
                  Map<String, PrimaryKey> map = PrimaryKeyUtil.getPrimaryKeys(iCld);

                  String[] tokens = keyList.split(",");
                  for (int i = 0; i < tokens.length; i++) {
                    String token = tokens[i].trim();
                    if (map.get(token) == null) {
                      throw new IllegalArgumentException(
                          "Primary key "
                              + token
                              + " for class "
                              + cldName
                              + " required by datasource "
                              + source.getName()
                              + " in "
                              + source.getName()
                              + "_keys.properties is not defined in "
                              + cld.getModel().getName()
                              + "_keyDefs.properties");
                    }
                  }
                } else {
                  LOG.warn(
                      "Ignoring entry for "
                          + cldName
                          + " in file "
                          + cld.getModel().getName()
                          + "_keyDefs.properties - not in model!");
                }
              }
            }
            verifiedSources.add(source);
          }
          Map<String, PrimaryKey> map = PrimaryKeyUtil.getPrimaryKeys(cld);
          String cldName = TypeUtil.unqualifiedName(cld.getName());
          String keyList = (String) keys.get(cldName);
          if (keyList != null) {
            String[] tokens = keyList.split(",");
            for (int i = 0; i < tokens.length; i++) {
              String token = tokens[i].trim();
              if (map.get(token) == null) {
                throw new IllegalArgumentException(
                    "Primary key "
                        + token
                        + " for class "
                        + cld.getName()
                        + " required by data source "
                        + source.getName()
                        + " in "
                        + source.getName()
                        + "_keys.properties is not defined in "
                        + cld.getModel().getName()
                        + "_keyDefs.properties");
              } else {
                keySet.add(map.get(token));
              }
            }
          }
          for (Map.Entry<Object, Object> entry : keys.entrySet()) {
            String propKey = (String) entry.getKey();
            String fieldList = (String) entry.getValue();
            int posOfDot = propKey.indexOf('.');
            if (posOfDot > 0) {
              String propCldName = propKey.substring(0, posOfDot);
              if (cldName.equals(propCldName)) {
                String keyName = propKey.substring(posOfDot + 1);
                PrimaryKey pk = new PrimaryKey(keyName, fieldList, cld);
                if (!keySet.contains(pk)) {
                  keySet.add(pk);
                  if (os instanceof ObjectStoreInterMineImpl) {
                    ObjectStoreInterMineImpl osimi = (ObjectStoreInterMineImpl) os;
                    DatabaseSchema schema = osimi.getSchema();
                    ClassDescriptor tableMaster = schema.getTableMaster(cld);
                    String tableName = DatabaseUtil.getTableName(tableMaster);
                    List<String> fields = new ArrayList<String>();

                    for (String field : pk.getFieldNames()) {
                      String colName = DatabaseUtil.generateSqlCompatibleName(field);
                      if (tableMaster.getReferenceDescriptorByName(field, true) != null) {
                        colName += "id";
                      }
                      fields.add(colName);
                    }
                    String sql =
                        "CREATE INDEX "
                            + tableName
                            + "__"
                            + keyName
                            + " ON "
                            + tableName
                            + " ("
                            + StringUtil.join(fields, ", ")
                            + ")";
                    System.out.println("Creating index: " + sql);
                    LOG.info("Creating index: " + sql);
                    Connection conn = null;
                    try {
                      conn = osimi.getConnection();
                      conn.createStatement().execute(sql);
                    } catch (SQLException e) {
                      LOG.warn("Index creation failed", e);
                    } finally {
                      if (conn != null) {
                        osimi.releaseConnection(conn);
                      }
                    }
                  }
                }
              }
            }
          }
        } else {
          throw new IllegalArgumentException(
              "Unable to find keys for source "
                  + source.getName()
                  + " in file "
                  + source.getName()
                  + "_keys.properties");
        }
        getPrimaryKeyCache.put(key, keySet);
      }
      return keySet;
    }
  }