import org.apache.cassandra.service.ClientState; //导入依赖的package包/类
/**
 * Get the meta data (column definitions) for the target table.
 * 
 * @param query The CREATE TABLE statement for the table the Json data should be put into.
 * @return The table's meta data
 */
private static CFMetaData parseSchema(String query) {
    try {
        ClientState state = ClientState.forInternalCalls();
        ParsedStatement.Prepared prepared = QueryProcessor.getStatement(query, state);
        CQLStatement stmt = prepared.statement;
        stmt.validate(state);

        if (!stmt.getClass().equals(CreateTableStatement.class)) {
            throw new IllegalArgumentException("Invalid query, must be a CREATE TABLE statement");
        }

        return CreateTableStatement.class.cast(stmt).getCFMetaData();
    } catch (RequestValidationException | IllegalArgumentException e) {
        throw new RuntimeException(e);
    }
}
 

import org.apache.cassandra.service.ClientState; //导入依赖的package包/类
public void checkAccess(ClientState state) throws UnauthorizedException
{
    AuthenticatedUser user = state.getUser();

    boolean isSuper = user.isSuper();

    if (superuser != null && user.getName().equals(username))
        throw new UnauthorizedException("You aren't allowed to alter your own superuser status");

    if (superuser != null && !isSuper)
        throw new UnauthorizedException("Only superusers are allowed to alter superuser status");

    if (!user.isSuper() && !user.getName().equals(username))
        throw new UnauthorizedException("You aren't allowed to alter this user");

    if (!isSuper)
    {
        for (IAuthenticator.Option option : opts.getOptions().keySet())
        {
            if (!DatabaseDescriptor.getAuthenticator().alterableOptions().contains(option))
                throw new UnauthorizedException(String.format("You aren't allowed to alter %s option", option));
        }
    }
}
 

import org.apache.cassandra.service.ClientState; //导入依赖的package包/类
public String system_add_column_family(CfDef cf_def)
throws InvalidRequestException, SchemaDisagreementException, TException
{
    logger.debug("add_column_family");

    try
    {
        ClientState cState = state();
        String keyspace = cState.getKeyspace();
        cState.hasKeyspaceAccess(keyspace, Permission.CREATE);
        cf_def.unsetId(); // explicitly ignore any id set by client (Hector likes to set zero)
        CFMetaData cfm = CFMetaData.fromThrift(cf_def);
        CFMetaData.validateCompactionOptions(cfm.compactionStrategyClass, cfm.compactionStrategyOptions);
        cfm.addDefaultIndexNames();

        if (!cfm.getTriggers().isEmpty())
            state().ensureIsSuper("Only superusers are allowed to add triggers.");

        MigrationManager.announceNewColumnFamily(cfm);
        return Schema.instance.getVersion().toString();
    }
    catch (RequestValidationException e)
    {
        throw ThriftConversion.toThrift(e);
    }
}
 

import org.apache.cassandra.service.ClientState; //导入依赖的package包/类
/**
 * Grant all applicable permissions on the newly created role to the user performing the request
 * see also: SchemaAlteringStatement#grantPermissionsToCreator and the overridden implementations
 * of it in subclasses CreateKeyspaceStatement & CreateTableStatement.
 * @param state
 */
private void grantPermissionsToCreator(ClientState state)
{
    // The creator of a Role automatically gets ALTER/DROP/AUTHORIZE permissions on it if:
    // * the user is not anonymous
    // * the configured IAuthorizer supports granting of permissions (not all do, AllowAllAuthorizer doesn't and
    //   custom external implementations may not)
    if (!state.getUser().isAnonymous())
    {
        try
        {
            DatabaseDescriptor.getAuthorizer().grant(AuthenticatedUser.SYSTEM_USER,
                                                     role.applicablePermissions(),
                                                     role,
                                                     RoleResource.role(state.getUser().getName()));
        }
        catch (UnsupportedOperationException e)
        {
            // not a problem, grant is an optional method on IAuthorizer
        }
    }
}
 

import org.apache.cassandra.service.ClientState; //导入依赖的package包/类
/**
 * The <code>CqlParser</code> only goes as far as extracting the keyword arguments
 * from these statements, so this method is responsible for processing and
 * validating.
 *
 * @throws InvalidRequestException if arguments are missing or unacceptable
 */
