# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements.  See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership.  The ASF licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License.  You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

import re
from warnings import warn
from .cqlhandling import CqlParsingRuleSet, Hint
from cql.cqltypes import (cql_types, lookup_casstype, CompositeType, UTF8Type,
                          ColumnToCollectionType, CounterColumnType)
from . import helptopics

simple_cql_types = set(cql_types)
simple_cql_types.difference_update(('set', 'map', 'list'))

cqldocs = helptopics.CQL3HelpTopics()

try:
    import json
except ImportError:
    import simplejson as json

class UnexpectedTableStructure(UserWarning):
    def __init__(self, msg):
        self.msg = msg

    def __str__(self):
        return 'Unexpected table structure; may not translate correctly to CQL. ' + self.msg

SYSTEM_KEYSPACES = ('system', 'system_traces', 'system_auth')
NONALTERBALE_KEYSPACES = ('system', 'system_traces')

class Cql3ParsingRuleSet(CqlParsingRuleSet):
    keywords = set((
        'select', 'from', 'where', 'and', 'key', 'insert', 'update', 'with',
        'limit', 'using', 'use', 'count', 'set',
        'begin', 'apply', 'batch', 'truncate', 'delete', 'in', 'create',
        'keyspace', 'schema', 'columnfamily', 'table', 'index', 'on', 'drop',
        'primary', 'into', 'values', 'timestamp', 'ttl', 'alter', 'add', 'type',
        'compact', 'storage', 'order', 'by', 'asc', 'desc', 'clustering',
        'token', 'writetime', 'map', 'list', 'to'
    ))

    unreserved_keywords = set((
        'key', 'clustering', 'ttl', 'compact', 'storage', 'type', 'values'
    ))

    columnfamily_options = (
        # (CQL option name, Thrift option name (or None if same))
        ('comment', None),
        ('compaction_strategy_class', 'compaction_strategy'),
        ('comparator', 'comparator_type'),
        ('default_validation', 'default_validation_class'),
        ('gc_grace_seconds', None),
        ('index_interval', None),
        ('read_repair_chance', None),
        ('replicate_on_write', None),
        ('populate_io_cache_on_flush', None),
    )

    old_columnfamily_layout_options = (
        # (CQL3 option name, schema_columnfamilies column name (or None if same))
        ('bloom_filter_fp_chance', None),
        ('caching', None),
        ('comment', None),
        ('compaction_strategy_class', None),
        ('dclocal_read_repair_chance', 'local_read_repair_chance'),
        ('gc_grace_seconds', None),
        ('index_interval', None),
        ('read_repair_chance', None),
        ('replicate_on_write', None),
        ('populate_io_cache_on_flush', None),
    )

    new_columnfamily_layout_options = (
        ('bloom_filter_fp_chance', None),
        ('caching', None),
        ('comment', None),
        ('dclocal_read_repair_chance', 'local_read_repair_chance'),
        ('gc_grace_seconds', None),
        ('index_interval', None),
        ('read_repair_chance', None),
        ('replicate_on_write', None),
        ('populate_io_cache_on_flush', None),
    )

    old_columnfamily_layout_map_options = (
        # (CQL3 option prefix, schema_columnfamilies column name (or None if same),
        #  list of known suboptions)
        ('compaction_strategy_options', None,
            ('min_compaction_threshold', 'max_compaction_threshold')),
        ('compression_parameters', None,
            ('sstable_compression', 'chunk_length_kb', 'crc_check_chance')),
    )

    new_columnfamily_layout_map_options = (
        # (CQL3 option name, schema_columnfamilies column name (or None if same),
        #  list of known map keys)
        ('compaction', 'compaction_strategy_options',
            ('class', 'min_threshold', 'max_threshold')),
        ('compression', 'compression_parameters',
            ('sstable_compression', 'chunk_length_kb', 'crc_check_chance')),
    )

    new_obsolete_cf_options = (
        'compaction_parameters',
        'compaction_strategy_class',
        'compaction_strategy_options',
        'compression_parameters',
        'max_compaction_threshold',
        'min_compaction_threshold',
    )

    @staticmethod
    def token_dequote(tok):
        if tok[0] == 'unclosedName':
            # strip one quote
            return tok[1][1:].replace('""', '"')
        # cql2 version knows how to do everything else
        return CqlParsingRuleSet.token_dequote(tok)

    @classmethod
    def cql3_dequote_value(cls, value):
        return cls.cql2_dequote_value(value)

    @staticmethod
    def cql3_dequote_name(name):
        name = name.strip()
        if name == '':
            return name
        if name[0] == '"' and name[-1] == '"':
            name = name[1:-1].replace('""', '"')
        return name

    @classmethod
    def cql3_escape_value(cls, value):
        return cls.cql2_escape_value(value)

    @staticmethod
    def cql3_escape_name(name):
        return '"%s"' % name.replace('"', '""')

    valid_cql3_word_re = re.compile(r'^[a-z][0-9a-z_]*$')

    @classmethod
    def is_valid_cql3_name(cls, s):
        if s is None:
            return False
        if s.lower() in cls.keywords - cls.unreserved_keywords:
            return False
        return cls.valid_cql3_word_re.match(s) is not None

    @classmethod
    def cql3_maybe_escape_name(cls, name):
        if cls.is_valid_cql3_name(name):
            return name
        return cls.cql3_escape_name(name)

    @classmethod
    def dequote_any(cls, t):
        if t[0] == '"':
            return cls.cql3_dequote_name(t)
        return CqlParsingRuleSet.dequote_any(t)

    dequote_value = cql3_dequote_value
    dequote_name = cql3_dequote_name
    escape_value = cql3_escape_value
    escape_name = cql3_escape_name
    maybe_escape_name = cql3_maybe_escape_name

