Java Event.SchemaChange方法代码示例

import org.apache.cassandra.transport.Event; //导入方法依赖的package包/类
public Event.SchemaChange announceMigration(boolean isLocalOnly) throws ConfigurationException, InvalidRequestException
{
    CFMetaData cfm = Schema.instance.getCFMetaData(keyspace(), columnFamily()).copy();
    Triggers triggers = cfm.getTriggers();

    if (triggers.get(triggerName).isPresent())
    {
        if (ifNotExists)
            return null;
        else
            throw new InvalidRequestException(String.format("Trigger %s already exists", triggerName));
    }

    cfm.triggers(triggers.with(TriggerMetadata.create(triggerName, triggerClass)));
    logger.info("Adding trigger with name {} and class {}", triggerName, triggerClass);
    MigrationManager.announceColumnFamilyUpdate(cfm, isLocalOnly);
    return new Event.SchemaChange(Event.SchemaChange.Change.UPDATED, Event.SchemaChange.Target.TABLE, keyspace(), columnFamily());
}
 

import org.apache.cassandra.transport.Event; //导入方法依赖的package包/类
public Event.SchemaChange announceMigration(boolean isLocalOnly) throws RequestValidationException
{
    KeyspaceMetadata ksm = KeyspaceMetadata.create(name, attrs.asNewKeyspaceParams());
    try
    {
        MigrationManager.announceNewKeyspace(ksm, isLocalOnly);
        return new Event.SchemaChange(Event.SchemaChange.Change.CREATED, keyspace());
    }
    catch (AlreadyExistsException e)
    {
        if (ifNotExists)
            return null;
        throw e;
    }
}
 

import org.apache.cassandra.transport.Event; //导入方法依赖的package包/类
public Event.SchemaChange announceMigration(boolean isLocalOnly) throws RequestValidationException
{
    Function old = Schema.instance.findFunction(functionName, argTypes).orElse(null);
    boolean replaced = old != null;
    if (replaced)
    {
        if (ifNotExists)
            return null;
        if (!orReplace)
            throw new InvalidRequestException(String.format("Function %s already exists", old));
        if (!(old instanceof ScalarFunction))
            throw new InvalidRequestException(String.format("Function %s can only replace a function", old));
        if (calledOnNullInput != ((ScalarFunction) old).isCalledOnNullInput())
            throw new InvalidRequestException(String.format("Function %s can only be replaced with %s", old,
                                                            calledOnNullInput ? "CALLED ON NULL INPUT" : "RETURNS NULL ON NULL INPUT"));

        if (!Functions.typesMatch(old.returnType(), returnType))
            throw new InvalidRequestException(String.format("Cannot replace function %s, the new return type %s is not compatible with the return type %s of existing function",
                                                            functionName, returnType.asCQL3Type(), old.returnType().asCQL3Type()));
    }

    UDFunction udFunction = UDFunction.create(functionName, argNames, argTypes, returnType, calledOnNullInput, language, body);

    MigrationManager.announceNewFunction(udFunction, isLocalOnly);

    return new Event.SchemaChange(replaced ? Event.SchemaChange.Change.UPDATED : Event.SchemaChange.Change.CREATED,
                                  Event.SchemaChange.Target.FUNCTION,
                                  udFunction.name().keyspace, udFunction.name().name, AbstractType.asCQLTypeStringList(udFunction.argTypes()));
}
 

import org.apache.cassandra.transport.Event; //导入方法依赖的package包/类
public Event.SchemaChange announceMigration(boolean isLocalOnly) throws ConfigurationException
{
    try
    {
        MigrationManager.announceKeyspaceDrop(keyspace, isLocalOnly);
        return new Event.SchemaChange(Event.SchemaChange.Change.DROPPED, keyspace());
    }
    catch(ConfigurationException e)
    {
        if (ifExists)
            return null;
        throw e;
    }
}
 

