Пример #1
0
  public DatabaseExporter(ConnectionHelper connectionHelper, SqlExceptionHelper sqlExceptionHelper)
      throws SQLException {
    this.connectionHelper = connectionHelper;
    this.sqlExceptionHelper = sqlExceptionHelper;

    connectionHelper.prepare(false); // CUSTOM: changed auto-commit flag to false
    connection = connectionHelper.getConnection();
    statement = connection.createStatement();
  }
Пример #2
0
  public void connect(String fileName, String tableName) throws DAOException {

    try {
      c = ConnectionHelper.getConnection(fileName);
      Statement s = c.createStatement();

      s.execute(
          "CREATE TABLE IF NOT EXISTS "
              + tableName
              + " ("
              + "   id INTEGER, "
              + "   numProcessed INTEGER, "
              + "   totalToProcess INTEGER, "
              + "   startUp INTEGER, "
              + "   runTime INTEGER, "
              + "   shutDown INTEGER "
              + ")");

      s.execute("DELETE FROM " + tableName);

    } catch (SQLException e) {
      e.printStackTrace();
      throw new DAOException(e);
    }
  }
Пример #3
0
  private void execute(
      boolean script, boolean export, Writer fileOutput, Statement statement, final String sql)
      throws IOException, SQLException {
    final SqlExceptionHelper sqlExceptionHelper = new SqlExceptionHelper();

    String formatted = formatter.format(sql);
    if (delimiter != null) formatted += delimiter;
    if (script) System.out.println(formatted);
    LOG.debug(formatted);
    if (outputFile != null) {
      fileOutput.write(formatted + "\n");
    }
    if (export) {

      statement.executeUpdate(sql);
      try {
        SQLWarning warnings = statement.getWarnings();
        if (warnings != null) {
          sqlExceptionHelper.logAndClearWarnings(connectionHelper.getConnection());
        }
      } catch (SQLException sqle) {
        LOG.unableToLogSqlWarnings(sqle);
      }
    }
  }
Пример #4
0
 @Override
 public void release() throws Exception {
   try {
     statement.close();
   } finally {
     connectionHelper.release();
   }
 }
Пример #5
0
 /**
  * To check whether an active connection exists to a given broker.
  *
  * @param brokerURI The URI of the broker to check for the connection.
  * @return true is the client is connected to the given broker; false otherwise.
  * @throws ClientException If the given URI is malformatted.
  * @see NodeAddress , {@link #connect(String)}
  */
 public boolean connectionIsActive(String brokerURI) throws ClientException {
   try {
     NodeAddress brokerAddr = ConnectionHelper.getAddress(brokerURI);
     return brokerStates.containsKey(brokerAddr);
   } catch (CommunicationException e) {
     throw new ClientException(e.getMessage(), e);
   }
 }
Пример #6
0
 /**
  * Provided a broker URI, this method returns the associated broker state. The broker state
  * contains the details about the broker connection as well as, depending on the configuration,
  * the adv/sub messages sent to the specified broker.
  *
  * @param brokerURI
  * @return
  * @throws ClientException If the given broker URI is mal-formatted
  */
 public BrokerState getBrokerState(String brokerURI) throws ClientException {
   try {
     NodeAddress brokerAddress = ConnectionHelper.getAddress(brokerURI);
     return brokerStates.get(brokerAddress);
   } catch (CommunicationException e) {
     throw new ClientException("Could not get broker status: " + e.getMessage(), e);
   }
 }
Пример #7
0
 /**
  * DOC tguiu Comment method "doGetTableNames".
  *
  * @param connection
  * @return
  */
 private static List<String> doGetTableNames(Connection connection) {
   List<String> result = new ArrayList<String>(15);
   for (MetadataTable table : ConnectionHelper.getTables(connection)) {
     if (table == null) {
       continue;
     }
     result.add(table.getLabel());
   }
   return result;
 }
Пример #8
0
  /**
   * return the first connection available that refers to this table by moving up to the last
   * Package instance that hold this table and finding the connection linked to it
   *
   * @param metadataTable
   * @return
   */
  public static Connection getFirstConnection(MetadataTable metadataTable) {
    assert metadataTable != null;
    Connection connection = null;
    Namespace namespace = metadataTable.getNamespace();
    // for the file connection
    if (namespace != null && namespace instanceof RecordFile) {
      return ConnectionHelper.getConnection((RecordFile) namespace);
    }

    // for the mdm connection
    if (namespace != null && namespace instanceof TdXmlSchema) {
      return ConnectionHelper.getConnection((Package) namespace);
    }

    if (namespace != null) {
      Package thePackage = SwitchHelpers.PACKAGE_SWITCH.doSwitch(namespace);
      if (thePackage != null) {
        connection = getFirstPackageConnection(thePackage);
      }
    } // else class is not linked to any package
    return connection;
  }