CqlRuleSet = Cql3ParsingRuleSet()

# convenience for remainder of module
shorthands = ('completer_for', 'explain_completion',
              'dequote_value', 'dequote_name',
              'escape_value', 'escape_name',
              'maybe_escape_name')

for shorthand in shorthands:
    globals()[shorthand] = getattr(CqlRuleSet, shorthand)



# BEGIN SYNTAX/COMPLETION RULE DEFINITIONS

syntax_rules = r'''
<Start> ::= <CQL_Statement>*
          ;

<CQL_Statement> ::= [statements]=<statementBody> ";"
                  ;

# the order of these terminal productions is significant:
<endline> ::= /\n/ ;

JUNK ::= /([ \t\r\f\v]+|(--|[/][/])[^\n\r]*([\n\r]|$)|[/][*].*?[*][/])/ ;

<stringLiteral> ::= /'([^']|'')*'/ ;
<quotedName> ::=    /"([^"]|"")*"/ ;
<float> ::=         /-?[0-9]+\.[0-9]+/ ;
<wholenumber> ::=   /[0-9]+/ ;
<uuid> ::=          /[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/ ;
<identifier> ::=    /[a-z][a-z0-9_]*/ ;
<colon> ::=         ":" ;
<star> ::=          "*" ;
<endtoken> ::=      ";" ;
<op> ::=            /[-+=,().]/ ;
<cmp> ::=           /[<>]=?/ ;
<brackets> ::=      /[][{}]/ ;

<integer> ::= "-"? <wholenumber> ;
<boolean> ::= "true"
            | "false"
            ;

<unclosedString>  ::= /'([^']|'')*/ ;
<unclosedName>    ::= /"([^"]|"")*/ ;
<unclosedComment> ::= /[/][*][^\n]*$/ ;

<term> ::= <stringLiteral>
         | <integer>
         | <float>
         | <uuid>
         | <boolean>
         ;

<tokenDefinition> ::= token="TOKEN" "(" <term> ( "," <term> )* ")"
                    | <stringLiteral>
                    ;
<value> ::= <term>
          | <collectionLiteral>
          ;
<cident> ::= <quotedName>
           | <identifier>
           | <unreservedKeyword>
           ;
<colname> ::= <cident> ;   # just an alias

<collectionLiteral> ::= <listLiteral>
                      | <setLiteral>
                      | <mapLiteral>
                      ;
<listLiteral> ::= "[" ( <term> ( "," <term> )* )? "]"
                ;
<setLiteral> ::= "{" ( <term> ( "," <term> )* )? "}"
               ;
<mapLiteral> ::= "{" <term> ":" <term> ( "," <term> ":" <term> )* "}"
               ;

<statementBody> ::= <useStatement>
                  | <selectStatement>
                  | <dataChangeStatement>
                  | <schemaChangeStatement>
                  | <authenticationStatement>
                  | <authorizationStatement>
                  ;

<dataChangeStatement> ::= <insertStatement>
                        | <updateStatement>
                        | <deleteStatement>
                        | <truncateStatement>
                        | <batchStatement>
                        ;

<schemaChangeStatement> ::= <createKeyspaceStatement>
                          | <createColumnFamilyStatement>
                          | <createIndexStatement>
                          | <dropKeyspaceStatement>
                          | <dropColumnFamilyStatement>
                          | <dropIndexStatement>
                          | <alterTableStatement>
                          | <alterKeyspaceStatement>
                          ;

<authenticationStatement> ::= <createUserStatement>
                            | <alterUserStatement>
                            | <dropUserStatement>
                            | <listUsersStatement>
                            ;

<authorizationStatement> ::= <grantStatement>
                           | <revokeStatement>
                           | <listPermissionsStatement>
                           ;

# timestamp is included here, since it's also a keyword
<simpleStorageType> ::= typename=( <identifier> | <stringLiteral> | <K_TIMESTAMP> ) ;

<storageType> ::= <simpleStorageType> | <collectionType> ;

<collectionType> ::= "map" "<" <simpleStorageType> "," <simpleStorageType> ">"
                   | "list" "<" <simpleStorageType> ">"
                   | "set" "<" <simpleStorageType> ">"
                   ;

<columnFamilyName> ::= ( ksname=<cfOrKsName> dot="." )? cfname=<cfOrKsName> ;

<keyspaceName> ::= ksname=<cfOrKsName> ;

<nonSystemKeyspaceName> ::= ksname=<cfOrKsName> ;

<alterableKeyspaceName> ::= ksname=<cfOrKsName> ;

<cfOrKsName> ::= <identifier>
               | <quotedName>
               | <unreservedKeyword>;

<unreservedKeyword> ::= nocomplete=
                        ( <K_KEY>
                        | <K_CLUSTERING>
                        # | <K_COUNT>  -- to get count(*) completion, treat count as reserved
                        | <K_TTL>
                        | <K_COMPACT>
                        | <K_STORAGE>
                        | <K_TYPE>
                        | <K_VALUES> )
                      ;

# <property> will be defined once cqlsh determines whether we're using
# 3.0.0-beta1 or later. :/

<newPropSpec> ::= [propname]=<cident> propeq="=" [propval]=<propertyValue>
                ;
<propertyValue> ::= propsimpleval=( <stringLiteral>
                                  | <identifier>
                                  | <integer>
                                  | <float>
                                  | <unreservedKeyword> )
                    # we don't use <mapLiteral> here so we can get more targeted
                    # completions:
                    | propsimpleval="{" [propmapkey]=<term> ":" [propmapval]=<term>
                            ( ender="," [propmapkey]=<term> ":" [propmapval]=<term> )*
                      ender="}"
                    ;

<oldPropSpec> ::= [propname]=<optionName> propeq="=" [optval]=<optionVal>
                ;
<optionName> ::= optname=<cident> ( optsep=":" subopt=( <cident> | <wholenumber> ) )?
               ;
<optionVal> ::= <identifier>
              | <stringLiteral>
              | <integer>
              | <float>
              ;
'''