import org.apache.cassandra.transport.Event; //导入方法依赖的package包/类
public Event.SchemaChange announceMigration(boolean isLocalOnly) throws InvalidRequestException, ConfigurationException
{
    KeyspaceMetadata ksm = Schema.instance.getKSMetaData(name.getKeyspace());
    if (ksm == null)
        return null; // do not assert (otherwise IF EXISTS case fails)

    UserType toDrop = ksm.types.getNullable(name.getUserTypeName());
    // Can be null with ifExists
    if (toDrop == null)
        return null;

    MigrationManager.announceTypeDrop(toDrop, isLocalOnly);
    return new Event.SchemaChange(Event.SchemaChange.Change.DROPPED, Event.SchemaChange.Target.TYPE, keyspace(), name.getStringTypeName());
}
 

import org.apache.cassandra.transport.Event; //导入方法依赖的package包/类
public Event.SchemaChange announceMigration(boolean isLocalOnly) throws RequestValidationException
{
    try
    {
        MigrationManager.announceNewColumnFamily(getCFMetaData(), isLocalOnly);
        return new Event.SchemaChange(Event.SchemaChange.Change.CREATED, Event.SchemaChange.Target.TABLE, keyspace(), columnFamily());
    }
    catch (AlreadyExistsException e)
    {
        if (ifNotExists)
            return null;
        throw e;
    }
}
 

import org.apache.cassandra.transport.Event; //导入方法依赖的package包/类
public Event.SchemaChange announceMigration(boolean isLocalOnly) throws InvalidRequestException, ConfigurationException
{
    CFMetaData cfm = lookupIndexedTable();
    if (cfm == null)
        return null;

    CFMetaData updatedCfm = cfm.copy();
    updatedCfm.indexes(updatedCfm.getIndexes().without(indexName));
    MigrationManager.announceColumnFamilyUpdate(updatedCfm, isLocalOnly);
    // Dropping an index is akin to updating the CF
    // Note that we shouldn't call columnFamily() at this point because the index has been dropped and the call to lookupIndexedTable()
    // in that method would now throw.
    return new Event.SchemaChange(Event.SchemaChange.Change.UPDATED, Event.SchemaChange.Target.TABLE, cfm.ksName, cfm.cfName);
}
 

import org.apache.cassandra.transport.Event; //导入方法依赖的package包/类
public Event.SchemaChange announceMigration(boolean isLocalOnly) throws RequestValidationException
{
    KeyspaceMetadata oldKsm = Schema.instance.getKSMetaData(name);
    // In the (very) unlikely case the keyspace was dropped since validate()
    if (oldKsm == null)
        throw new InvalidRequestException("Unknown keyspace " + name);

    KeyspaceMetadata newKsm = oldKsm.withSwapped(attrs.asAlteredKeyspaceParams(oldKsm.params));
    MigrationManager.announceKeyspaceUpdate(newKsm, isLocalOnly);
    return new Event.SchemaChange(Event.SchemaChange.Change.UPDATED, keyspace());
}
 

import org.apache.cassandra.transport.Event; //导入方法依赖的package包/类
public Event.SchemaChange announceMigration(boolean isLocalOnly) throws InvalidRequestException, ConfigurationException
    {
        try
        {
//            ViewDefinition view = Schema.instance.getViewDefinition(keyspace(), columnFamily());
//            if (view == null)
//            {
//                if (Schema.instance.getCFMetaData(keyspace(), columnFamily()) != null)
//                    throw new ConfigurationException(String.format("Cannot drop table '%s' in keyspace '%s'.", columnFamily(), keyspace()));
//
//                throw new ConfigurationException(String.format("Cannot drop non existing materialized view '%s' in keyspace '%s'.", columnFamily(), keyspace()));
//            }
//
//            CFMetaData baseCfm = Schema.instance.getCFMetaData(view.baseTableId);
//            if (baseCfm == null)
//            {
//                if (ifExists)
//                    throw new ConfigurationException(String.format("Cannot drop materialized view '%s' in keyspace '%s' without base CF.", columnFamily(), keyspace()));
//                else
//                    throw new InvalidRequestException(String.format("View '%s' could not be found in any of the tables of keyspace '%s'", cfName, keyspace()));
//            }

            MigrationManager.announceViewDrop(keyspace(), columnFamily(), isLocalOnly);
            return new Event.SchemaChange(Event.SchemaChange.Change.DROPPED, Event.SchemaChange.Target.TABLE, keyspace(), columnFamily());
        }
        catch (ConfigurationException e)
        {
            if (ifExists)
                return null;
            throw e;
        }
    }
 