public void validate(ClientState state) throws RequestValidationException
{
    ThriftValidation.validateKeyspaceNotSystem(name);

    // keyspace name
    if (!name.matches("\\w+"))
        throw new InvalidRequestException(String.format("\"%s\" is not a valid keyspace name", name));
    if (name.length() > Schema.NAME_LENGTH)
        throw new InvalidRequestException(String.format("Keyspace names shouldn't be more than %s characters long (got \"%s\")", Schema.NAME_LENGTH, name));

    attrs.validate();

    if (attrs.getReplicationStrategyClass() == null)
        throw new ConfigurationException("Missing mandatory replication strategy class");

    // The strategy is validated through KSMetaData.validate() in announceNewKeyspace below.
    // However, for backward compatibility with thrift, this doesn't validate unexpected options yet,
    // so doing proper validation here.
    AbstractReplicationStrategy.validateReplicationStrategy(name,
                                                            AbstractReplicationStrategy.getClass(attrs.getReplicationStrategyClass()),
                                                            StorageService.instance.getTokenMetadata(),
                                                            DatabaseDescriptor.getEndpointSnitch(),
                                                            attrs.getReplicationOptions());
}
 

import org.apache.cassandra.service.ClientState; //导入依赖的package包/类
private static <T extends CQLStatement> Pair<T, List<ColumnSpecification>> getStatement(String query, Class<T> klass, String type)
{
    try
    {
        ClientState state = ClientState.forInternalCalls();
        ParsedStatement.Prepared prepared = QueryProcessor.getStatement(query, state);
        CQLStatement stmt = prepared.statement;
        stmt.validate(state);

        if (!stmt.getClass().equals(klass))
            throw new IllegalArgumentException("Invalid query, must be a " + type + " statement");

        return Pair.create(klass.cast(stmt), prepared.boundNames);
    }
    catch (RequestValidationException e)
    {
        throw new IllegalArgumentException(e.getMessage(), e);
    }
}
 

import org.apache.cassandra.service.ClientState; //导入依赖的package包/类
public ResultMessage processStatement(CQLStatement statement, QueryState queryState, QueryOptions options)
throws RequestExecutionException, RequestValidationException
{
    logger.trace("Process {} @CL.{}", statement, options.getConsistency());
    ClientState clientState = queryState.getClientState();
    statement.checkAccess(clientState);
    statement.validate(clientState);

    ResultMessage result = statement.execute(queryState, options);
    return result == null ? new ResultMessage.Void() : result;
}
 

import org.apache.cassandra.service.ClientState; //导入依赖的package包/类
public void validate(ClientState state)
{
    Collection<Function> olds = Schema.instance.getFunctions(functionName);

    if (!argsPresent && olds != null && olds.size() > 1)
        throw new InvalidRequestException(String.format("'DROP FUNCTION %s' matches multiple function definitions; " +
                                                        "specify the argument types by issuing a statement like " +
                                                        "'DROP FUNCTION %s (type, type, ...)'. Hint: use cqlsh " +
                                                        "'DESCRIBE FUNCTION %s' command to find all overloads",
                                                        functionName, functionName, functionName));
}
 

import org.apache.cassandra.service.ClientState; //导入依赖的package包/类
public ResultMessage processBatch(BatchStatement batch, QueryState queryState, BatchQueryOptions options)
throws RequestExecutionException, RequestValidationException
{
    ClientState clientState = queryState.getClientState();
    batch.checkAccess(clientState);
    batch.validate();
    batch.validate(clientState);
    return batch.execute(queryState, options);
}
 

import org.apache.cassandra.service.ClientState; //导入依赖的package包/类
public void validate(ClientState state) throws RequestValidationException
{
    state.ensureNotAnonymous();

    if (!DatabaseDescriptor.getRoleManager().isExistingRole(role))
        throw new InvalidRequestException(String.format("%s doesn't exist", role.getRoleName()));

    if (!DatabaseDescriptor.getRoleManager().isExistingRole(grantee))
        throw new InvalidRequestException(String.format("%s doesn't exist", grantee.getRoleName()));
}
 

import org.apache.cassandra.service.ClientState; //导入依赖的package包/类
public void validate(ClientState state) throws InvalidRequestException
{
    if (hasConditions() && attrs.isTimestampSet())
        throw new InvalidRequestException("Cannot provide custom timestamp for conditional updates");

    if (isCounter() && attrs.isTimestampSet())
        throw new InvalidRequestException("Cannot provide custom timestamp for counter updates");

    if (isCounter() && attrs.isTimeToLiveSet())
        throw new InvalidRequestException("Cannot provide custom TTL for counter updates");
}
 