def use_pre_3_0_0_syntax():
    # cassandra-1.1 support
    CqlRuleSet.append_rules('''
        <property> ::= <oldPropSpec> ;
    ''')
    CqlRuleSet.columnfamily_layout_map_options = \
            CqlRuleSet.old_columnfamily_layout_map_options
    CqlRuleSet.columnfamily_layout_options = \
            CqlRuleSet.old_columnfamily_layout_options

def use_post_3_0_0_syntax():
    CqlRuleSet.append_rules('''
        <property> ::= <newPropSpec> ;
    ''')
    CqlRuleSet.columnfamily_layout_map_options = \
            CqlRuleSet.new_columnfamily_layout_map_options
    CqlRuleSet.columnfamily_layout_options = \
            CqlRuleSet.new_columnfamily_layout_options
    CqlRuleSet.obsolete_cf_options += CqlRuleSet.new_obsolete_cf_options

def prop_equals_completer(ctxt, cass):
    if not working_on_keyspace(ctxt):
        # we know if the thing in the property name position is "compact" or
        # "clustering" that there won't actually be an equals sign, because
        # there are no properties by those names. there are, on the other hand,
        # table properties that start with those keywords which don't have
        # equals signs at all.
        curprop = ctxt.get_binding('propname')[-1].upper()
        if curprop in ('COMPACT', 'CLUSTERING'):
            return ()
    return ['=']