import org.apache.cassandra.transport.Event; //导入方法依赖的package包/类
public Event.SchemaChange announceMigration(boolean isLocalOnly) throws RequestValidationException
{
    Function old = Schema.instance.findFunction(functionName, argTypes).orElse(null);
    boolean replaced = old != null;
    if (replaced)
    {
        if (ifNotExists)
            return null;
        if (!orReplace)
            throw new InvalidRequestException(String.format("Function %s already exists", old));
        if (!(old instanceof AggregateFunction))
            throw new InvalidRequestException(String.format("Aggregate %s can only replace an aggregate", old));

        // Means we're replacing the function. We still need to validate that 1) it's not a native function and 2) that the return type
        // matches (or that could break existing code badly)
        if (old.isNative())
            throw new InvalidRequestException(String.format("Cannot replace native aggregate %s", old));
        if (!old.returnType().isValueCompatibleWith(returnType))
            throw new InvalidRequestException(String.format("Cannot replace aggregate %s, the new return type %s is not compatible with the return type %s of existing function",
                                                            functionName, returnType.asCQL3Type(), old.returnType().asCQL3Type()));
    }

    if (!stateFunction.isCalledOnNullInput() && initcond == null)
        throw new InvalidRequestException(String.format("Cannot create aggregate %s without INITCOND because state function %s does not accept 'null' arguments", functionName, stateFunc));

    UDAggregate udAggregate = new UDAggregate(functionName, argTypes, returnType, stateFunction, finalFunction, initcond);

    MigrationManager.announceNewAggregate(udAggregate, isLocalOnly);

    return new Event.SchemaChange(replaced ? Event.SchemaChange.Change.UPDATED : Event.SchemaChange.Change.CREATED,
                                  Event.SchemaChange.Target.AGGREGATE,
                                  udAggregate.name().keyspace, udAggregate.name().name, AbstractType.asCQLTypeStringList(udAggregate.argTypes()));
}
 

import org.apache.cassandra.transport.Event; //导入方法依赖的package包/类
public ResultMessage execute(QueryState state, QueryOptions options) throws RequestValidationException
{
    // If an IF [NOT] EXISTS clause was used, this may not result in an actual schema change.  To avoid doing
    // extra work in the drivers to handle schema changes, we return an empty message in this case. (CASSANDRA-7600)
    boolean didChangeSchema = announceMigration(false);
    if (!didChangeSchema)
        return new ResultMessage.Void();

    Event.SchemaChange ce = changeEvent();
    return ce == null ? new ResultMessage.Void() : new ResultMessage.SchemaChange(ce);
}
 

import org.apache.cassandra.transport.Event; //导入方法依赖的package包/类
public Event.SchemaChange changeEvent()
{
    return new Event.SchemaChange(Event.SchemaChange.Change.DROPPED, Event.SchemaChange.Target.TABLE, keyspace(), columnFamily());
}
 

import org.apache.cassandra.transport.Event; //导入方法依赖的package包/类
public Event.SchemaChange changeEvent()
{
    return new Event.SchemaChange(Event.SchemaChange.Change.UPDATED, Event.SchemaChange.Target.TABLE, keyspace(), columnFamily());
}
 

import org.apache.cassandra.transport.Event; //导入方法依赖的package包/类
public Event.SchemaChange changeEvent()
{
    // Creating an index is akin to updating the CF
    return new Event.SchemaChange(Event.SchemaChange.Change.UPDATED, Event.SchemaChange.Target.TABLE, keyspace(), columnFamily());
}
 

import org.apache.cassandra.transport.Event; //导入方法依赖的package包/类
public ResultMessage executeInternal(QueryState state, QueryOptions options)
{
    Event.SchemaChange ce = announceMigration(true);
    return ce == null ? new ResultMessage.Void() : new ResultMessage.SchemaChange(ce);
}