import org.apache.cassandra.service.ClientState; //导入依赖的package包/类
public void validate(ClientState state) throws RequestValidationException
{
    ThriftValidation.validateColumnFamily(keyspace(), columnFamily());
    try
    {
        TriggerExecutor.instance.loadTriggerInstance(triggerClass);
    }
    catch (Exception e)
    {
        throw new ConfigurationException(String.format("Trigger class '%s' doesn't exist", triggerClass));
    }
}
 

import org.apache.cassandra.service.ClientState; //导入依赖的package包/类
public void validate(ClientState state) throws InvalidRequestException
{
    UDFunction.assertUdfsEnabled(language);

    if (ifNotExists && orReplace)
        throw new InvalidRequestException("Cannot use both 'OR REPLACE' and 'IF NOT EXISTS' directives");

    if (Schema.instance.getKSMetaData(functionName.keyspace) == null)
        throw new InvalidRequestException(String.format("Cannot add function '%s' to non existing keyspace '%s'.", functionName.name, functionName.keyspace));
}
 

import org.apache.cassandra.service.ClientState; //导入依赖的package包/类
public void validate(ClientState state) throws RequestValidationException
{
    opts.validate();

    if (role.getRoleName().isEmpty())
        throw new InvalidRequestException("Role name can't be an empty string");

    // validate login here before checkAccess to avoid leaking role existence to anonymous users.
    state.ensureNotAnonymous();

    if (!ifNotExists && DatabaseDescriptor.getRoleManager().isExistingRole(role))
        throw new InvalidRequestException(String.format("%s already exists", role.getRoleName()));
}
 

import org.apache.cassandra.service.ClientState; //导入依赖的package包/类
public void validate(ClientState state) throws RequestValidationException
{
    opts.validate();

    if (superuser == null && opts.isEmpty())
        throw new InvalidRequestException("ALTER USER can't be empty");

    // validate login here before checkAccess to avoid leaking user existence to anonymous users.
    state.ensureNotAnonymous();

    if (!Auth.isExistingUser(username))
        throw new InvalidRequestException(String.format("User %s doesn't exist", username));
}
 

import org.apache.cassandra.service.ClientState; //导入依赖的package包/类
private static CFMetaData getTableMetadata(String schema)
{
    CFStatement parsed = (CFStatement)QueryProcessor.parseStatement(schema);
    // tables with UDTs are currently not supported by CQLSSTableWrite, so we just use Types.none(), for now
    // see CASSANDRA-10624 for more details
    CreateTableStatement statement = (CreateTableStatement) ((CreateTableStatement.RawStatement) parsed).prepare(Types.none()).statement;
    statement.validate(ClientState.forInternalCalls());
    return statement.getCFMetaData();
}
 

import org.apache.cassandra.service.ClientState; //导入依赖的package包/类
public ResultMessage execute(ClientState state) throws RequestValidationException, RequestExecutionException
{
    if (!opts.isEmpty())
        DatabaseDescriptor.getAuthenticator().alter(username, opts.getOptions());
    if (superuser != null)
        Auth.insertUser(username, superuser.booleanValue());
    return null;
}
 

import org.apache.cassandra.service.ClientState; //导入依赖的package包/类
public static IResource maybeCorrectResource(IResource resource, ClientState state) throws InvalidRequestException
{
    if (DataResource.class.isInstance(resource))
    {
        DataResource dataResource = (DataResource) resource;
        if (dataResource.isTableLevel() && dataResource.getKeyspace() == null)
            return DataResource.table(state.getKeyspace(), dataResource.getTable());
    }
    return resource;
}
 

import org.apache.cassandra.service.ClientState; //导入依赖的package包/类
public void validate(ClientState state) throws RequestValidationException
{
    // validate login here before checkAccess to avoid leaking user existence to anonymous users.
    state.ensureNotAnonymous();

    if (!Auth.isExistingUser(username))
        throw new InvalidRequestException(String.format("User %s doesn't exist", username));

    // if a keyspace is omitted when GRANT/REVOKE ON TABLE <table>, we need to correct the resource.
    resource = maybeCorrectResource(resource, state);
    if (!resource.exists())
        throw new InvalidRequestException(String.format("%s doesn't exist", resource));
}
 

import org.apache.cassandra.service.ClientState; //导入依赖的package包/类
public void checkAccess(ClientState state) throws UnauthorizedException
{
    // check that the user has AUTHORIZE permission on the resource or its parents, otherwise reject GRANT/REVOKE.
    state.ensureHasPermission(Permission.AUTHORIZE, resource);
    // check that the user has [a single permission or all in case of ALL] on the resource or its parents.
    for (Permission p : permissions)
        state.ensureHasPermission(p, resource);
}