completer_for('oldPropSpec', 'propeq')(prop_equals_completer)
completer_for('newPropSpec', 'propeq')(prop_equals_completer)

@completer_for('newPropSpec', 'propname')
def new_prop_name_completer(ctxt, cass):
    if working_on_keyspace(ctxt):
        return ks_new_prop_name_completer(ctxt, cass)
    else:
        return cf_new_prop_name_completer(ctxt, cass)

@completer_for('propertyValue', 'propsimpleval')
def new_prop_val_completer(ctxt, cass):
    if working_on_keyspace(ctxt):
        return ks_new_prop_val_completer(ctxt, cass)
    else:
        return cf_new_prop_val_completer(ctxt, cass)

@completer_for('propertyValue', 'propmapkey')
def new_prop_val_mapkey_completer(ctxt, cass):
    if working_on_keyspace(ctxt):
        return ks_new_prop_val_mapkey_completer(ctxt, cass)
    else:
        return cf_new_prop_val_mapkey_completer(ctxt, cass)

@completer_for('propertyValue', 'propmapval')
def new_prop_val_mapval_completer(ctxt, cass):
    if working_on_keyspace(ctxt):
        return ks_new_prop_val_mapval_completer(ctxt, cass)
    else:
        return cf_new_prop_val_mapval_completer(ctxt, cass)

@completer_for('propertyValue', 'ender')
def new_prop_val_mapender_completer(ctxt, cass):
    if working_on_keyspace(ctxt):
        return ks_new_prop_val_mapender_completer(ctxt, cass)
    else:
        return cf_new_prop_val_mapender_completer(ctxt, cass)

def ks_new_prop_name_completer(ctxt, cass):
    optsseen = ctxt.get_binding('propname', ())
    if 'replication' not in optsseen:
        return ['replication']
    return ["durable_writes"]

def ks_new_prop_val_completer(ctxt, cass):
    optname = ctxt.get_binding('propname')[-1]
    if optname == 'durable_writes':
        return ["'true'", "'false'"]
    if optname == 'replication':
        return ["{'class': '"]
    return ()

def ks_new_prop_val_mapkey_completer(ctxt, cass):
    optname = ctxt.get_binding('propname')[-1]
    if optname != 'replication':
        return ()
    keysseen = map(dequote_value, ctxt.get_binding('propmapkey', ()))
    valsseen = map(dequote_value, ctxt.get_binding('propmapval', ()))
    for k, v in zip(keysseen, valsseen):
        if k == 'class':
            repclass = v
            break
    else:
        return ["'class'"]
    if repclass in CqlRuleSet.replication_factor_strategies:
        opts = set(('replication_factor',))
    elif repclass == 'NetworkTopologyStrategy':
        return [Hint('<dc_name>')]
    return map(escape_value, opts.difference(keysseen))

