import org.apache.cassandra.cql3.statements.CFStatement; //导入依赖的package包/类
@VisibleForTesting
public static CFMetaData compile(String cql, String keyspace)
{
    try
    {
        CFStatement parsed = (CFStatement)QueryProcessor.parseStatement(cql);
        parsed.prepareKeyspace(keyspace);
        CreateTableStatement statement = (CreateTableStatement) parsed.prepare().statement;
        CFMetaData cfm = newSystemMetadata(keyspace, statement.columnFamily(), "", statement.comparator);
        statement.applyPropertiesTo(cfm);
        return cfm.rebuild();
    }
    catch (RequestValidationException e)
    {
        throw new RuntimeException(e);
    }
}
 

import org.apache.cassandra.cql3.statements.CFStatement; //导入依赖的package包/类
public static CFMetaData compile(String cql, String keyspace, IPartitioner partitioner)
{
    CFStatement parsed = (CFStatement) QueryProcessor.parseStatement(cql);
    parsed.properties.properties.addProperty(CFProperties.KEYSPACE_NAME, keyspace);

    CreateTableStatement statement = (CreateTableStatement) parsed.prepare().statement;

    return statement.metadataBuilder()
            .withId(generateLegacyCfId(keyspace, statement.columnFamily()))
            .withPartitioner(partitioner)
            .build()
            .params(statement.params());
}
 

import org.apache.cassandra.cql3.statements.CFStatement; //导入依赖的package包/类
public static CFMetaData tableFromCQL(InputStream source, UUID cfid) throws IOException {
    String schema = CharStreams.toString(new InputStreamReader(source, "UTF-8"));
    logger.trace("Loading Schema" + schema);
    CFStatement statement = (CFStatement) QueryProcessor.parseStatement(schema);
    String keyspace = "";
    try {
        keyspace = statement.keyspace() == null ? "turtles" : statement.keyspace();
    } catch (AssertionError e) { // if -ea added we should provide lots of warnings that things probably wont work
        logger.warn("Remove '-ea' JVM option when using sstable-tools library");
        keyspace = "turtles";
    }
    statement.prepareKeyspace(keyspace);
    if(Schema.instance.getKSMetaData(keyspace) == null) {
        Schema.instance.setKeyspaceMetadata(KeyspaceMetadata.create(keyspace, KeyspaceParams.local(), Tables.none(),
                Views.none(), getTypes(), Functions.none()));
    }
    CFMetaData cfm;
    if(cfid != null) {
        cfm = ((CreateTableStatement) statement.prepare().statement).metadataBuilder().withId(cfid).build();
        KeyspaceMetadata prev = Schema.instance.getKSMetaData(keyspace);
        List<CFMetaData> tables = Lists.newArrayList(prev.tablesAndViews());
        tables.add(cfm);
        Schema.instance.setKeyspaceMetadata(prev.withSwapped(Tables.of(tables)));
        Schema.instance.load(cfm);
    } else {
        cfm = ((CreateTableStatement) statement.prepare().statement).getCFMetaData();
    }
    return cfm;
}
 

import org.apache.cassandra.cql3.statements.CFStatement; //导入依赖的package包/类
public static CFMetaData compile(String cql, String keyspace)
{
    CFStatement parsed = (CFStatement)QueryProcessor.parseStatement(cql);
    parsed.prepareKeyspace(keyspace);
    CreateTableStatement statement = (CreateTableStatement) ((CreateTableStatement.RawStatement) parsed).prepare(Types.none()).statement;

    return statement.metadataBuilder()
                    .withId(generateLegacyCfId(keyspace, statement.columnFamily()))
                    .build()
                    .params(statement.params())
                    .readRepairChance(0.0)
                    .dcLocalReadRepairChance(0.0)
                    .gcGraceSeconds(0)
                    .memtableFlushPeriod((int) TimeUnit.HOURS.toMillis(1));
}
 

import org.apache.cassandra.cql3.statements.CFStatement; //导入依赖的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.cql3.statements.CFStatement; //导入依赖的package包/类
@SuppressWarnings("serial")
@Override
public CFMetaData getCFMetaData(String keyspace, String cfName) {
    Pair<String, String> key = Pair.create(keyspace, cfName);
    CFMetaData cfm = cfMetaDatas.get(key);
    if (cfm == null) {
        KeyspaceMetadata ks = metadata.getKeyspace(keyspace);
        TableMetadata cf = ks.getTable(cfName);
        CFStatement parsed = (CFStatement) QueryProcessor.parseStatement(cf.asCQLQuery());
        org.apache.cassandra.schema.KeyspaceMetadata ksm = Schema.instance.getKSMetaData(keyspace);
        CreateTableStatement statement = (CreateTableStatement) ((CreateTableStatement.RawStatement) parsed)
                .prepare(ksm != null ? ksm.types : Types.none()).statement;
        statement.validate(ClientState.forInternalCalls());
        cfm = statement.getCFMetaData();

        final Map<ByteBuffer, DroppedColumn> map = new HashMap<>();
        Map<ByteBuffer, DroppedColumn> droppedColumns = map;

        try {
            ResultSet r = session.execute(SELECT_DROPPED_COLUMNS + " WHERE keyspace_name = '" + keyspace
                    + "' AND table_name = '" + cfName + '\'');

            for (Row row : r) {
                String name = row.getString("column_name");
                long droppedTime = row.getTimestamp("dropped_time").getTime();
                AbstractType<?> type = parse(keyspace, row.getString("type"),
                        org.apache.cassandra.schema.Types.none());
                droppedColumns.put(UTF8Type.instance.decompose(name),
                        new CFMetaData.DroppedColumn(name, type, droppedTime * 1000));
            }
        } catch (DriverException e) {
            // ignore. Assume we're asking a v2 schema source.
        }
        if (!ignoreColumns.isEmpty()) {
            droppedColumns = new HashMap<ByteBuffer, DroppedColumn>(droppedColumns) {
                @Override
                public DroppedColumn get(Object key) {
                    DroppedColumn c = super.get(key);
                    if (c == null) {
                        String name = UTF8Type.instance.compose((ByteBuffer) key);
                        if (ignoreColumns.contains(name)) {
                            c = new DroppedColumn(name, BytesType.instance, FBUtilities.timestampMicros());
                            put((ByteBuffer) key, c);
                        }
                    }
                    return c;
                }
            };
        }
        cfm.droppedColumns(droppedColumns);
        cfMetaDatas.put(key, cfm);
    }
    return cfm;
}