void handleStatement(boolean addition, Long graphId, Long subj, Long prop, Long obj)
     throws AnzoException {
   URI graphNode = getValue(graphId);
   Resource subjNode = getValue(subj);
   URI propNode = getValue(prop);
   Value objNode = getValue(obj);
   URI ngURI = graphNode;
   boolean meta = false;
   if (UriGenerator.isMetadataGraphUri(ngURI)) {
     ngURI = UriGenerator.stripEncapsulatedURI(NAMESPACES.METADATAGRAPH_PREFIX, ngURI);
     meta = true;
   }
   NamedGraphRevision ngr = ngs.get(ngURI);
   if (ngr == null) {
     throw new AnzoException(
         ExceptionConstants.DATASOURCE.NAMEDGRAPH.REVISION_NOT_FOUND, "?", ngURI.toString());
   }
   if (meta
       && (!ngr.readMeta
           && !(ngr.readGraph && subjNode.equals(ngURI) && isSpecialMeta(propNode)))) {
     return;
   } else if (!meta && !ngr.readGraph) {
     return;
   }
   if (lastNGRevision == null || !lastNGRevision.namedGraphUri.equals(ngURI)) {
     handler.handleNamedGraph(ngr.namedGraphUri, ngr.uuid, ngr.revision);
     lastNGRevision = ngr;
     if (newGraph.get(ngURI) && lastNGRevision.cache == null) {
       lastNGRevision.cache = new ArrayList<Statement>();
     }
   }
   handler.handleStatement(meta, addition, subjNode, propNode, objNode, graphNode);
   if (addition && lastNGRevision.cache != null) {
     lastNGRevision.cache.add(
         Constants.valueFactory.createStatement(subjNode, propNode, objNode, graphNode));
   }
 }
  @Override
  protected void replicateInternal(
      IOperationContext context,
      Collection<NamedGraphRevision> newGraphs,
      Collection<NamedGraphRevision> diffGraphs,
      IReplicationHandler handler,
      ReplicationCache cache)
      throws AnzoException {
    NodeCentricOperationContext connectionContext = datasource.getQueryContext(context);
    long startAll = System.currentTimeMillis();
    int count = 0;
    try {
      Map<Long, NamedGraphRevision> idToGraphs = new HashMap<Long, NamedGraphRevision>();
      long revisionCount = diffGraphs.size();
      long norevisionCount = newGraphs.size();

      long start = System.currentTimeMillis();
      datasource.begin(connectionContext.getConnection(), false, false);
      try {
        StringBuilder sb = new StringBuilder("Replicating:");
        HashMap<URI, Boolean> newGraph = new HashMap<URI, Boolean>();
        for (NamedGraphRevision ngRevision : newGraphs) {
          newGraph.put(ngRevision.namedGraphUri, true);
          Long namedGraphId =
              connectionContext
                  .getNodeLayout()
                  .fetchId(ngRevision.namedGraphUri, connectionContext.getConnection());
          Long metadataId =
              connectionContext
                  .getNodeLayout()
                  .fetchId(ngRevision.metadataUri, connectionContext.getConnection());
          if (namedGraphId != null && metadataId != null) {
            idToGraphs.put(metadataId, ngRevision);
            idToGraphs.put(namedGraphId, ngRevision);

            long startInsertNamedGraphEntries = System.currentTimeMillis();
            long insertNamedGraphEntries =
                ReplicationRdbWrapper.insertNamedGraphNewRevisions(
                    connectionContext.getStatementProvider(),
                    connectionContext.getConnection(),
                    namedGraphId.toString(),
                    connectionContext.getConfiguration().getSessionPrefix(),
                    Long.toString(ngRevision.revision));
            if (log.isDebugEnabled()) {
              log.debug(
                  LogUtils.RDB_MARKER,
                  "[REPLICATE-INSERT_NAMEDGRAPH_ENTRIES] {}:{}",
                  insertNamedGraphEntries,
                  (System.currentTimeMillis() - startInsertNamedGraphEntries));
            }
            if (insertNamedGraphEntries == 0) {
              insertNamedGraphEntries =
                  ReplicationRdbWrapper.insertNamedGraphNRNewRevisions(
                      connectionContext.getStatementProvider(),
                      connectionContext.getConnection(),
                      namedGraphId.toString(),
                      connectionContext.getConfiguration().getSessionPrefix(),
                      Long.toString(ngRevision.revision));
              if (log.isDebugEnabled()) {
                log.debug(
                    LogUtils.RDB_MARKER,
                    "[REPLICATE-INSERT_NAMEDGRAPH_NR_ENTRIES] {}:{}",
                    insertNamedGraphEntries,
                    (System.currentTimeMillis() - startInsertNamedGraphEntries));
              }
            }
            sb.append(ngRevision.namedGraphUri + ",");
          }
        }
        for (NamedGraphRevision ngRevision : diffGraphs) {
          newGraph.put(ngRevision.namedGraphUri, false);
          Long namedGraphId =
              connectionContext
                  .getNodeLayout()
                  .fetchId(ngRevision.namedGraphUri, connectionContext.getConnection());
          Long metadataId =
              connectionContext
                  .getNodeLayout()
                  .fetchId(ngRevision.metadataUri, connectionContext.getConnection());
          if (namedGraphId != null && metadataId != null) {
            idToGraphs.put(metadataId, ngRevision);
            idToGraphs.put(namedGraphId, ngRevision);

            long startInsertNamedGraphEntries = System.currentTimeMillis();
            long insertNamedGraphEntries =
                ReplicationRdbWrapper.insertNamedGraphNewRevisions(
                    connectionContext.getStatementProvider(),
                    connectionContext.getConnection(),
                    namedGraphId.toString(),
                    connectionContext.getConfiguration().getSessionPrefix(),
                    Long.toString(ngRevision.revision));
            if (log.isDebugEnabled()) {
              log.debug(
                  LogUtils.RDB_MARKER,
                  "[REPLICATE-INSERT_NAMEDGRAPH_ENTRIES] {}:{}",
                  insertNamedGraphEntries,
                  (System.currentTimeMillis() - startInsertNamedGraphEntries));
            }
            if (insertNamedGraphEntries == 0) {
              insertNamedGraphEntries =
                  ReplicationRdbWrapper.insertNamedGraphNRNewRevisions(
                      connectionContext.getStatementProvider(),
                      connectionContext.getConnection(),
                      namedGraphId.toString(),
                      connectionContext.getConfiguration().getSessionPrefix(),
                      Long.toString(ngRevision.revision));
              if (log.isDebugEnabled()) {
                log.debug(
                    LogUtils.RDB_MARKER,
                    "[REPLICATE-INSERT_NAMEDGRAPH_NR_ENTRIES] {}:{}",
                    insertNamedGraphEntries,
                    (System.currentTimeMillis() - startInsertNamedGraphEntries));
              }
            }
            sb.append(ngRevision.namedGraphUri + ",");
          }
        }
        if (log.isDebugEnabled()) {
          log.debug(LogUtils.RDB_MARKER, "[REPLICATE-NAMEDGRAPHS] {}", sb.toString());
        }

        if (log.isDebugEnabled()) {
          log.debug(
              LogUtils.RDB_MARKER,
              "[REPLICATE-INSERT_REVISIONS] {}:{}",
              revisionCount + norevisionCount,
              (System.currentTimeMillis() - start));
        }

        long insertDeltaStatements = 0;
        long insertDeltaNRStatements = 0;
        if (revisionCount > 0) {
          long startInsertDeltaStatements = System.currentTimeMillis();
          insertDeltaStatements =
              ReplicationRdbWrapper.insertDeltaStatements(
                  connectionContext.getStatementProvider(),
                  connectionContext.getConnection(),
                  connectionContext.getConfiguration().getSessionPrefix());
          if (log.isDebugEnabled()) {
            log.debug(
                LogUtils.RDB_MARKER,
                "[REPLICATE-INSERT_DELTA_STATEMENTS] {}:{}",
                insertDeltaStatements,
                (System.currentTimeMillis() - startInsertDeltaStatements));
          }
          long startInsertDeltaNRStatements = System.currentTimeMillis();
          insertDeltaNRStatements =
              ReplicationRdbWrapper.insertDeltaNRStatements(
                  connectionContext.getStatementProvider(),
                  connectionContext.getConnection(),
                  connectionContext.getConfiguration().getSessionPrefix());
          if (log.isDebugEnabled()) {
            log.debug(
                LogUtils.RDB_MARKER,
                "[REPLICATE-INSERT_DELTA_NR_STATEMENTS] {}:{}",
                insertDeltaNRStatements,
                (System.currentTimeMillis() - startInsertDeltaNRStatements));
          }

          long startPurgeExtraStatements = System.currentTimeMillis();
          long purgeExtraStatements =
              ReplicationRdbWrapper.purgeExtraStatements(
                  connectionContext.getStatementProvider(),
                  connectionContext.getConnection(),
                  connectionContext.getConfiguration().getSessionPrefix());
          if (log.isDebugEnabled()) {
            log.debug(
                LogUtils.RDB_MARKER,
                "[REPLICATE-PURGE_EXTRA_STATEMENTS] {}:{}",
                purgeExtraStatements,
                (System.currentTimeMillis() - startPurgeExtraStatements));
          }
          insertDeltaStatements -= purgeExtraStatements;
        }
        if (insertDeltaStatements > 0 || insertDeltaNRStatements > 0 || norevisionCount > 0) {
          Deltas deltas = new Deltas(handler, connectionContext, newGraph, cache);
          count =
              processDeltaResults(
                  connectionContext,
                  deltas,
                  (insertDeltaStatements > 0 || insertDeltaNRStatements > 0),
                  (norevisionCount > 0),
                  idToGraphs);
          deltas.end();
        }
      } finally {
        // if (datasource.getConfiguration().getForceTempTablePurge()) {
        try {
          BaseSQL.truncateTableWithSessionMayCommit(
              datasource.getStatementProvider(),
              connectionContext.getConnection(),
              datasource.getConfiguration().getSessionPrefix(),
              "NGR_TMP");
          BaseSQL.truncateTableWithSessionMayCommit(
              datasource.getStatementProvider(),
              connectionContext.getConnection(),
              datasource.getConfiguration().getSessionPrefix(),
              "STMTS_REP_TMP");
        } catch (RdbException sqle) {
          log.error(LogUtils.RDB_MARKER, "Error clearing temporary tables", sqle);
        }
        // }
        datasource.commit(connectionContext.getConnection(), false, false);
      }

    } catch (SQLException sqle) {
      SQLException cause = sqle;
      while (cause != null) {
        log.error(LogUtils.RDB_MARKER, "SQL Error in replicate", cause);
        cause = cause.getNextException();
      }
      throw new AnzoException(
          ExceptionConstants.SERVER.REPLICATION_FAILED, sqle, sqle.getMessage());
    } finally {
      handler.end();
      if (log.isDebugEnabled()) {
        log.debug(
            LogUtils.RDB_MARKER,
            "[REPLICATE-TOTAL-TIME] {}:{}",
            count,
            (System.currentTimeMillis() - startAll));
      }
      if (connectionContext != null) {
        datasource.returnQueryContext(connectionContext);
      }
    }
  }
 protected void start(int totaSize) throws AnzoException {
   handler.start(totaSize);
 }