Java AlreadyExistsException类代码示例

import org.apache.cassandra.exceptions.AlreadyExistsException; //导入依赖的package包/类
private void maybeCreateKeyspace(RequiresKeyspace rk, RequiresColumnFamily rcf) {
  logger.debug("RequiresKeyspace annotation has keyspace name: {}", rk.ksName());
  List<CFMetaData> cfs = extractColumnFamily(rcf);
  try {
    MigrationManager
            .announceNewKeyspace(KSMetaData.newKeyspace(rk.ksName(),
                    rk.strategy(), KSMetaData.optsWithRF(rk.replication()), false, cfs));
  } catch (AlreadyExistsException aee) {
    logger.info("using existing Keyspace for " + rk.ksName());
    if ( cfs.size() > 0 ) {
      maybeTruncateSafely(rcf);
    }
  } catch (Exception ex) {
    throw new RuntimeException("Failure creating keyspace for " + rk.ksName(),ex);
  }
}
 

import org.apache.cassandra.exceptions.AlreadyExistsException; //导入依赖的package包/类
private void maybeCreateColumnFamily(RequiresColumnFamily rcf) {
  try {
    CFMetaData cfMetaData;
    if ( rcf.isCounter() ) {
      cfMetaData = new CFMetaData(rcf.ksName(), rcf.cfName(),
                    ColumnFamilyType.Standard, TypeParser.parse(rcf.comparator()), null)
              .replicateOnWrite(false).defaultValidator(CounterColumnType.instance);
    } else {
      cfMetaData = new CFMetaData(rcf.ksName(), rcf.cfName(),
                    ColumnFamilyType.Standard, TypeParser.parse(rcf.comparator()), null);
    }
    MigrationManager.announceNewColumnFamily(cfMetaData);
  } catch(AlreadyExistsException aee) {
    logger.info("CF already exists for " + rcf.cfName());
    maybeTruncateSafely(rcf);
  } catch (Exception ex) {
    throw new RuntimeException("Could not create CF for: " + rcf.cfName(), ex);
  }
}
 

import org.apache.cassandra.exceptions.AlreadyExistsException; //导入依赖的package包/类
public boolean announceMigration(boolean isLocalOnly) throws RequestValidationException
{
    try
    {
        MigrationManager.announceNewColumnFamily(getCFMetaData(), isLocalOnly);
        return true;
    }
    catch (AlreadyExistsException e)
    {
        if (ifNotExists)
            return false;
        throw e;
    }
}
 

import org.apache.cassandra.exceptions.AlreadyExistsException; //导入依赖的package包/类
public boolean announceMigration(boolean isLocalOnly) throws RequestValidationException
{
    try
    {
        MigrationManager.announceNewKeyspace(attrs.asKSMetadata(name), isLocalOnly);
        return true;
    }
    catch (AlreadyExistsException e)
    {
        if (ifNotExists)
            return false;
        throw e;
    }
}
 

import org.apache.cassandra.exceptions.AlreadyExistsException; //导入依赖的package包/类
public static void announceNewKeyspace(KSMetaData ksm, long timestamp, boolean announceLocally) throws ConfigurationException
{
    ksm.validate();

    if (Schema.instance.getKSMetaData(ksm.name) != null)
        throw new AlreadyExistsException(ksm.name);

    logger.info(String.format("Create new Keyspace: %s", ksm));
    announce(ksm.toSchema(timestamp), announceLocally);
}
 

import org.apache.cassandra.exceptions.AlreadyExistsException; //导入依赖的package包/类
public static void announceNewColumnFamily(CFMetaData cfm, boolean announceLocally) throws ConfigurationException
{
    cfm.validate();

    KSMetaData ksm = Schema.instance.getKSMetaData(cfm.ksName);
    if (ksm == null)
        throw new ConfigurationException(String.format("Cannot add column family '%s' to non existing keyspace '%s'.", cfm.cfName, cfm.ksName));
    else if (ksm.cfMetaData().containsKey(cfm.cfName))
        throw new AlreadyExistsException(cfm.ksName, cfm.cfName);

    logger.info(String.format("Create new ColumnFamily: %s", cfm));
    announce(addSerializedKeyspace(cfm.toSchema(FBUtilities.timestampMicros()), cfm.ksName), announceLocally);
}
 

import org.apache.cassandra.exceptions.AlreadyExistsException; //导入依赖的package包/类
public void announceMigration() throws RequestValidationException
{
    try
    {
       MigrationManager.announceNewColumnFamily(getCFMetaData());
    }
    catch (AlreadyExistsException e)
    {
        if (!ifNotExists)
            throw e;
    }
}
 

import org.apache.cassandra.exceptions.AlreadyExistsException; //导入依赖的package包/类
public void announceMigration() throws RequestValidationException
{
    try
    {
        MigrationManager.announceNewKeyspace(attrs.asKSMetadata(name));
    }
    catch (AlreadyExistsException e)
    {
        if (!ifNotExists)
            throw e;
    }
}
 

