org.apache.cassandra.exceptions.SyntaxException Java Examples

@Override protected void setup(
        Context context)
        throws IOException, InterruptedException {
    super.setup(context);

    maxRowSize = context.getConfiguration().getLong(Aegisthus.Feature.CONF_MAXCOLSIZE, Long.MAX_VALUE);

    String columnType = context.getConfiguration().get(Aegisthus.Feature.CONF_COLUMNTYPE, "BytesType");
    String rowKeyType = context.getConfiguration().get(Aegisthus.Feature.CONF_KEYTYPE, "BytesType");

    try {
        columnComparator = TypeParser.parse(columnType);
        rowKeyComparator = TypeParser.parse(rowKeyType);
    } catch (SyntaxException | ConfigurationException e) {
        throw new RuntimeException(e);
    }
}
 

public static Cluster loadTablesFromRemote(String host, int port, String cfidOverrides) throws IOException {
    Map<String, UUID> cfs = parseOverrides(cfidOverrides);
    Cluster.Builder builder = Cluster.builder().addContactPoints(host).withPort(port);
    Cluster cluster = builder.build();
    Metadata metadata = cluster.getMetadata();
    IPartitioner partitioner = FBUtilities.newPartitioner(metadata.getPartitioner());
    if (DatabaseDescriptor.getPartitioner() == null)
        DatabaseDescriptor.setPartitionerUnsafe(partitioner);
    for (com.datastax.driver.core.KeyspaceMetadata ksm : metadata.getKeyspaces()) {
        if (!ksm.getName().equals("system")) {
            for (TableMetadata tm : ksm.getTables()) {
                String name = ksm.getName()+"."+tm.getName();
                try {
                    CassandraUtils.tableFromCQL(
                            new ByteArrayInputStream(tm.asCQLQuery().getBytes()),
                            cfs.get(name) != null ? cfs.get(name) : tm.getId());
                } catch(SyntaxException e) {
                    // ignore tables that we cant parse (probably dse)
                    logger.debug("Ignoring table " + name + " due to syntax exception " + e.getMessage());
                }
            }
        }
    }
    return cluster;
}
 

public static Integer toInt(String key, String value, Integer defaultValue) throws SyntaxException
{
    if (value == null)
    {
        return defaultValue;
    }
    else
    {
        try
        {
            return Integer.valueOf(value);
        }
        catch (NumberFormatException e)
        {
            throw new SyntaxException(String.format("Invalid integer value %s for '%s'", value, key));
        }
    }
}
 

public Double getDouble(String key, Double defaultValue) throws SyntaxException
{
    String value = getSimple(key);
    if (value == null)
    {
        return defaultValue;
    }
    else
    {
        try
        {
            return Double.valueOf(value);
        }
        catch (NumberFormatException e)
        {
            throw new SyntaxException(String.format("Invalid double value %s for '%s'", value, key));
        }
    }
}
 

public static MapType<?, ?> getInstance(TypeParser parser) throws ConfigurationException, SyntaxException
{
    List<AbstractType<?>> l = parser.getTypeParameters();
    if (l.size() != 2)
        throw new ConfigurationException("MapType takes exactly 2 type parameters");

    return getInstance(l.get(0), l.get(1), true);
}
 

