import com.orientechnologies.orient.client.remote.OServerAdmin; //导入依赖的package包/类
static void createDatabase(final OServerAdmin serverAdmin, final String database) {
    final Logger log = Logger.getLogger(OrientDBUtils.class.getName());
    try {
        if (!databaseExists(serverAdmin, database)) {
            serverAdmin.createDatabase(database, "document", "plocal");
            log.logp(INFO, OrientDBUtils.class.getName(), "createDatabase", String.format("created db : %s", database));
            serverAdmin.listDatabases().entrySet().forEach(entry -> log.info(String.format("%s -> %s", entry.getKey(), entry.getValue())));
        } else {
            log.logp(INFO, OrientDBUtils.class.getName(), "createDatabase", String.format("db already exists: %s", database));
        }
    } catch (final IOException e) {
        throw new RuntimeException(e);
    } finally {
        if (serverAdmin != null) {
            serverAdmin.close();
        }
    }
}
 

import com.orientechnologies.orient.client.remote.OServerAdmin; //导入依赖的package包/类
@Override
public OServerAdmin getServerAdmin() {
    final String ipAddress = config.getNetworkConfig().listeners.stream()
            .filter(l -> l.protocol.equals(NETWORK_BINARY_PROTOCOL))
            .findFirst()
            .map(l -> l.ipAddress.equals("0.0.0.0") ? JvmProcess.HOST : l.ipAddress)
            .orElse(JvmProcess.HOST);

    try {
        final OServerAdmin serverAdmin = new OServerAdmin(String.format("remote:%s", ipAddress));
        final OServerUserConfiguration userConfig = server.getUser(ROOT_USER);
        serverAdmin.connect(userConfig.name, userConfig.password);
        return serverAdmin;
    } catch (final IOException ex) {
        throw new ApplicationException(ex);
    }
}
 

import com.orientechnologies.orient.client.remote.OServerAdmin; //导入依赖的package包/类
private static void initDatabase() {
    Optional<OrientDBService> orientDBService = TypeSafeObjectRegistry.GLOBAL_OBJECT_REGISTRY.get(OrientDBService.ORIENTDB_SERVICE);
    while (!orientDBService.isPresent()) {
        log.log(Level.WARNING, "Waiting for OrientDBService ...");
        sleep(Duration.ofSeconds(2));
        orientDBService = TypeSafeObjectRegistry.GLOBAL_OBJECT_REGISTRY.get(OrientDBService.ORIENTDB_SERVICE);
    }

    final OServerAdmin admin = orientDBService.get().getServerAdmin();
    try {
        OrientDBUtils.createDatabase(admin, EventLogRepository.DB);
    } catch (final Exception e) {
        e.printStackTrace();
    } finally {
        admin.close();
    }

    EventLogRepository.initDatabase(orientDBService.get().getODatabaseDocumentTxSupplier(EventLogRepository.DB).get().get());
}
 

import com.orientechnologies.orient.client.remote.OServerAdmin; //导入依赖的package包/类
private static void initDatabase() {
    final OServerAdmin admin = service.getServerAdmin();
    try {
        OrientDBUtils.createDatabase(admin, CLASS_NAME);
    } finally {
        admin.close();
    }

    final Optional<ODatabaseDocumentTxSupplier> dbSupplier = service.getODatabaseDocumentTxSupplier(CLASS_NAME);
    assertThat(dbSupplier.isPresent(), is(true));

    try (final ODatabase db = dbSupplier.get().get()) {
        final OClass timestampedClass = db.getMetadata().getSchema().createAbstractClass(Timestamped.class.getSimpleName());
        timestampedClass.createProperty(Timestamped.Field.created_on.name(), OType.DATETIME);
        timestampedClass.createProperty(Timestamped.Field.updated_on.name(), OType.DATETIME);

        final OClass logRecordClass = db.getMetadata().getSchema().createClass(EventLogRecord.class.getSimpleName()).setSuperClasses(ImmutableList.of(timestampedClass));
        logRecordClass.createProperty(EventLogRecord.Field.event.name(), OType.STRING);
    }
}
 