Пример #9
0
  public InventoryRecord readItem() throws Exception {

    Connection connection = null;
    PreparedStatement statement = null;
    ResultSet rs = null;

    try {
      connection = ConnectionHelper.getConnection(dataSource);

      statement = connection.prepareStatement(ConnectionHelper.SELECT_INVENTORY);
      statement.setInt(1, 1);
      rs = statement.executeQuery();

      int quantity = -1;
      while (rs.next()) {
        quantity = rs.getInt("quantity");
      }

      // If we run out of items we are done so stop processing orders
      if (quantity < 1) {
        return null;
      }

      // decrement the quantity and update the table

      InventoryRecord ir = new InventoryRecord(1, --quantity);
      decrementInventory(connection, ir);

      readerIndex++;
      this.inventoryCheckpoint.setInventoryCount(readerIndex);

      return new InventoryRecord(1, 1); // Every order only orders 1 item
    } catch (SQLException e) {
      throw e;
    } finally {
      ConnectionHelper.cleanupConnection(connection, rs, statement);
    }
  }
Пример #10
0
  public static String search(String name, String year, String season) {
    Connection c = ConnectionHelper.connect();
    String result = "";
    try {
      if (!name.equals("")) name = "name='" + name + "'";
      else name = "name LIKE '%'";
      if (!year.equals("")) year = "year='" + year + "'";
      else year = "year LIKE '%'";
      if (!season.equals("")) season = "season='" + season + "'";
      else season = "season LIKE '%'";
      String sql_query =
          "SELECT * " + "FROM archives " + "WHERE " + name + " AND " + year + " AND " + season;
      PreparedStatement stmt = c.prepareStatement(sql_query);
      ResultSet rs = stmt.executeQuery();
      while (rs.next()) {
        result = result + rs.getString("filename") + ";";
      }
    } catch (Exception e) {
      result = "database error";
    }

    ConnectionHelper.close(c);
    return result;
  }
Пример #11
0
 /**
  * DOC tguiu Comment method "findByLabel".
  *
  * @deprecated it would be better to use find with some unique identifier
  * @param connection
  * @param label
  * @return
  */
 @Deprecated
 public static MetadataTable findByLabel(Connection connection, String label) {
   if (connection == null) {
     throw new IllegalArgumentException("null connection"); // $NON-NLS-1$
   }
   if (label == null || "".equals(label)) {
     throw new IllegalArgumentException("null/empty label"); // $NON-NLS-1$
   }
   Set<MetadataTable> tables = ConnectionHelper.getTables(connection);
   for (MetadataTable table : tables) {
     if (label.equals(table.getLabel())) {
       return table;
     }
   }
   return null;
 }
Пример #12
0
 @Override
 public void init() throws DBException {
   Properties props = getProperties();
   String servers = props.getProperty("voltdb.servers", "localhost");
   String user = props.getProperty("voltdb.user", "");
   String password = props.getProperty("voltdb.password", "");
   String strLimit = props.getProperty("voltdb.ratelimit");
   int ratelimit = strLimit != null ? Integer.parseInt(strLimit) : Integer.MAX_VALUE;
   try {
     m_client =
         ConnectionHelper.createConnection(
             Thread.currentThread().getId(), servers, user, password, ratelimit);
   } catch (Exception e) {
     e.printStackTrace();
     throw new DBException(e.getMessage());
   }
   m_workingData = new byte[1024 * 1024];
   m_writeBuf = ByteBuffer.wrap(m_workingData);
 }
Пример #13
0
  /**
   * Connects to a broker with the given URI. The given URI should conform to an accepted
   * communication protocol format.
   *
   * @param brokerURI URI of the broker to connect to.
   * @return A BrokerState data structure to keep track of the state of the connection and related
   *     operation
   * @throws ClientException In case the given URI is malformated, a connection already exists to
   *     the specified broker, or a communication error is occurred.
   * @see BrokerState, NodeAddress
   */
  public BrokerState connect(String brokerURI) throws ClientException {
    try {
      NodeAddress brokerAddr = ConnectionHelper.getAddress(brokerURI);
      if (brokerStates.containsKey(brokerAddr)) {
        throw new ClientException("Server connection already exists");
      } else {
        if (brokerStates.size() == 0) setDefaultBrokerAddress(brokerAddr);
        MessageSender msgSender = commSystem.getMessageSender(brokerURI);
        BrokerState bState = addBrokerState(brokerAddr, msgSender);

        msgSender.connect(
            MessageDestination.formatClientDestination(clientID, brokerAddr.getNodeURI()),
            msgListener);
        return bState;
      }
    } catch (CommunicationException e) {
      exceptionLogger.error("Could not connect to broker: " + e);
      throw new ClientException("Could not connect to broker: " + e.getMessage(), e);
    }
  }
Пример #14
0
 @Override
 public void cleanup() throws DBException {
   ConnectionHelper.disconnect(Thread.currentThread().getId());
 }