import org.apache.cassandra.exceptions.AlreadyExistsException; //导入依赖的package包/类
public static void announceNewKeyspace(KSMetaData ksm, long timestamp) throws ConfigurationException
{
    ksm.validate();

    if (Schema.instance.getKSMetaData(ksm.name) != null)
        throw new AlreadyExistsException(ksm.name);

    logger.info(String.format("Create new Keyspace: %s", ksm));
    announce(ksm.toSchema(timestamp));
}
 

import org.apache.cassandra.exceptions.AlreadyExistsException; //导入依赖的package包/类
public static void announceNewColumnFamily(CFMetaData cfm) throws ConfigurationException
{
    cfm.validate();

    KSMetaData ksm = Schema.instance.getKSMetaData(cfm.ksName);
    if (ksm == null)
        throw new ConfigurationException(String.format("Cannot add column family '%s' to non existing keyspace '%s'.", cfm.cfName, cfm.ksName));
    else if (ksm.cfMetaData().containsKey(cfm.cfName))
        throw new AlreadyExistsException(cfm.ksName, cfm.cfName);

    logger.info(String.format("Create new ColumnFamily: %s", cfm));
    announce(cfm.toSchema(FBUtilities.timestampMicros()));
}
 

import org.apache.cassandra.exceptions.AlreadyExistsException; //导入依赖的package包/类
public static void announceNewKeyspace(KeyspaceMetadata ksm, long timestamp, boolean announceLocally) throws ConfigurationException
{
    ksm.validate();

    if (Schema.instance.getKSMetaData(ksm.name) != null)
        throw new AlreadyExistsException(ksm.name);

    logger.info(String.format("Create new Keyspace: %s", ksm));
    announce(SchemaKeyspace.makeCreateKeyspaceMutation(ksm, timestamp), announceLocally);
}
 

import org.apache.cassandra.exceptions.AlreadyExistsException; //导入依赖的package包/类
private static void announceNewColumnFamily(CFMetaData cfm, boolean announceLocally, boolean throwOnDuplicate) throws ConfigurationException
{
    cfm.validate();

    KeyspaceMetadata ksm = Schema.instance.getKSMetaData(cfm.ksName);
    if (ksm == null)
        throw new ConfigurationException(String.format("Cannot add table '%s' to non existing keyspace '%s'.", cfm.cfName, cfm.ksName));
    // If we have a table or a view which has the same name, we can't add a new one
    else if (throwOnDuplicate && ksm.getTableOrViewNullable(cfm.cfName) != null)
        throw new AlreadyExistsException(cfm.ksName, cfm.cfName);

    logger.info(String.format("Create new table: %s", cfm));
    announce(SchemaKeyspace.makeCreateTableMutation(ksm, cfm, FBUtilities.timestampMicros()), announceLocally);
}
 

import org.apache.cassandra.exceptions.AlreadyExistsException; //导入依赖的package包/类
public static void announceNewView(ViewDefinition view, boolean announceLocally) throws ConfigurationException
{
    view.metadata.validate();

    KeyspaceMetadata ksm = Schema.instance.getKSMetaData(view.ksName);
    if (ksm == null)
        throw new ConfigurationException(String.format("Cannot add table '%s' to non existing keyspace '%s'.", view.viewName, view.ksName));
    else if (ksm.getTableOrViewNullable(view.viewName) != null)
        throw new AlreadyExistsException(view.ksName, view.viewName);

    logger.info(String.format("Create new view: %s", view));
    announce(SchemaKeyspace.makeCreateViewMutation(ksm, view, FBUtilities.timestampMicros()), announceLocally);
}
 

import org.apache.cassandra.exceptions.AlreadyExistsException; //导入依赖的package包/类
@Test(expected = AlreadyExistsException.class)
public void testCreateWithIdDuplicate() throws Throwable
{
    createTable("CREATE TABLE %s (a int, b int, c int, PRIMARY KEY(a, b))");
    UUID id = currentTableMetadata().cfId;
    execute(String.format("CREATE TABLE %%s (a int, b int, c int, PRIMARY KEY(a, b)) WITH ID = %s", id));
}
 

import org.apache.cassandra.exceptions.AlreadyExistsException; //导入依赖的package包/类
public static void announceNewColumnFamily(CFMetaData cfm, boolean announceLocally) throws ConfigurationException
{
    cfm.validate();

    KSMetaData ksm = Schema.instance.getKSMetaData(cfm.ksName);
    if (ksm == null)
        throw new ConfigurationException(String.format("Cannot add table '%s' to non existing keyspace '%s'.", cfm.cfName, cfm.ksName));
    else if (ksm.cfMetaData().containsKey(cfm.cfName))
        throw new AlreadyExistsException(cfm.ksName, cfm.cfName);

    logger.info(String.format("Create new table: %s", cfm));
    announce(addSerializedKeyspace(cfm.toSchema(FBUtilities.timestampMicros()), cfm.ksName), announceLocally);
}