public void applyToCFMetadata(CFMetaData cfm) throws ConfigurationException, SyntaxException
{
    if (hasProperty(KW_COMMENT))
        cfm.comment(getString(KW_COMMENT, ""));

    cfm.readRepairChance(getDouble(KW_READREPAIRCHANCE, cfm.getReadRepairChance()));
    cfm.dcLocalReadRepairChance(getDouble(KW_DCLOCALREADREPAIRCHANCE, cfm.getDcLocalReadRepair()));
    cfm.gcGraceSeconds(getInt(KW_GCGRACESECONDS, cfm.getGcGraceSeconds()));
    int minCompactionThreshold = toInt(KW_MINCOMPACTIONTHRESHOLD, getCompactionOptions().get(KW_MINCOMPACTIONTHRESHOLD), cfm.getMinCompactionThreshold());
    int maxCompactionThreshold = toInt(KW_MAXCOMPACTIONTHRESHOLD, getCompactionOptions().get(KW_MAXCOMPACTIONTHRESHOLD), cfm.getMaxCompactionThreshold());
    if (minCompactionThreshold <= 0 || maxCompactionThreshold <= 0)
        throw new ConfigurationException("Disabling compaction by setting compaction thresholds to 0 has been deprecated, set the compaction option 'enabled' to false instead.");
    cfm.minCompactionThreshold(minCompactionThreshold);
    cfm.maxCompactionThreshold(maxCompactionThreshold);
    cfm.defaultTimeToLive(getInt(KW_DEFAULT_TIME_TO_LIVE, cfm.getDefaultTimeToLive()));
    cfm.speculativeRetry(CFMetaData.SpeculativeRetry.fromString(getString(KW_SPECULATIVE_RETRY, cfm.getSpeculativeRetry().toString())));
    cfm.memtableFlushPeriod(getInt(KW_MEMTABLE_FLUSH_PERIOD, cfm.getMemtableFlushPeriod()));
    cfm.minIndexInterval(getInt(KW_MIN_INDEX_INTERVAL, cfm.getMinIndexInterval()));
    cfm.maxIndexInterval(getInt(KW_MAX_INDEX_INTERVAL, cfm.getMaxIndexInterval()));

    if (compactionStrategyClass != null)
    {
        cfm.compactionStrategyClass(compactionStrategyClass);
        cfm.compactionStrategyOptions(new HashMap<>(getCompactionOptions()));
    }

    cfm.bloomFilterFpChance(getDouble(KW_BF_FP_CHANCE, cfm.getBloomFilterFpChance()));

    if (!getCompressionOptions().isEmpty())
        cfm.compressionParameters(CompressionParameters.create(getCompressionOptions()));
    CachingOptions cachingOptions = getCachingOptions();
    if (cachingOptions != null)
        cfm.caching(cachingOptions);
}
 

private AbstractType<?> parseType(String type) throws ConfigurationException
{
    try
    {
        // always treat counters like longs, specifically CCT.serialize is not what we need
        if (type != null && type.equals("org.apache.cassandra.db.marshal.CounterColumnType"))
            return LongType.instance;
        return TypeParser.parse(type);
    }
    catch (SyntaxException e)
    {
        throw new ConfigurationException(e.getMessage(), e);
    }
}
 

public static AbstractType<?> getInstance(TypeParser parser) throws ConfigurationException, SyntaxException
{
    List<AbstractType<?>> innerTypes = parser.getTypeParameters();
    if (innerTypes.size() != 1)
        throw new SyntaxException("FrozenType() only accepts one parameter");

    AbstractType<?> innerType = innerTypes.get(0);
    return innerType.freeze();
}
 

public static AbstractType<?> parseDefaultParameters(AbstractType<?> baseType, TypeParser parser) throws SyntaxException
{
    Map<String, String> parameters = parser.getKeyValueParameters();
    String reversed = parameters.get("reversed");
    if (reversed != null && (reversed.isEmpty() || reversed.equals("true")))
    {
        return ReversedType.getInstance(baseType);
    }
    else
    {
        return baseType;
    }
}
 

public static SetType<?> getInstance(TypeParser parser) throws ConfigurationException, SyntaxException
{
    List<AbstractType<?>> l = parser.getTypeParameters();
    if (l.size() != 1)
        throw new ConfigurationException("SetType takes exactly 1 type parameter");

    return getInstance(l.get(0), true);
}
 

public static ListType<?> getInstance(TypeParser parser) throws ConfigurationException, SyntaxException
{
    List<AbstractType<?>> l = parser.getTypeParameters();
    if (l.size() != 1)
        throw new ConfigurationException("ListType takes exactly 1 type parameter");

    return getInstance(l.get(0), true);
}
 

private void validateMinimumInt(String field, int minimumValue, int defaultValue) throws SyntaxException, ConfigurationException
{
    Integer val = getInt(field, null);
    if (val != null && val < minimumValue)
        throw new ConfigurationException(String.format("%s cannot be smaller than %s, (default %s)",
                                                        field, minimumValue, defaultValue));

}
 

public static TupleType getInstance(TypeParser parser) throws ConfigurationException, SyntaxException
{
    List<AbstractType<?>> types = parser.getTypeParameters();
    for (int i = 0; i < types.size(); i++)
        types.set(i, types.get(i).freeze());
    return new TupleType(types);
}
 

public static UserType getInstance(TypeParser parser) throws ConfigurationException, SyntaxException
{
    Pair<Pair<String, ByteBuffer>, List<Pair<ByteBuffer, AbstractType>>> params = parser.getUserTypeParameters();
    String keyspace = params.left.left;
    ByteBuffer name = params.left.right;
    List<ByteBuffer> columnNames = new ArrayList<>(params.right.size());
    List<AbstractType<?>> columnTypes = new ArrayList<>(params.right.size());
    for (Pair<ByteBuffer, AbstractType> p : params.right)
    {
        columnNames.add(p.left);
        columnTypes.add(p.right.freeze());
    }
    return new UserType(keyspace, name, columnNames, columnTypes);
}
 