import com.orientechnologies.orient.client.remote.OServerAdmin; //导入依赖的package包/类
private static void initDatabase() {
    final OServerAdmin admin = service.getServerAdmin();
    try {
        OrientDBUtils.createDatabase(admin, CLASS_NAME);
    } finally {
        admin.close();
    }
    try (final ODatabase db = service.getODatabaseDocumentTxSupplier(CLASS_NAME).get().get()) {
        final OClass timestampedClass = db.getMetadata().getSchema().createAbstractClass(Timestamped.class.getSimpleName());
        timestampedClass.createProperty(Timestamped.Field.created_on.name(), OType.DATETIME);
        timestampedClass.createProperty(Timestamped.Field.updated_on.name(), OType.DATETIME);

        final OClass logRecordClass = db.getMetadata().getSchema().createClass(EventLogRecord.class.getSimpleName()).setSuperClasses(ImmutableList.of(timestampedClass));
        logRecordClass.createProperty(EventLogRecord.Field.event.name(), OType.STRING);
    }
}
 

import com.orientechnologies.orient.client.remote.OServerAdmin; //导入依赖的package包/类
@Override
public OrientConnection connect() throws IOException {
    final OServerAdmin oServerAdmin = new OServerAdmin(url.toString());

    oServerAdmin.connect(userName, password);
    try {
        if (oServerAdmin.existsDatabase())
            oServerAdmin.dropDatabase("plocal");

        oServerAdmin.createDatabase(url.getDbName(), "graph", "plocal");
    } finally {
        oServerAdmin.close();
    }

    final OrientGraphFactory graphFactory = new OrientGraphFactory(url.toString(), userName, password);
    graphFactory.setAutoStartTx(false);
    graphFactory.declareIntent(new OIntentMassiveInsert().setEnableCache(false));

    return new AbstractOrientConnection(graphFactory.getNoTx()) {
        @Override
        public void close() throws Exception {
            graph.commit();
            graph.getRawGraph().close();
        }
    };
}
 

import com.orientechnologies.orient.client.remote.OServerAdmin; //导入依赖的package包/类
private void initObjectDatabaseTx(String database)
{
    //        OPartitionedDatabasePoolFactory poolFactory = new OPartitionedDatabasePoolFactory(30);
    //        OPartitionedDatabasePool pool = poolFactory.get(dbUrl,  "admin", "admin");

    logger.info("db url : {}{}", dbUrl, database);

    if (dbUrl.startsWith("remote"))
    {
        OServerAdmin serverAdmin;

        try
        {
            serverAdmin = new OServerAdmin(dbUrl + database).connect("admin", "admin");
            if (!serverAdmin.existsDatabase())
            {
                serverAdmin.createDatabase(database, "object", "plocal");
            }
        }
        catch (IOException e)
        {
            logger.info(e);
        }
    }

    partitionedDatabasePool = new OPartitionedDatabasePool(dbUrl + database, "admin", "admin", 32, 10);
    partitionedDatabasePool.setAutoCreate(true);
}
 

import com.orientechnologies.orient.client.remote.OServerAdmin; //导入依赖的package包/类
private static void removeDatabaseIfExists(String dbName) throws IOException
{
	OServerAdmin admin;
	admin = new OServerAdmin("localhost/" + dbName).connect(
			Constants.DB_USERNAME, Constants.DB_PASSWORD);
	if (admin.existsDatabase())
	{
		admin.dropDatabase("plocal");
	}
}
 

import com.orientechnologies.orient.client.remote.OServerAdmin; //导入依赖的package包/类
private boolean doesDatabaseExist(String dbName)
{
	try
	{
		return new OServerAdmin("localhost/" + dbName).connect(
				Constants.DB_USERNAME, Constants.DB_PASSWORD).existsDatabase();

	} catch (IOException e)
	{
		throw new RuntimeException("Error determining whether database exists");
	}
}
 

import com.orientechnologies.orient.client.remote.OServerAdmin; //导入依赖的package包/类
static boolean databaseExists(final OServerAdmin serverAdmin, final String database) {
    try {
        return serverAdmin.listDatabases().containsKey(database);
    } catch (final IOException ex) {
        throw new RuntimeException(ex);
    }
}
 

