Process predecessors.

@throws SQLException
484078
private void processPredecessors() throws SQLException
   {
      List<Row> rows = getRows("select * from link where projid=? order by linkid", m_projectID);
      List<Row> completedSections = getRows("select * from task_completed_section where projid=?", m_projectID);
      m_reader.processPredecessors(rows, completedSections);
   }
1326224
private void processPredecessors() throws SQLException
   {
      List<Row> rows = getTable("LINK");
      List<Row> completedSections = getTable("TASK_COMPLETED_SECTION");
      Collections.sort(rows, LINK_COMPARATOR);
      m_reader.processPredecessors(rows, completedSections);
   }
909380
private void processProjectProperties() throws SQLException
   {
      List<Row> rows = getTable("PROJECT_SUMMARY");
      if (rows.isEmpty() == false)
      {
         m_reader.processProjectProperties(rows.get(0));
      }
   }
67596
private void processProjectProperties() throws SQLException
   {
      List<Row> rows = getRows("select * from project_summary where projid=?", m_projectID);
      if (rows.isEmpty() == false)
      {
         m_reader.processProjectProperties(rows.get(0));
      }
   }
1335791
public int deleteAll() throws SQLException {

		DeleteBuilder<Extensions, Void> db = deleteBuilder();
		int deleted = db.delete();

		return deleted;
	}
37255
public void fetchRemaining() throws SQLException {
    if (!isEof) {
      lock.lock();
      try {
        lastRowPointer = -1;
        while (!isEof) {
          addStreamingValue();
        }

      } catch (SQLException queryException) {
        throw ExceptionMapper.getException(queryException, null, statement, false);
      } catch (IOException ioe) {
        throw handleIoException(ioe);
      } finally {
        lock.unlock();
      }
      dataFetchTime++;
    }
  }
885909
public void processPredecessors(List<Row> rows)
   {
      for (Row row : rows)
      {
         Integer currentID = mapTaskID(row.getInteger("task_id"));
         Integer predecessorID = mapTaskID(row.getInteger("pred_task_id"));
         Task currentTask = m_project.getTaskByUniqueID(currentID);
         Task predecessorTask = m_project.getTaskByUniqueID(predecessorID);
         RelationType type = RELATION_TYPE_MAP.get(row.getString("pred_type"));
         Duration lag = row.getDuration("lag_hr_cnt");
         if (currentTask != null)
         {
            Integer uniqueID = row.getInteger("task_pred_id");
            if (predecessorTask != null)
            {
               Relation relation = currentTask.addPredecessor(predecessorTask, type, lag);
               relation.setUniqueID(uniqueID);
               m_eventManager.fireRelationReadEvent(relation);
            }
            else
            {
               // if we can't find the predecessor, it must lie outside the project
               ExternalPredecessorRelation relation = new ExternalPredecessorRelation(predecessorID, currentTask, type, lag);
               m_externalPredecessors.add(relation);
               relation.setUniqueID(uniqueID);
            }
         }
      }
   }
995970
public void abort() throws SQLException {
    if (fetchSize != 0) {
      fetchSize = 0;
      if (resultSet != null) {
        resultSet.abort();
      } else {
        SelectResultSet firstResult = executionResults.peekFirst();
        if (firstResult != null) {
          firstResult.abort();
        }
      }
    }
  }
808909
private void doWrite(final LogEntry logEntry) throws SQLException {
		if (checkConnection()) {
			if (batch) {
				batchCount += 1;
			}

			try {
				for (int i = 0; i < tokens.size(); ++i) {
					tokens.get(i).apply(logEntry, statement, i + 1);
				}
			} catch (SQLException ex) {
				resetConnection();
				throw ex;
			}

			try {
				if (batch) {
					statement.addBatch();
					if (batchCount >= MAX_BATCH_SIZE) {
						statement.executeBatch();
						batchCount = 0;
					}
				} else {
					statement.executeUpdate();
				}
			} catch (SQLException ex) {
				resetConnection();
				throw ex;
			}
		} else {
			lostCount += 1;
		}
	}