def ks_new_prop_val_mapval_completer(ctxt, cass):
    optname = ctxt.get_binding('propname')[-1]
    if optname != 'replication':
        return ()
    currentkey = dequote_value(ctxt.get_binding('propmapkey')[-1])
    if currentkey == 'class':
        return map(escape_value, CqlRuleSet.replication_strategies)
    return [Hint('<value>')]

def ks_new_prop_val_mapender_completer(ctxt, cass):
    optname = ctxt.get_binding('propname')[-1]
    if optname != 'replication':
        return [',']
    keysseen = map(dequote_value, ctxt.get_binding('propmapkey', ()))
    valsseen = map(dequote_value, ctxt.get_binding('propmapval', ()))
    for k, v in zip(keysseen, valsseen):
        if k == 'class':
            repclass = v
            break
    else:
        return [',']
    if repclass in CqlRuleSet.replication_factor_strategies:
        if 'replication_factor' not in keysseen:
            return [',']
    if repclass == 'NetworkTopologyStrategy' and len(keysseen) == 1:
        return [',']
    return ['}']

def cf_new_prop_name_completer(ctxt, cass):
    return [c[0] for c in (CqlRuleSet.columnfamily_layout_options +
                           CqlRuleSet.columnfamily_layout_map_options)]

def cf_new_prop_val_completer(ctxt, cass):
    exist_opts = ctxt.get_binding('propname')
    this_opt = exist_opts[-1]
    if this_opt == 'compression':
        return ["{'sstable_compression': '"]
    if this_opt == 'compaction':
        return ["{'class': '"]
    if any(this_opt == opt[0] for opt in CqlRuleSet.obsolete_cf_options):
        return ["'<obsolete_option>'"]
    if this_opt in ('read_repair_chance', 'bloom_filter_fp_chance',
                    'dclocal_read_repair_chance'):
        return [Hint('<float_between_0_and_1>')]
    if this_opt in ('replicate_on_write', 'populate_io_cache_on_flush'):
        return ["'yes'", "'no'"]
    if this_opt in ('min_compaction_threshold', 'max_compaction_threshold',
                    'gc_grace_seconds', 'index_interval'):
        return [Hint('<integer>')]
    if this_opt == 'default_read_consistency':
        return [cl for cl in CqlRuleSet.consistency_levels if cl != 'ANY']
    if this_opt == 'default_write_consistency':
        return CqlRuleSet.consistency_levels
    return [Hint('<option_value>')]

def cf_new_prop_val_mapkey_completer(ctxt, cass):
    optname = ctxt.get_binding('propname')[-1]
    for cql3option, _, subopts in CqlRuleSet.columnfamily_layout_map_options:
        if optname == cql3option:
            break
    else:
        return ()
    keysseen = map(dequote_value, ctxt.get_binding('propmapkey', ()))
    valsseen = map(dequote_value, ctxt.get_binding('propmapval', ()))
    pairsseen = dict(zip(keysseen, valsseen))
    if optname == 'compression':
        return map(escape_value, set(subopts).difference(keysseen))
    if optname == 'compaction':
        opts = set(subopts)
        try:
            csc = pairsseen['class']
        except KeyError:
            return ["'class'"]
        csc = csc.split('.')[-1]
        if csc == 'SizeTieredCompactionStrategy':
            opts.add('min_sstable_size')
        elif csc == 'LeveledCompactionStrategy':
            opts.add('sstable_size_in_mb')
        return map(escape_value, opts)
    return ()

def cf_new_prop_val_mapval_completer(ctxt, cass):
    opt = ctxt.get_binding('propname')[-1]
    key = dequote_value(ctxt.get_binding('propmapkey')[-1])
    if opt == 'compaction':
        if key == 'class':
            return map(escape_value, CqlRuleSet.available_compaction_classes)
        return [Hint('<option_value>')]
    elif opt == 'compression':
        if key == 'sstable_compression':
            return map(escape_value, CqlRuleSet.available_compression_classes)
        return [Hint('<option_value>')]
    return ()

