/**
  * Reset the database
  *
  * @param connectionContext NodeCentric specific context, which contains connection to run queries
  *     against
  * @param hardReset if true, all tables are dropped and not just truncated
  * @param statements statements to use to initialize database
  * @return ValuePair containing servers new URI and ID
  * @throws AnzoException
  */
 protected URI resetDatabase(
     NodeCentricOperationContext connectionContext,
     boolean hardReset,
     MultiMap<URI, Statement> statements)
     throws AnzoException {
   datasource.resetDatasource();
   Pair<Long, URI> serverURI = null;
   boolean[] result = lockDB(connectionContext);
   if (result[1]) {
     try {
       serverURI = resetDatabaseTables(connectionContext, hardReset);
       if (statements != null && statements.size() > 0) {
         resetGraph(statements, connectionContext, serverURI.second);
       } else {
         if (rdfInitFiles != null && rdfInitFiles.size() > 0) {
           initializeProvidedRoles(connectionContext, serverURI.second);
         } else {
           initializeDefaultRoles(connectionContext, serverURI.second);
         }
       }
       unLockDB(connectionContext, true, serverURI.first);
       return serverURI.second;
     } catch (AnzoException ae) {
       if (result[0]) {
         BaseSQL.dropTable(
             connectionContext.getStatementProvider(),
             connectionContext.getConnection(),
             connectionContext.getConfiguration().getUsesUppercase()
                 ? NodeCentricDatasource.serverUpper
                 : NodeCentricDatasource.serverLower);
       }
       throw ae;
     }
   } else {
     if (result[0]) {
       BaseSQL.dropTable(
           connectionContext.getStatementProvider(),
           connectionContext.getConnection(),
           connectionContext.getConfiguration().getUsesUppercase()
               ? NodeCentricDatasource.serverUpper
               : NodeCentricDatasource.serverLower);
     }
     throw new AnzoException(ExceptionConstants.RDB.FAILED_INITIALZE_DB);
   }
 }
  public void restoreData(String fileName) throws AnzoException {
    final NodeCentricOperationContext connectionContext =
        datasource.getWriteContext(
            new BaseOperationContext(
                "RESTORE",
                BaseOperationContext.generateOperationId(),
                new AnzoPrincipal("sysadmin", null, null, true, false)));
    if (getLockProvider() != null) {
      getLockProvider().writeLock().lock();
    }
    try {
      datasource.resetStarting();
      datasource.reset();
      if (eventAdmin != null)
        eventAdmin.sendEvent(
            new Event(OSGI.RESET_TOPIC, (Dictionary<Object, Object>) new Properties()));

      Pair<Long, URI> serverURI = null;

      datasource.resetDatasource();
      boolean[] result = lockDB(connectionContext);
      if (result[1]) {
        try {
          serverURI = resetDatabaseTables(connectionContext, hardReset);

          try {
            Reader fileReader = ReadWriteUtils.createSmartFileReader(fileName);
            XMLBackupReader reader = new XMLBackupReader(fileReader);
            try {
              reader.read(
                  new IBackupHandler() {
                    Long graphId;

                    Long metaId;

                    Long uuidId;

                    public void start() throws AnzoException {
                      datasource.begin(connectionContext.getConnection(), true, true);
                    }

                    public void handleStatement(
                        boolean metadata,
                        boolean revisioned,
                        Statement statement,
                        Long start,
                        Long end)
                        throws AnzoException {
                      Long s =
                          connectionContext
                              .getNodeLayout()
                              .store(statement.getSubject(), connectionContext.getConnection(), 1);
                      Long p =
                          connectionContext
                              .getNodeLayout()
                              .store(
                                  statement.getPredicate(), connectionContext.getConnection(), 1);
                      Long o =
                          connectionContext
                              .getNodeLayout()
                              .store(statement.getObject(), connectionContext.getConnection(), 1);
                      String stmtId =
                          MessageFormat.format(
                              ID_STRING,
                              (metadata) ? metaId.toString() : graphId.toString(),
                              s.toString(),
                              p.toString(),
                              o.toString());
                      if (revisioned) {
                        Backup.restoreStatement(
                            connectionContext.getStatementProvider(),
                            connectionContext.getConnection(),
                            stmtId,
                            metadata ? 1 : 0,
                            uuidId,
                            metadata ? metaId : graphId,
                            s,
                            p,
                            o,
                            start,
                            end);
                      } else {
                        Backup.restoreStatementNR(
                            connectionContext.getStatementProvider(),
                            connectionContext.getConnection(),
                            stmtId,
                            metadata ? 1 : 0,
                            metadata ? metaId : graphId,
                            s,
                            p,
                            o);
                      }
                    }

                    public boolean handleNamedGraph(
                        boolean revisioned,
                        URI namedGraphUri,
                        URI metadataURI,
                        URI uuid,
                        Collection<BackupRevision> revisions)
                        throws AnzoException {
                      try {
                        connectionContext.getConnection().commit();
                      } catch (SQLException sqle) {
                        throw new org.openanzo.jdbc.utils.RdbException(
                            org.openanzo.exceptions.ExceptionConstants.RDB
                                .FAILED_COMMIT_RDB_TRANSACTION,
                            sqle);
                      }
                      uuidId =
                          connectionContext
                              .getNodeLayout()
                              .store(uuid, connectionContext.getConnection(), 1);
                      graphId =
                          connectionContext
                              .getNodeLayout()
                              .store(namedGraphUri, connectionContext.getConnection(), 1);
                      metaId =
                          connectionContext
                              .getNodeLayout()
                              .store(metadataURI, connectionContext.getConnection(), 1);
                      for (BackupRevision backup : revisions) {
                        Long lastMod =
                            connectionContext
                                .getNodeLayout()
                                .store(backup.lastModifiedBy, connectionContext.getConnection(), 1);
                        if (revisioned) {
                          Backup.restoreNamedGraph(
                              connectionContext.getStatementProvider(),
                              connectionContext.getConnection(),
                              backup.start,
                              backup.end,
                              graphId,
                              metaId,
                              uuidId,
                              backup.revision,
                              lastMod);
                        } else {
                          Backup.restoreNamedGraphNR(
                              connectionContext.getStatementProvider(),
                              connectionContext.getConnection(),
                              backup.start,
                              graphId,
                              metaId,
                              uuidId,
                              backup.revision,
                              lastMod);
                        }
                      }
                      return true;
                    }

                    public void end() throws AnzoException {
                      datasource.commit(connectionContext.getConnection(), true, true);
                      connectionContext
                          .getNodeLayout()
                          .commitReferencedIds(connectionContext.getConnection(), 1);
                    }
                  });
            } catch (AnzoException ae) {
              datasource.abort(connectionContext.getConnection(), true, true);
            } finally {
              if (fileReader != null) {
                fileReader.close();
              }
            }
          } catch (Exception e) {
            log.error(LogUtils.RDB_MARKER, "Error resetting datasource", e);
          }
          datasource.getIndexHandler().rebuildIndex(true);
        } catch (AnzoException ae) {
          if (result[0]) {
            BaseSQL.dropTable(
                connectionContext.getStatementProvider(),
                connectionContext.getConnection(),
                connectionContext.getConfiguration().getUsesUppercase()
                    ? NodeCentricDatasource.serverUpper
                    : NodeCentricDatasource.serverLower);
          }
          throw ae;
        }
        unLockDB(connectionContext, true, serverURI.first);
        datasource.postReset();
        datasource.resetFinished();
      } else {
        if (result[0]) {
          BaseSQL.dropTable(
              connectionContext.getStatementProvider(),
              connectionContext.getConnection(),
              connectionContext.getConfiguration().getUsesUppercase()
                  ? NodeCentricDatasource.serverUpper
                  : NodeCentricDatasource.serverLower);
        }
        throw new AnzoException(ExceptionConstants.RDB.FAILED_INITIALZE_DB);
      }
    } finally {
      if (getLockProvider() != null) {
        getLockProvider().writeLock().unlock();
      }
      datasource.returnWriteContext(connectionContext);
    }
  }