import com.orientechnologies.orient.client.remote.OServerAdmin; //导入依赖的package包/类
@Override
public void run(String iURL, File parentfolder, IConsole c) throws Exception {
	this.dbURL = iURL;

	final OServerAdmin admin = getServerAdmin();
	if (!admin.existsDatabase(storageType)) {
		admin.createDatabase(DBTYPE_DOC, storageType);
	}
	admin.close();

	super.run(iURL, parentfolder, c);
}
 

import com.orientechnologies.orient.client.remote.OServerAdmin; //导入依赖的package包/类
@Override
public void delete() throws Exception {
	shutdown();

	final OServerAdmin admin = getServerAdmin();
	admin.dropDatabase(storageType);
	admin.close();
}
 

import com.orientechnologies.orient.client.remote.OServerAdmin; //导入依赖的package包/类
protected OServerAdmin getServerAdmin() throws Exception {
	OServerAdmin admin = new OServerAdmin(dbURL);

	// TODO: add options for dbUsername/pw (and a specific remote: URL)
	admin.connect(rootUsername, rootPassword);

	return admin;
}
 

import com.orientechnologies.orient.client.remote.OServerAdmin; //导入依赖的package包/类
/**
 * {@inheritDoc}
 * Initialize the OrientDB dataStore by {@link Properties} parameters.
 *
 * @param keyClass key class type for dataStore.
 * @param persistentClass persistent class type for dataStore.
 * @param properties OrientDB dataStore properties EG:- OrientDB client credentials.
 */
@Override
public void initialize(Class<K> keyClass, Class<T> persistentClass, Properties properties) {
  super.initialize(keyClass, persistentClass, properties);
  try {
    orientDbStoreParams = OrientDBStoreParameters.load(properties);
    ROOT_URL = "remote:".concat(orientDbStoreParams.getServerHost()).concat(":")
            .concat(orientDbStoreParams.getServerPort());
    ROOT_DATABASE_URL = ROOT_URL.concat("/").concat(orientDbStoreParams.getDatabaseName());
    remoteServerAdmin = new OServerAdmin(ROOT_URL).connect(orientDbStoreParams.getUserName(),
            orientDbStoreParams.getUserPassword());
    if (!remoteServerAdmin.existsDatabase(orientDbStoreParams.getDatabaseName(), "memory")) {
      remoteServerAdmin.createDatabase(orientDbStoreParams.getDatabaseName(), "document", "memory");
    }

    if (orientDbStoreParams.getConnectionPoolSize() != null) {
      int connPoolSize = Integer.valueOf(orientDbStoreParams.getConnectionPoolSize());
      connectionPool = new OPartitionedDatabasePoolFactory(connPoolSize)
              .get(ROOT_DATABASE_URL, orientDbStoreParams.getUserName(),
                      orientDbStoreParams.getUserPassword());
    } else {
      connectionPool = new OPartitionedDatabasePoolFactory().get(ROOT_DATABASE_URL,
              orientDbStoreParams.getUserName(), orientDbStoreParams.getUserPassword());
    }

    OrientDBMappingBuilder<K, T> builder = new OrientDBMappingBuilder<>(this);
    orientDBMapping = builder.fromFile(orientDbStoreParams.getMappingFile()).build();

    if (!schemaExists()) {
      createSchema();
    }
  } catch (Exception e) {
    LOG.error("Error while initializing OrientDB dataStore: {}",
            new Object[]{e.getMessage()});
    throw new RuntimeException(e);
  }
}
 

import com.orientechnologies.orient.client.remote.OServerAdmin; //导入依赖的package包/类
private boolean databaseExists(String dbName) throws IOException
{
	return new OServerAdmin("localhost/" + dbName).connect(
			Constants.DB_USERNAME, Constants.DB_PASSWORD).existsDatabase();
}
 

import com.orientechnologies.orient.client.remote.OServerAdmin; //导入依赖的package包/类
/**
 *
 * @return new instance is returned - it is the responsibility of the client to close the connection, i.e., via OServerAdmin.close(), when they are done
 * with it.
 */
OServerAdmin getServerAdmin();