def cf_new_prop_val_mapender_completer(ctxt, cass):
    return [',', '}']

@completer_for('optionName', 'optname')
def old_prop_name_completer(ctxt, cass):
    if working_on_keyspace(ctxt):
        return ks_old_prop_name_completer(ctxt, cass)
    else:
        return cf_old_prop_name_completer(ctxt, cass)

@completer_for('oldPropSpec', 'optval')
def old_prop_val_completer(ctxt, cass):
    if working_on_keyspace(ctxt):
        return ks_old_prop_val_completer(ctxt, cass)
    else:
        return cf_old_prop_val_completer(ctxt, cass)

@completer_for('optionName', 'optsep')
def old_prop_separator_completer(ctxt, cass):
    if working_on_keyspace(ctxt):
        return ks_old_prop_separator_completer(ctxt, cass)
    else:
        return cf_old_prop_separator_completer(ctxt, cass)

@completer_for('optionName', 'subopt')
def old_prop_suboption_completer(ctxt, cass):
    if working_on_keyspace(ctxt):
        return ks_old_prop_suboption_completer(ctxt, cass)
    else:
        return cf_old_prop_suboption_completer(ctxt, cass)

def ks_old_prop_name_completer(ctxt, cass):
    exist_opts = ctxt.get_binding('optname', ())
    try:
        stratopt = exist_opts.index('strategy_class')
    except ValueError:
        return ['strategy_class =']
    vals = ctxt.get_binding('optval')
    stratclass = dequote_value(vals[stratopt])
    if stratclass in CqlRuleSet.replication_factor_strategies:
        return ['strategy_options:replication_factor =']
    return [Hint('<strategy_option_name>')]

def ks_old_prop_val_completer(ctxt, cass):
    exist_opts = ctxt.get_binding('optname', (None,))
    if exist_opts[-1] == 'strategy_class':
        return map(escape_value, CqlRuleSet.replication_strategies)
    return [Hint('<option_value>')]

def ks_old_prop_separator_completer(ctxt, cass):
    curopt = ctxt.get_binding('optname')[-1]
    if curopt == 'strategy_options':
        return [':']
    return ()

def ks_old_prop_suboption_completer(ctxt, cass):
    exist_opts = ctxt.get_binding('optname')
    if exist_opts[-1] != 'strategy_options':
        return ()
    try:
        stratopt = exist_opts.index('strategy_class')
    except ValueError:
        return ()
    vals = ctxt.get_binding('optval')
    stratclass = dequote_value(vals[stratopt])
    if stratclass in CqlRuleSet.replication_factor_strategies:
        return ['replication_factor =']
    return [Hint('<dc_name>')]

def cf_old_prop_name_completer(ctxt, cass):
    return list(CqlRuleSet.columnfamily_layout_options) + \
           [c[0] + ':' for c in CqlRuleSet.columnfamily_layout_map_options]

def cf_old_prop_val_completer(ctxt, cass):
    exist_opts = ctxt.get_binding('propname')
    this_opt = exist_opts[-1]
    if this_opt == 'compression_parameters:sstable_compression':
        return map(escape_value, CqlRuleSet.available_compression_classes)
    if this_opt == 'compaction_strategy_class':
        return map(escape_value, CqlRuleSet.available_compaction_classes)
    if any(this_opt == opt[0] for opt in CqlRuleSet.obsolete_cf_options):
        return ["'<obsolete_option>'"]
    if this_opt in ('comparator', 'default_validation'):
        return simple_cql_types
    if this_opt in ('read_repair_chance', 'bloom_filter_fp_chance'):
        return [Hint('<float_between_0_and_1>')]
    if this_opt in ('replicate_on_write', 'populate_io_cache_on_flush'):
        return [Hint('<yes_or_no>')]
    if this_opt in ('min_compaction_threshold', 'max_compaction_threshold', 'gc_grace_seconds'):
        return [Hint('<integer>')]
    return [Hint('<option_value>')]