public static <T> ReversedType<T> getInstance(TypeParser parser) throws ConfigurationException, SyntaxException
{
    List<AbstractType<?>> types = parser.getTypeParameters();
    if (types.size() != 1)
        throw new ConfigurationException("ReversedType takes exactly one argument, " + types.size() + " given");
    return getInstance((AbstractType<T>) types.get(0));
}
 

private void assertInvalidCreateWithMessage(String createTableStatement, String errorMessage) throws Throwable
{
     try
    {
        createTableMayThrow(createTableStatement);
        Assert.fail("Expected CREATE TABLE statement to error: " + createTableStatement);
    }
    catch (InvalidRequestException | ConfigurationException | SyntaxException ex)
    {
        Assert.assertTrue("Expected error message to contain '" + errorMessage + "', but got '" + ex.getMessage() + "'",
                ex.getMessage().contains(errorMessage));
    }
}
 

@Test
public void testParse() throws ConfigurationException, SyntaxException
{
    AbstractType type;

    type = TypeParser.parse(null);
    assert type == BytesType.instance;

    type = TypeParser.parse("");
    assert type == BytesType.instance;

    type = TypeParser.parse("    ");
    assert type == BytesType.instance;

    type = TypeParser.parse("LongType");
    assert type == LongType.instance;

    type = TypeParser.parse("  LongType   ");
    assert type == LongType.instance;

    type = TypeParser.parse("LongType()");
    assert type == LongType.instance;

    type = TypeParser.parse("LongType(reversed=false)");
    assert type == LongType.instance;

    type = TypeParser.parse("LongType(reversed=true)");
    assert type == ReversedType.getInstance(LongType.instance);
    assert ((ReversedType)type).baseType == LongType.instance;

    type = TypeParser.parse("LongType(reversed)");
    assert type == ReversedType.getInstance(LongType.instance);
    assert ((ReversedType)type).baseType == LongType.instance;
}
 

@SuppressWarnings("unchecked")
private AbstractType<ByteBuffer> getConverter(Configuration conf, String key) {
    String converterType = conf.get(key);
    if (Strings.isNullOrEmpty(key)) {
        return BytesType.instance;
    }

    try {
        return (AbstractType<ByteBuffer>) TypeParser.parse(converterType);
    } catch (SyntaxException | ConfigurationException e) {
        throw Throwables.propagate(e);
    }
}
 

@Override
public void setConf(Configuration conf) {
    this.conf = conf;
    String columnType = conf.get(Aegisthus.Feature.CONF_COLUMNTYPE, "BytesType");
    legacyColumnNameFormatting = conf.getBoolean(Aegisthus.Feature.CONF_LEGACY_COLUMN_NAME_FORMATTING, false);
    sortColumnsByName = conf.getBoolean(Aegisthus.Feature.CONF_SORT_COLUMNS_BY_NAME, false);
    try {
        //noinspection unchecked
        columnNameConverter = (AbstractType<ByteBuffer>) TypeParser.parse(columnType);
    } catch (SyntaxException | ConfigurationException e) {
        throw new RuntimeException(e);
    }
}
 

public CachingOptions getCachingOptions() throws SyntaxException, ConfigurationException
{
    CachingOptions options = null;
    Object val = properties.get(KW_CACHING);
    if (val == null)
        return null;
    else if (val instanceof Map)
        options = CachingOptions.fromMap(getMap(KW_CACHING));
    else if (val instanceof String) // legacy syntax
    {
        options = CachingOptions.fromString(getSimple(KW_CACHING));
        logger.warn("Setting caching options with deprecated syntax.");
    }
    return options;
}
 