855153
private void processAssignments() throws SQLException
   {
      List<Row> rows = getRows("select * from zscheduleitem where zproject=? and z_ent=? order by zorderinactivity", m_projectID, m_entityMap.get("Assignment"));
      for (Row row : rows)
      {
         Task task = m_project.getTaskByUniqueID(row.getInteger("ZACTIVITY_"));
         Resource resource = m_project.getResourceByUniqueID(row.getInteger("ZRESOURCE"));
         if (task != null && resource != null)
         {
            ResourceAssignment assignment = task.addResourceAssignment(resource);
            assignment.setGUID(row.getUUID("ZUNIQUEID"));
            assignment.setActualFinish(row.getTimestamp("ZGIVENACTUALENDDATE_"));
            assignment.setActualStart(row.getTimestamp("ZGIVENACTUALSTARTDATE_"));

            assignment.setWork(assignmentDuration(task, row.getWork("ZGIVENWORK_")));
            assignment.setOvertimeWork(assignmentDuration(task, row.getWork("ZGIVENWORKOVERTIME_")));
            assignment.setActualWork(assignmentDuration(task, row.getWork("ZGIVENACTUALWORK_")));
            assignment.setActualOvertimeWork(assignmentDuration(task, row.getWork("ZGIVENACTUALWORKOVERTIME_")));
            assignment.setRemainingWork(assignmentDuration(task, row.getWork("ZGIVENREMAININGWORK_")));

            assignment.setLevelingDelay(row.getDuration("ZLEVELINGDELAY_"));

            if (assignment.getRemainingWork() == null)
            {
               assignment.setRemainingWork(assignment.getWork());
            }

            if (resource.getType() == ResourceType.WORK)
            {
               assignment.setUnits(Double.valueOf(NumberHelper.getDouble(row.getDouble("ZRESOURCEUNITS_")) * 100.0));
            }
         }
      }
   }
1014023
private void processProjectProperties() throws SQLException
   {
      List<ResultSetRow> rows = getRows("SELECT * FROM MSP_PROJECTS WHERE PROJ_ID=?", m_projectID);
      if (rows.isEmpty() == false)
      {
         processProjectProperties(rows.get(0));
      }
   }
981667
public void setNextException(SQLException ex) {

        SQLException current = this;
        for(;;) {
            SQLException next=current.next;
            if (next != null) {
                current = next;
                continue;
            }

            if (nextUpdater.compareAndSet(current,null,ex)) {
                return;
            }
            current=current.next;
        }
    }
1014601
protected function processResults()
    {
        try {
            $this->log("Processing new result set.", Project::MSG_VERBOSE);

            $formatters = $this->getConfiguredFormatters();

            while ($row = $this->statement->fetch($this->fetchMode)) {
                foreach ($formatters as $formatter) {
                    $formatter->processRow($row);
                }
            }
        } catch (Exception $x) {
            $this->log("Error processing reults: " . $x->getMessage(), Project::MSG_ERR);
            foreach ($formatters as $formatter) {
                $formatter->close();
            }
            throw $x;
        }
    }
48818
public void clear() throws SQLException {
        clearStatements();
        statements.clear();
        parameterSets.clear();
        connections.clear();
        resultSets.clear();
        executeGroups.clear();
    }
1168141
private void processTasks() throws SQLException
   {
      List<Row> bars = getTable("BAR");
      List<Row> expandedTasks = getTable("EXPANDED_TASK");
      List<Row> tasks = getTable("TASK");
      List<Row> milestones = getTable("MILESTONE");

      m_reader.processTasks(bars, expandedTasks, tasks, milestones);
   }
933129
private void processRow(Subscriber<? super T> subscriber) throws SQLException {
        checkSubscription(subscriber);
        if (!keepGoing)
            return;
        if (rs.next()) {
            log.trace("onNext");
            subscriber.onNext(function.call(rs));
        } else
            keepGoing = false;
    }
107498
protected void incrementBatchCount() throws SQLException {
        batchCount++;
        if (batchCount == batchSize /* never true for batchSize of 0 */) {
            int[] result = delegate.executeBatch();
            processResult(result);
            batchCount = 0;
        }
    }