def cf_old_prop_separator_completer(ctxt, cass):
    opt = ctxt.get_binding('optname')
    if any(opt == c[0] for c in CqlRuleSet.columnfamily_layout_map_options):
        return [':']
    return ()

def cf_old_prop_suboption_completer(ctxt, cass):
    opt = ctxt.get_binding('optname')
    if opt == 'compaction_strategy_options':
        # try to determine the strategy class in use
        prevopts = ctxt.get_binding('propname', ())
        prevvals = ctxt.get_binding('optval', ())
        for prevopt, prevval in zip(prevopts, prevvals):
            if prevopt == 'compaction_strategy_class':
                csc = dequote_value(prevval)
                break
        else:
            layout = get_cf_layout(ctxt, cass)
            try:
                csc = layout.compaction_strategy
            except Exception:
                csc = ''
        csc = csc.split('.')[-1]
        if csc == 'SizeTieredCompactionStrategy':
            return ['min_sstable_size']
        elif csc == 'LeveledCompactionStrategy':
            return ['sstable_size_in_mb']
    for optname, _, subopts in CqlRuleSet.columnfamily_layout_map_options:
        if opt == optname:
            return subopts
    return ()

@completer_for('tokenDefinition', 'token')
def token_word_completer(ctxt, cass):
    return ['TOKEN(']

@completer_for('simpleStorageType', 'typename')
def storagetype_completer(ctxt, cass):
    return simple_cql_types

@completer_for('keyspaceName', 'ksname')
def ks_name_completer(ctxt, cass):
    return map(maybe_escape_name, cass.get_keyspace_names())

@completer_for('nonSystemKeyspaceName', 'ksname')
def ks_name_completer(ctxt, cass):
    ksnames = [n for n in cass.get_keyspace_names() if n not in SYSTEM_KEYSPACES]
    return map(maybe_escape_name, ksnames)

@completer_for('alterableKeyspaceName', 'ksname')
def ks_name_completer(ctxt, cass):
    ksnames = [n for n in cass.get_keyspace_names() if n not in NONALTERBALE_KEYSPACES]
    return map(maybe_escape_name, ksnames)

@completer_for('columnFamilyName', 'ksname')
def cf_ks_name_completer(ctxt, cass):
    return [maybe_escape_name(ks) + '.' for ks in cass.get_keyspace_names()]

@completer_for('columnFamilyName', 'dot')
def cf_ks_dot_completer(ctxt, cass):
    name = dequote_name(ctxt.get_binding('ksname'))
    if name in cass.get_keyspace_names():
        return ['.']
    return []

@completer_for('columnFamilyName', 'cfname')
def cf_name_completer(ctxt, cass):
    ks = ctxt.get_binding('ksname', None)
    if ks is not None:
        ks = dequote_name(ks)
    try:
        cfnames = cass.get_columnfamily_names(ks)
    except Exception:
        if ks is None:
            return ()
        raise
    return map(maybe_escape_name, cfnames)

@completer_for('unreservedKeyword', 'nocomplete')
def unreserved_keyword_completer(ctxt, cass):
    # we never want to provide completions through this production;
    # this is always just to allow use of some keywords as column
    # names, CF names, property values, etc.
    return ()

def get_cf_layout(ctxt, cass):
    ks = ctxt.get_binding('ksname', None)
    if ks is not None:
        ks = dequote_name(ks)
    cf = dequote_name(ctxt.get_binding('cfname'))
    return cass.get_columnfamily_layout(ks, cf)

def working_on_keyspace(ctxt):
    wat = ctxt.get_binding('wat').upper()
    if wat in ('KEYSPACE', 'SCHEMA'):
        return True
    return False

syntax_rules += r'''
<useStatement> ::= "USE" <keyspaceName>
                 ;
<selectStatement> ::= "SELECT" <selectClause>
                        "FROM" cf=<columnFamilyName>
                          ("WHERE" <whereClause>)?
                          ("ORDER" "BY" <orderByClause> ( "," <orderByClause> )* )?
                          ("LIMIT" limit=<wholenumber>)?
                    ;