public void doSchema(String command) throws Exception {
    String path = command.substring(6).trim().replaceAll("\"", "");

    if (path.equalsIgnoreCase("off")) {
        System.out.println(DISABLING_SCHEMA);
        CassandraUtils.cqlOverride = null;
    } else if (Strings.isNullOrEmpty(path)) {
        if (!Strings.isNullOrEmpty(CassandraUtils.cqlOverride)) {
            System.out.printf(USER_DEFINED_SCHEMA, CassandraUtils.cqlOverride);
        } else {
            System.out.println(NO_USER_DEFINED_SCHEMA);
        }
    } else {
        File schemaFile = new File(path);
        if (!schemaFile.exists()) {
            System.err.printf(CANNOT_FIND_FILE, schemaFile.getAbsolutePath());
        } else {
            String cql = new String(Files.readAllBytes(schemaFile.toPath()));
            try {
                ParsedStatement statement = QueryProcessor.parseStatement(cql);
                if (statement instanceof CreateTableStatement.RawStatement) {
                    CassandraUtils.cqlOverride = cql;
                    System.out.printf(IMPORTED_SCHEMA, schemaFile.getAbsolutePath());
                } else {
                    System.err.printf(FAILED_TO_IMPORT_SCHEMA, schemaFile.getAbsoluteFile(), "Wrong type of statement, " + statement.getClass());
                }
            } catch (SyntaxException se) {
                System.err.printf(FAILED_TO_IMPORT_SCHEMA, schemaFile.getAbsoluteFile(), se.getMessage());
            }
        }
    }

}
 

public static ParsedStatement parseStatement(String queryStr) throws SyntaxException
{
    try
    {
        // Lexer and parser
        ErrorCollector errorCollector = new ErrorCollector(queryStr);
        CharStream stream = new ANTLRStringStream(queryStr);
        CqlLexer lexer = new CqlLexer(stream);
        lexer.addErrorListener(errorCollector);

        TokenStream tokenStream = new CommonTokenStream(lexer);
        CqlParser parser = new CqlParser(tokenStream);
        parser.addErrorListener(errorCollector);

        // Parse the query string to a statement instance
        ParsedStatement statement = parser.query();

        // The errorCollector has queue up any errors that the lexer and parser may have encountered
        // along the way, if necessary, we turn the last error into exceptions here.
        errorCollector.throwLastSyntaxError();

        return statement;
    }
    catch (RuntimeException re)
    {
        logger.error(String.format("The statement: [%s] could not be parsed.", queryStr), re);
        throw new SyntaxException(String.format("Failed parsing statement: [%s] reason: %s %s",
                                                queryStr,
                                                re.getClass().getSimpleName(),
                                                re.getMessage()));
    }
    catch (RecognitionException e)
    {
        throw new SyntaxException("Invalid or malformed CQL query string: " + e.getMessage());
    }
}
 

public void validate(Set<String> keywords, Set<String> obsolete) throws SyntaxException
{
    for (String name : properties.keySet())
    {
        if (keywords.contains(name))
            continue;

        if (obsolete.contains(name))
            logger.warn("Ignoring obsolete property {}", name);
        else
            throw new SyntaxException(String.format("Unknown property '%s'", name));
    }
}
 

protected String getSimple(String name) throws SyntaxException
{
    Object val = properties.get(name);
    if (val == null)
        return null;
    if (!(val instanceof String))
        throw new SyntaxException(String.format("Invalid value for property '%s'. It should be a string", name));
    return (String)val;
}
 

protected Map<String, String> getMap(String name) throws SyntaxException
{
    Object val = properties.get(name);
    if (val == null)
        return null;
    if (!(val instanceof Map))
        throw new SyntaxException(String.format("Invalid value for property '%s'. It should be a map.", name));
    return (Map<String, String>)val;
}
 

public Map<String, String> getCompressionOptions() throws SyntaxException
{
    Map<String, String> compressionOptions = getMap(KW_COMPRESSION);
    if (compressionOptions == null)
        return new HashMap<>();
    return compressionOptions;
}
 

public Map<String, String> getCompactionOptions() throws SyntaxException
{
    Map<String, String> compactionOptions = getMap(KW_COMPACTION);
    if (compactionOptions == null)
        return new HashMap<>();
    return compactionOptions;
}
 

public AbstractType<?> getComparator() throws ConfigurationException, SyntaxException
{
    return TypeParser.parse((comparators.get(getPropertyString(KW_COMPARATOR, "text")) != null)
                              ? comparators.get(getPropertyString(KW_COMPARATOR, "text"))
                              : getPropertyString(KW_COMPARATOR, "text"));
}
 

public Integer getDefaultTimeToLive() throws SyntaxException
{
    return getInt(KW_DEFAULT_TIME_TO_LIVE, 0);
}
 

/**
 * Throws the last syntax error found by the lexer or the parser if it exists.
 *
 * @throws SyntaxException the syntax error.
 */
public void throwLastSyntaxError() throws SyntaxException
{
    if (!errorMsgs.isEmpty())
        throw new SyntaxException(errorMsgs.getLast());
}