mirror of https://github.com/apache/cassandra
1164 lines
42 KiB
Python
1164 lines
42 KiB
Python
# 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.
|
|
|
|
from .cqlhandling import CqlParsingRuleSet, Hint
|
|
from cassandra.metadata import maybe_escape_name
|
|
from cassandra.metadata import escape_name
|
|
|
|
|
|
simple_cql_types = set(('ascii', 'bigint', 'blob', 'boolean', 'counter', 'decimal', 'double', 'float', 'inet', 'int',
|
|
'text', 'timestamp', 'timeuuid', 'uuid', 'varchar', 'varint'))
|
|
simple_cql_types.difference_update(('set', 'map', 'list'))
|
|
|
|
from . import helptopics
|
|
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')
|
|
|
|
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', 'custom', 'if', 'not'
|
|
))
|
|
|
|
unreserved_keywords = set((
|
|
'key', 'clustering', 'ttl', 'compact', 'storage', 'type', 'values', 'custom', 'exists'
|
|
))
|
|
|
|
columnfamily_layout_options = (
|
|
('bloom_filter_fp_chance', None),
|
|
('comment', None),
|
|
('dclocal_read_repair_chance', 'local_read_repair_chance'),
|
|
('gc_grace_seconds', None),
|
|
('min_index_interval', None),
|
|
('max_index_interval', None),
|
|
('read_repair_chance', None),
|
|
('populate_io_cache_on_flush', None),
|
|
('default_time_to_live', None),
|
|
('speculative_retry', None),
|
|
('memtable_flush_period_in_ms', None),
|
|
)
|
|
|
|
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', 'max_threshold', 'tombstone_compaction_interval', 'tombstone_threshold', 'enabled')),
|
|
('compression', 'compression_parameters',
|
|
('sstable_compression', 'chunk_length_kb', 'crc_check_chance')),
|
|
('caching', None,
|
|
('rows_per_partition', 'keys')),
|
|
)
|
|
|
|
obsolete_cf_options = ()
|
|
|
|
consistency_levels = (
|
|
'ANY',
|
|
'ONE',
|
|
'TWO',
|
|
'THREE',
|
|
'QUORUM',
|
|
'ALL',
|
|
'LOCAL_QUORUM',
|
|
'EACH_QUORUM',
|
|
'SERIAL'
|
|
)
|
|
|
|
maybe_escape_name = staticmethod(maybe_escape_name)
|
|
|
|
escape_name = staticmethod(escape_name)
|
|
|
|
@classmethod
|
|
def escape_value(cls, value):
|
|
if value is None:
|
|
return 'NULL' # this totally won't work
|
|
if isinstance(value, bool):
|
|
value = str(value).lower()
|
|
elif isinstance(value, float):
|
|
return '%f' % value
|
|
elif isinstance(value, int):
|
|
return str(value)
|
|
return "'%s'" % value.replace("'", "''")
|
|
|
|
@staticmethod
|
|
def dequote_name(name):
|
|
name = name.strip()
|
|
if name == '':
|
|
return name
|
|
if name[0] == '"' and name[-1] == '"':
|
|
name = name[1:-1].replace('""', '"')
|
|
return name
|
|
|
|
@staticmethod
|
|
def dequote_value(cqlword):
|
|
cqlword = cqlword.strip()
|
|
if cqlword == '':
|
|
return cqlword
|
|
if cqlword[0] == "'" and cqlword[-1] == "'":
|
|
cqlword = cqlword[1:-1].replace("''", "'")
|
|
return cqlword
|
|
|
|
CqlRuleSet = Cql3ParsingRuleSet()
|
|
|
|
# convenience for remainder of module
|
|
shorthands = ('completer_for', 'explain_completion',
|
|
'dequote_value', 'dequote_name',
|
|
'escape_value',
|
|
'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]+/ ;
|
|
<uuid> ::= /[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/ ;
|
|
<blobLiteral> ::= /0x[0-9a-f]+/ ;
|
|
<wholenumber> ::= /[0-9]+/ ;
|
|
<identifier> ::= /[a-z][a-z0-9_]*/ ;
|
|
<colon> ::= ":" ;
|
|
<star> ::= "*" ;
|
|
<endtoken> ::= ";" ;
|
|
<op> ::= /[-+=,().]/ ;
|
|
<cmp> ::= /[<>]=?/ ;
|
|
<brackets> ::= /[][{}]/ ;
|
|
|
|
<integer> ::= "-"? <wholenumber> ;
|
|
<boolean> ::= "true"
|
|
| "false"
|
|
;
|
|
|
|
<unclosedString> ::= /'([^']|'')*/ ;
|
|
<unclosedName> ::= /"([^"]|"")*/ ;
|
|
<unclosedComment> ::= /[/][*].*$/ ;
|
|
|
|
<term> ::= <stringLiteral>
|
|
| <integer>
|
|
| <float>
|
|
| <uuid>
|
|
| <boolean>
|
|
| <blobLiteral>
|
|
| <functionName> <functionArguments>
|
|
;
|
|
|
|
<functionArguments> ::= "(" ( <term> ( "," <term> )* )? ")"
|
|
;
|
|
|
|
<tokenDefinition> ::= token="TOKEN" "(" <term> ( "," <term> )* ")"
|
|
| <term>
|
|
;
|
|
<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> )* "}"
|
|
;
|
|
|
|
<functionName> ::= <identifier>
|
|
;
|
|
|
|
<statementBody> ::= <useStatement>
|
|
| <selectStatement>
|
|
| <dataChangeStatement>
|
|
| <schemaChangeStatement>
|
|
| <authenticationStatement>
|
|
| <authorizationStatement>
|
|
;
|
|
|
|
<dataChangeStatement> ::= <insertStatement>
|
|
| <updateStatement>
|
|
| <deleteStatement>
|
|
| <truncateStatement>
|
|
| <batchStatement>
|
|
;
|
|
|
|
<schemaChangeStatement> ::= <createKeyspaceStatement>
|
|
| <createColumnFamilyStatement>
|
|
| <createIndexStatement>
|
|
| <createUserTypeStatement>
|
|
| <dropKeyspaceStatement>
|
|
| <dropColumnFamilyStatement>
|
|
| <dropIndexStatement>
|
|
| <dropUserTypeStatement>
|
|
| <alterTableStatement>
|
|
| <alterKeyspaceStatement>
|
|
| <alterUserTypeStatement>
|
|
;
|
|
|
|
<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> ) ;
|
|
|
|
<userType> ::= utname=<cfOrKsName> ;
|
|
|
|
<storageType> ::= <simpleStorageType> | <collectionType> | <userType> ;
|
|
|
|
<collectionType> ::= "map" "<" <simpleStorageType> "," ( <simpleStorageType> | <userType> ) ">"
|
|
| "list" "<" ( <simpleStorageType> | <userType> ) ">"
|
|
| "set" "<" ( <simpleStorageType> | <userType> ) ">"
|
|
;
|
|
|
|
<columnFamilyName> ::= ( ksname=<cfOrKsName> dot="." )? cfname=<cfOrKsName> ;
|
|
|
|
<userTypeName> ::= ( ksname=<cfOrKsName> dot="." )? utname=<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> ::= [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="}"
|
|
;
|
|
|
|
'''
|
|
|
|
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('property', 'propeq')(prop_equals_completer)
|
|
|
|
@completer_for('property', 'propname')
|
|
def prop_name_completer(ctxt, cass):
|
|
if working_on_keyspace(ctxt):
|
|
return ks_prop_name_completer(ctxt, cass)
|
|
else:
|
|
return cf_prop_name_completer(ctxt, cass)
|
|
|
|
@completer_for('propertyValue', 'propsimpleval')
|
|
def prop_val_completer(ctxt, cass):
|
|
if working_on_keyspace(ctxt):
|
|
return ks_prop_val_completer(ctxt, cass)
|
|
else:
|
|
return cf_prop_val_completer(ctxt, cass)
|
|
|
|
@completer_for('propertyValue', 'propmapkey')
|
|
def prop_val_mapkey_completer(ctxt, cass):
|
|
if working_on_keyspace(ctxt):
|
|
return ks_prop_val_mapkey_completer(ctxt, cass)
|
|
else:
|
|
return cf_prop_val_mapkey_completer(ctxt, cass)
|
|
|
|
@completer_for('propertyValue', 'propmapval')
|
|
def prop_val_mapval_completer(ctxt, cass):
|
|
if working_on_keyspace(ctxt):
|
|
return ks_prop_val_mapval_completer(ctxt, cass)
|
|
else:
|
|
return cf_prop_val_mapval_completer(ctxt, cass)
|
|
|
|
@completer_for('propertyValue', 'ender')
|
|
def prop_val_mapender_completer(ctxt, cass):
|
|
if working_on_keyspace(ctxt):
|
|
return ks_prop_val_mapender_completer(ctxt, cass)
|
|
else:
|
|
return cf_prop_val_mapender_completer(ctxt, cass)
|
|
|
|
def ks_prop_name_completer(ctxt, cass):
|
|
optsseen = ctxt.get_binding('propname', ())
|
|
if 'replication' not in optsseen:
|
|
return ['replication']
|
|
return ["durable_writes"]
|
|
|
|
def ks_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_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_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_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_prop_name_completer(ctxt, cass):
|
|
return [c[0] for c in (CqlRuleSet.columnfamily_layout_options +
|
|
CqlRuleSet.columnfamily_layout_map_options)]
|
|
|
|
def cf_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 this_opt == 'caching':
|
|
return ["{'keys': '"]
|
|
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', 'min_index_interval', 'max_index_interval'):
|
|
return [Hint('<integer>')]
|
|
return [Hint('<option_value>')]
|
|
|
|
def cf_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 == 'caching':
|
|
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')
|
|
opts.add('min_threshold')
|
|
opts.add('bucket_high')
|
|
opts.add('bucket_low')
|
|
opts.add('cold_reads_to_omit')
|
|
elif csc == 'LeveledCompactionStrategy':
|
|
opts.add('sstable_size_in_mb')
|
|
return map(escape_value, opts)
|
|
return ()
|
|
|
|
def cf_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>')]
|
|
elif opt == 'caching':
|
|
if key == 'rows_per_partition':
|
|
return ["'ALL'", "'NONE'", Hint('#rows_per_partition')]
|
|
elif key == 'keys':
|
|
return ["'ALL'", "'NONE'"]
|
|
return ()
|
|
|
|
def cf_prop_val_mapender_completer(ctxt, cass):
|
|
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)
|
|
|
|
def cf_ks_name_completer(ctxt, cass):
|
|
return [maybe_escape_name(ks) + '.' for ks in cass.get_keyspace_names()]
|
|
|
|
completer_for('columnFamilyName', 'ksname')(cf_ks_name_completer)
|
|
|
|
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', 'dot')(cf_ks_dot_completer)
|
|
|
|
@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('userTypeName', 'ksname')(cf_ks_name_completer)
|
|
|
|
completer_for('userTypeName', 'dot')(cf_ks_dot_completer)
|
|
|
|
def ut_name_completer(ctxt, cass):
|
|
ks = ctxt.get_binding('ksname', None)
|
|
if ks is not None:
|
|
ks = dequote_name(ks)
|
|
try:
|
|
utnames = cass.get_usertype_names(ks)
|
|
except Exception:
|
|
if ks is None:
|
|
return ()
|
|
raise
|
|
return map(maybe_escape_name, utnames)
|
|
|
|
|
|
completer_for('userTypeName', 'utname')(ut_name_completer)
|
|
completer_for('userType', 'utname')(ut_name_completer)
|
|
|
|
@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_table_meta(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_table_meta(ks, cf)
|
|
|
|
def get_ut_layout(ctxt, cass):
|
|
ks = ctxt.get_binding('ksname', None)
|
|
if ks is not None:
|
|
ks = dequote_name(ks)
|
|
ut = dequote_name(ctxt.get_binding('utname'))
|
|
return cass.get_usertype_layout(ks, ut)
|
|
|
|
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> )?
|
|
;
|
|
<whereClause> ::= <relation> ( "AND" <relation> )*
|
|
;
|
|
<relation> ::= [rel_lhs]=<cident> ( "=" | "<" | ">" | "<=" | ">=" ) <term>
|
|
| token="TOKEN" "(" [rel_tokname]=<cident>
|
|
( "," [rel_tokname]=<cident> )*
|
|
")" ("=" | "<" | ">" | "<=" | ">=") <tokenDefinition>
|
|
| [rel_lhs]=<cident> "IN" "(" <term> ( "," <term> )* ")"
|
|
;
|
|
<selectClause> ::= "DISTINCT"? <selector> ("AS" <cident>)? ("," <selector> ("AS" <cident>)?)*
|
|
| "*"
|
|
| "COUNT" "(" star=( "*" | "1" ) ")" ("AS" <cident>)?
|
|
;
|
|
<selector> ::= [colname]=<cident>
|
|
| "WRITETIME" "(" [colname]=<cident> ")"
|
|
| "TTL" "(" [colname]=<cident> ")"
|
|
| <functionName> <selectionFunctionArguments>
|
|
;
|
|
<selectionFunctionArguments> ::= "(" ( <selector> ( "," <selector> )* )? ")"
|
|
;
|
|
<orderByClause> ::= [ordercol]=<cident> ( "ASC" | "DESC" )?
|
|
;
|
|
'''
|
|
|
|
@completer_for('orderByClause', 'ordercol')
|
|
def select_order_column_completer(ctxt, cass):
|
|
prev_order_cols = ctxt.get_binding('ordercol', ())
|
|
keyname = ctxt.get_binding('keyname')
|
|
if keyname is None:
|
|
keyname = ctxt.get_binding('rel_lhs', ())
|
|
if not keyname:
|
|
return [Hint("Can't ORDER BY here: need to specify partition key in WHERE clause")]
|
|
layout = get_table_meta(ctxt, cass)
|
|
order_by_candidates = [col.name for col in layout.clustering_key]
|
|
if len(order_by_candidates) > len(prev_order_cols):
|
|
return [maybe_escape_name(order_by_candidates[len(prev_order_cols)])]
|
|
return [Hint('No more orderable columns here.')]
|
|
|
|
@completer_for('relation', 'token')
|
|
def relation_token_word_completer(ctxt, cass):
|
|
return ['TOKEN(']
|
|
|
|
@completer_for('relation', 'rel_tokname')
|
|
def relation_token_subject_completer(ctxt, cass):
|
|
layout = get_table_meta(ctxt, cass)
|
|
return [key.name for key in layout.partition_key]
|
|
|
|
@completer_for('relation', 'rel_lhs')
|
|
def select_relation_lhs_completer(ctxt, cass):
|
|
layout = get_table_meta(ctxt, cass)
|
|
filterable = set((layout.partition_key[0].name, layout.clustering_key[0].name))
|
|
already_filtered_on = map(dequote_name, ctxt.get_binding('rel_lhs', ()))
|
|
for num in range(1, len(layout.partition_key)):
|
|
if layout.partition_key[num - 1].name in already_filtered_on:
|
|
filterable.add(layout.partition_key[num].name)
|
|
else:
|
|
break
|
|
for num in range(1, len(layout.clustering_key)):
|
|
if layout.clustering_key[num - 1].name in already_filtered_on:
|
|
filterable.add(layout.clustering_key[num].name)
|
|
else:
|
|
break
|
|
for cd in layout.columns.values():
|
|
if cd.index:
|
|
filterable.add(cd.name)
|
|
return map(maybe_escape_name, filterable)
|
|
|
|
@completer_for('selectClause', 'star')
|
|
def select_count_star_completer(ctxt, cass):
|
|
return ['*']
|
|
|
|
explain_completion('selector', 'colname')
|
|
|
|
syntax_rules += r'''
|
|
<insertStatement> ::= "INSERT" "INTO" cf=<columnFamilyName>
|
|
"(" [colname]=<cident> "," [colname]=<cident>
|
|
( "," [colname]=<cident> )* ")"
|
|
"VALUES" "(" [newval]=<value> valcomma="," [newval]=<value>
|
|
( valcomma="," [newval]=<value> )* valcomma=")"
|
|
( "USING" [insertopt]=<usingOption>
|
|
( "AND" [insertopt]=<usingOption> )* )?
|
|
;
|
|
<usingOption> ::= "TIMESTAMP" <wholenumber>
|
|
| "TTL" <wholenumber>
|
|
;
|
|
'''
|
|
|
|
def regular_column_names(table_meta):
|
|
if not table_meta or not table_meta.columns:
|
|
return []
|
|
regular_coulmns = list(set(table_meta.columns.keys())
|
|
- set([key.name for key in table_meta.partition_key])
|
|
- set([key.name for key in table_meta.clustering_key]))
|
|
return regular_coulmns
|
|
|
|
@completer_for('insertStatement', 'colname')
|
|
def insert_colname_completer(ctxt, cass):
|
|
layout = get_table_meta(ctxt, cass)
|
|
colnames = set(map(dequote_name, ctxt.get_binding('colname', ())))
|
|
keycols = layout.primary_key
|
|
for k in keycols:
|
|
if k.name not in colnames:
|
|
return [maybe_escape_name(k.name)]
|
|
normalcols = set(regular_column_names(layout)) - colnames
|
|
return map(maybe_escape_name, normalcols)
|
|
|
|
@completer_for('insertStatement', 'newval')
|
|
def insert_newval_completer(ctxt, cass):
|
|
layout = get_table_meta(ctxt, cass)
|
|
insertcols = map(dequote_name, ctxt.get_binding('colname'))
|
|
valuesdone = ctxt.get_binding('newval', ())
|
|
if len(valuesdone) >= len(insertcols):
|
|
return []
|
|
curcol = insertcols[len(valuesdone)]
|
|
cqltype = layout.columns[curcol].data_type
|
|
coltype = cqltype.typename
|
|
if coltype in ('map', 'set'):
|
|
return ['{']
|
|
if coltype == 'list':
|
|
return ['[']
|
|
if coltype == 'boolean':
|
|
return ['true', 'false']
|
|
return [Hint('<value for %s (%s)>' % (maybe_escape_name(curcol),
|
|
cqltype.cql_parameterized_type()))]
|
|
|
|
@completer_for('insertStatement', 'valcomma')
|
|
def insert_valcomma_completer(ctxt, cass):
|
|
layout = get_table_meta(ctxt, cass)
|
|
numcols = len(ctxt.get_binding('colname', ()))
|
|
numvals = len(ctxt.get_binding('newval', ()))
|
|
if numcols > numvals:
|
|
return [',']
|
|
return [')']
|
|
|
|
@completer_for('insertStatement', 'insertopt')
|
|
def insert_option_completer(ctxt, cass):
|
|
opts = set('TIMESTAMP TTL'.split())
|
|
for opt in ctxt.get_binding('insertopt', ()):
|
|
opts.discard(opt.split()[0])
|
|
return opts
|
|
|
|
syntax_rules += r'''
|
|
<updateStatement> ::= "UPDATE" cf=<columnFamilyName>
|
|
( "USING" [updateopt]=<usingOption>
|
|
( "AND" [updateopt]=<usingOption> )* )?
|
|
"SET" <assignment> ( "," <assignment> )*
|
|
"WHERE" <whereClause>
|
|
;
|
|
<assignment> ::= updatecol=<cident>
|
|
( "=" update_rhs=( <value> | <cident> )
|
|
( counterop=( "+" | "-" ) inc=<wholenumber>
|
|
| listadder="+" listcol=<cident> )
|
|
| indexbracket="[" <term> "]" "=" <term> )
|
|
;
|
|
'''
|
|
|
|
@completer_for('updateStatement', 'updateopt')
|
|
def insert_option_completer(ctxt, cass):
|
|
opts = set('TIMESTAMP TTL'.split())
|
|
for opt in ctxt.get_binding('updateopt', ()):
|
|
opts.discard(opt.split()[0])
|
|
return opts
|
|
|
|
@completer_for('assignment', 'updatecol')
|
|
def update_col_completer(ctxt, cass):
|
|
layout = get_table_meta(ctxt, cass)
|
|
return map(maybe_escape_name, regular_column_names(layout))
|
|
|
|
@completer_for('assignment', 'update_rhs')
|
|
def update_countername_completer(ctxt, cass):
|
|
layout = get_table_meta(ctxt, cass)
|
|
curcol = dequote_name(ctxt.get_binding('updatecol', ''))
|
|
cqltype = layout.columns[curcol].data_type
|
|
coltype = cqltype.typename
|
|
if coltype == 'counter':
|
|
return [maybe_escape_name(curcol)]
|
|
if coltype in ('map', 'set'):
|
|
return ["{"]
|
|
if coltype == 'list':
|
|
return ["["]
|
|
return [Hint('<term (%s)>' % cqltype.cql_parameterized_type())]
|
|
|
|
@completer_for('assignment', 'counterop')
|
|
def update_counterop_completer(ctxt, cass):
|
|
layout = get_table_meta(ctxt, cass)
|
|
curcol = dequote_name(ctxt.get_binding('updatecol', ''))
|
|
return ['+', '-'] if layout.columns[curcol].data_type.typename == 'counter' else []
|
|
|
|
@completer_for('assignment', 'inc')
|
|
def update_counter_inc_completer(ctxt, cass):
|
|
layout = get_table_meta(ctxt, cass)
|
|
curcol = dequote_name(ctxt.get_binding('updatecol', ''))
|
|
if layout.columns[curcol].data_type.typename == 'counter':
|
|
return [Hint('<wholenumber>')]
|
|
return []
|
|
|
|
@completer_for('assignment', 'listadder')
|
|
def update_listadder_completer(ctxt, cass):
|
|
rhs = ctxt.get_binding('update_rhs')
|
|
if rhs.startswith('['):
|
|
return ['+']
|
|
return []
|
|
|
|
@completer_for('assignment', 'listcol')
|
|
def update_listcol_completer(ctxt, cass):
|
|
rhs = ctxt.get_binding('update_rhs')
|
|
if rhs.startswith('['):
|
|
colname = dequote_name(ctxt.get_binding('updatecol'))
|
|
return [maybe_escape_name(colname)]
|
|
return []
|
|
|
|
@completer_for('assignment', 'indexbracket')
|
|
def update_indexbracket_completer(ctxt, cass):
|
|
layout = get_table_meta(ctxt, cass)
|
|
curcol = dequote_name(ctxt.get_binding('updatecol', ''))
|
|
coltype = layout.columns[curcol].data_type.typename
|
|
if coltype in ('map', 'list'):
|
|
return ['[']
|
|
return []
|
|
|
|
syntax_rules += r'''
|
|
<deleteStatement> ::= "DELETE" ( <deleteSelector> ( "," <deleteSelector> )* )?
|
|
"FROM" cf=<columnFamilyName>
|
|
( "USING" [delopt]=<deleteOption> )?
|
|
"WHERE" <whereClause>
|
|
;
|
|
<deleteSelector> ::= delcol=<cident> ( memberbracket="[" memberselector=<term> "]" )?
|
|
;
|
|
<deleteOption> ::= "TIMESTAMP" <wholenumber>
|
|
;
|
|
'''
|
|
|
|
@completer_for('deleteStatement', 'delopt')
|
|
def delete_opt_completer(ctxt, cass):
|
|
opts = set('TIMESTAMP'.split())
|
|
for opt in ctxt.get_binding('delopt', ()):
|
|
opts.discard(opt.split()[0])
|
|
return opts
|
|
|
|
@completer_for('deleteSelector', 'delcol')
|
|
def delete_delcol_completer(ctxt, cass):
|
|
layout = get_table_meta(ctxt, cass)
|
|
return map(maybe_escape_name, regular_column_names(layout))
|
|
|
|
syntax_rules += r'''
|
|
<batchStatement> ::= "BEGIN" ( "UNLOGGED" | "COUNTER" )? "BATCH"
|
|
( "USING" [batchopt]=<usingOption>
|
|
( "AND" [batchopt]=<usingOption> )* )?
|
|
[batchstmt]=<batchStatementMember> ";"?
|
|
( [batchstmt]=<batchStatementMember> ";"? )*
|
|
"APPLY" "BATCH"
|
|
;
|
|
<batchStatementMember> ::= <insertStatement>
|
|
| <updateStatement>
|
|
| <deleteStatement>
|
|
;
|
|
'''
|
|
|
|
@completer_for('batchStatement', 'batchopt')
|
|
def batch_opt_completer(ctxt, cass):
|
|
opts = set('TIMESTAMP'.split())
|
|
for opt in ctxt.get_binding('batchopt', ()):
|
|
opts.discard(opt.split()[0])
|
|
return opts
|
|
|
|
syntax_rules += r'''
|
|
<truncateStatement> ::= "TRUNCATE" cf=<columnFamilyName>
|
|
;
|
|
'''
|
|
|
|
syntax_rules += r'''
|
|
<createKeyspaceStatement> ::= "CREATE" wat=( "KEYSPACE" | "SCHEMA" ) ("IF" "NOT" "EXISTS")? ksname=<cfOrKsName>
|
|
"WITH" <property> ( "AND" <property> )*
|
|
;
|
|
'''
|
|
|
|
@completer_for('createKeyspaceStatement', 'wat')
|
|
def create_ks_wat_completer(ctxt, cass):
|
|
# would prefer to get rid of the "schema" nomenclature in cql3
|
|
if ctxt.get_binding('partial', '') == '':
|
|
return ['KEYSPACE']
|
|
return ['KEYSPACE', 'SCHEMA']
|
|
|
|
syntax_rules += r'''
|
|
<createColumnFamilyStatement> ::= "CREATE" wat=( "COLUMNFAMILY" | "TABLE" ) ("IF" "NOT" "EXISTS")?
|
|
( ks=<nonSystemKeyspaceName> dot="." )? cf=<cfOrKsName>
|
|
"(" ( <singleKeyCfSpec> | <compositeKeyCfSpec> ) ")"
|
|
( "WITH" <cfamProperty> ( "AND" <cfamProperty> )* )?
|
|
;
|
|
|
|
<cfamProperty> ::= <property>
|
|
| "COMPACT" "STORAGE"
|
|
| "CLUSTERING" "ORDER" "BY" "(" <cfamOrdering>
|
|
( "," <cfamOrdering> )* ")"
|
|
;
|
|
|
|
<cfamOrdering> ::= [ordercol]=<cident> ( "ASC" | "DESC" )
|
|
;
|
|
|
|
<singleKeyCfSpec> ::= [newcolname]=<cident> <simpleStorageType> "PRIMARY" "KEY"
|
|
( "," [newcolname]=<cident> <storageType> )*
|
|
;
|
|
|
|
<compositeKeyCfSpec> ::= [newcolname]=<cident> <simpleStorageType>
|
|
"," [newcolname]=<cident> <storageType> ( "static" )?
|
|
( "," [newcolname]=<cident> <storageType> ( "static" )? )*
|
|
"," "PRIMARY" k="KEY" p="(" ( partkey=<pkDef> | [pkey]=<cident> )
|
|
( c="," [pkey]=<cident> )* ")"
|
|
;
|
|
|
|
<pkDef> ::= "(" [ptkey]=<cident> "," [ptkey]=<cident>
|
|
( "," [ptkey]=<cident> )* ")"
|
|
;
|
|
'''
|
|
|
|
@completer_for('cfamOrdering', 'ordercol')
|
|
def create_cf_clustering_order_colname_completer(ctxt, cass):
|
|
colnames = map(dequote_name, ctxt.get_binding('newcolname', ()))
|
|
# Definitely some of these aren't valid for ordering, but I'm not sure
|
|
# precisely which are. This is good enough for now
|
|
return colnames
|
|
|
|
@completer_for('createColumnFamilyStatement', 'wat')
|
|
def create_cf_wat_completer(ctxt, cass):
|
|
# would prefer to get rid of the "columnfamily" nomenclature in cql3
|
|
if ctxt.get_binding('partial', '') == '':
|
|
return ['TABLE']
|
|
return ['TABLE', 'COLUMNFAMILY']
|
|
|
|
explain_completion('createColumnFamilyStatement', 'cf', '<new_table_name>')
|
|
explain_completion('compositeKeyCfSpec', 'newcolname', '<new_column_name>')
|
|
|
|
@completer_for('createColumnFamilyStatement', 'dot')
|
|
def create_cf_ks_dot_completer(ctxt, cass):
|
|
ks = dequote_name(ctxt.get_binding('ks'))
|
|
if ks in cass.get_keyspace_names():
|
|
return ['.']
|
|
return []
|
|
|
|
@completer_for('pkDef', 'ptkey')
|
|
def create_cf_pkdef_declaration_completer(ctxt, cass):
|
|
cols_declared = ctxt.get_binding('newcolname')
|
|
pieces_already = ctxt.get_binding('ptkey', ())
|
|
pieces_already = map(dequote_name, pieces_already)
|
|
while cols_declared[0] in pieces_already:
|
|
cols_declared = cols_declared[1:]
|
|
if len(cols_declared) < 2:
|
|
return ()
|
|
return [maybe_escape_name(cols_declared[0])]
|
|
|
|
@completer_for('compositeKeyCfSpec', 'pkey')
|
|
def create_cf_composite_key_declaration_completer(ctxt, cass):
|
|
cols_declared = ctxt.get_binding('newcolname')
|
|
pieces_already = ctxt.get_binding('ptkey', ()) + ctxt.get_binding('pkey', ())
|
|
pieces_already = map(dequote_name, pieces_already)
|
|
while cols_declared[0] in pieces_already:
|
|
cols_declared = cols_declared[1:]
|
|
if len(cols_declared) < 2:
|
|
return ()
|
|
return [maybe_escape_name(cols_declared[0])]
|
|
|
|
@completer_for('compositeKeyCfSpec', 'k')
|
|
def create_cf_composite_primary_key_keyword_completer(ctxt, cass):
|
|
return ['KEY (']
|
|
|
|
@completer_for('compositeKeyCfSpec', 'p')
|
|
def create_cf_composite_primary_key_paren_completer(ctxt, cass):
|
|
return ['(']
|
|
|
|
@completer_for('compositeKeyCfSpec', 'c')
|
|
def create_cf_composite_primary_key_comma_completer(ctxt, cass):
|
|
cols_declared = ctxt.get_binding('newcolname')
|
|
pieces_already = ctxt.get_binding('pkey', ())
|
|
if len(pieces_already) >= len(cols_declared) - 1:
|
|
return ()
|
|
return [',']
|
|
|
|
syntax_rules += r'''
|
|
<createIndexStatement> ::= "CREATE" "CUSTOM"? "INDEX" ("IF" "NOT" "EXISTS")? indexname=<identifier>? "ON"
|
|
cf=<columnFamilyName> "(" col=<cident> ")"
|
|
( "USING" <stringLiteral> ( "WITH" "OPTIONS" "=" <mapLiteral> )? )?
|
|
;
|
|
|
|
<createUserTypeStatement> ::= "CREATE" "TYPE" ( ks=<nonSystemKeyspaceName> dot="." )? typename=<cfOrKsName> "(" newcol=<cident> <storageType>
|
|
( "," [newcolname]=<cident> <storageType> )*
|
|
")"
|
|
;
|
|
'''
|
|
|
|
explain_completion('createIndexStatement', 'indexname', '<new_index_name>')
|
|
explain_completion('createUserTypeStatement', 'typename', '<new_type_name>')
|
|
explain_completion('createUserTypeStatement', 'newcol', '<new_field_name>')
|
|
|
|
@completer_for('createIndexStatement', 'col')
|
|
def create_index_col_completer(ctxt, cass):
|
|
layout = get_table_meta(ctxt, cass)
|
|
colnames = [cd.name for cd in layout.columns.values() if not cd.index]
|
|
return map(maybe_escape_name, colnames)
|
|
|
|
syntax_rules += r'''
|
|
<dropKeyspaceStatement> ::= "DROP" "KEYSPACE" ("IF" "EXISTS")? ksname=<nonSystemKeyspaceName>
|
|
;
|
|
|
|
<dropColumnFamilyStatement> ::= "DROP" ( "COLUMNFAMILY" | "TABLE" ) ("IF" "EXISTS")? cf=<columnFamilyName>
|
|
;
|
|
|
|
<dropIndexStatement> ::= "DROP" "INDEX" ("IF" "EXISTS")? indexname=<identifier>
|
|
;
|
|
|
|
<dropUserTypeStatement> ::= "DROP" "TYPE" ut=<userTypeName>
|
|
;
|
|
|
|
'''
|
|
|
|
@completer_for('dropIndexStatement', 'indexname')
|
|
def drop_index_completer(ctxt, cass):
|
|
return map(maybe_escape_name, cass.get_index_names())
|
|
|
|
syntax_rules += r'''
|
|
<alterTableStatement> ::= "ALTER" wat=( "COLUMNFAMILY" | "TABLE" ) cf=<columnFamilyName>
|
|
<alterInstructions>
|
|
;
|
|
<alterInstructions> ::= "ALTER" existcol=<cident> "TYPE" <storageType>
|
|
| "ADD" newcol=<cident> <storageType> ("static")?
|
|
| "DROP" existcol=<cident>
|
|
| "WITH" <cfamProperty> ( "AND" <cfamProperty> )*
|
|
| "RENAME" existcol=<cident> "TO" newcol=<cident>
|
|
( "AND" existcol=<cident> "TO" newcol=<cident> )*
|
|
;
|
|
|
|
<alterUserTypeStatement> ::= "ALTER" "TYPE" ut=<userTypeName>
|
|
<alterTypeInstructions>
|
|
;
|
|
<alterTypeInstructions> ::= "RENAME" "TO" typename=<cfOrKsName>
|
|
| "ALTER" existcol=<cident> "TYPE" <storageType>
|
|
| "ADD" newcol=<cident> <storageType>
|
|
| "RENAME" existcol=<cident> "TO" newcol=<cident>
|
|
;
|
|
'''
|
|
|
|
@completer_for('alterInstructions', 'existcol')
|
|
def alter_table_col_completer(ctxt, cass):
|
|
layout = get_table_meta(ctxt, cass)
|
|
cols = [str(md) for md in layout.columns]
|
|
return map(maybe_escape_name, cols)
|
|
|
|
@completer_for('alterTypeInstructions', 'existcol')
|
|
def alter_type_field_completer(ctxt, cass):
|
|
layout = get_ut_layout(ctxt, cass)
|
|
fields = [tuple[0] for tuple in layout]
|
|
return map(maybe_escape_name, fields)
|
|
|
|
explain_completion('alterInstructions', 'newcol', '<new_column_name>')
|
|
explain_completion('alterTypeInstructions', 'typename', '<new_type_name>')
|
|
explain_completion('alterTypeInstructions', 'newcol', '<new_field_name>')
|
|
|
|
|
|
syntax_rules += r'''
|
|
<alterKeyspaceStatement> ::= "ALTER" ( "KEYSPACE" | "SCHEMA" ) ks=<alterableKeyspaceName>
|
|
"WITH" <property> ( "AND" <property> )*
|
|
;
|
|
'''
|
|
|
|
syntax_rules += r'''
|
|
<username> ::= name=( <identifier> | <stringLiteral> )
|
|
;
|
|
|
|
<createUserStatement> ::= "CREATE" "USER" <username>
|
|
( "WITH" "PASSWORD" <stringLiteral> )?
|
|
( "SUPERUSER" | "NOSUPERUSER" )?
|
|
;
|
|
|
|
<alterUserStatement> ::= "ALTER" "USER" <username>
|
|
( "WITH" "PASSWORD" <stringLiteral> )?
|
|
( "SUPERUSER" | "NOSUPERUSER" )?
|
|
;
|
|
|
|
<dropUserStatement> ::= "DROP" "USER" <username>
|
|
;
|
|
|
|
<listUsersStatement> ::= "LIST" "USERS"
|
|
;
|
|
'''
|
|
|
|
syntax_rules += r'''
|
|
<grantStatement> ::= "GRANT" <permissionExpr> "ON" <resource> "TO" <username>
|
|
;
|
|
|
|
<revokeStatement> ::= "REVOKE" <permissionExpr> "ON" <resource> "FROM" <username>
|
|
;
|
|
|
|
<listPermissionsStatement> ::= "LIST" <permissionExpr>
|
|
( "ON" <resource> )? ( "OF" <username> )? "NORECURSIVE"?
|
|
;
|
|
|
|
<permission> ::= "AUTHORIZE"
|
|
| "CREATE"
|
|
| "ALTER"
|
|
| "DROP"
|
|
| "SELECT"
|
|
| "MODIFY"
|
|
;
|
|
|
|
<permissionExpr> ::= ( <permission> "PERMISSION"? )
|
|
| ( "ALL" "PERMISSIONS"? )
|
|
;
|
|
|
|
<resource> ::= <dataResource>
|
|
;
|
|
|
|
<dataResource> ::= ( "ALL" "KEYSPACES" )
|
|
| ( "KEYSPACE" <keyspaceName> )
|
|
| ( "TABLE"? <columnFamilyName> )
|
|
;
|
|
'''
|
|
|
|
@completer_for('username', 'name')
|
|
def username_name_completer(ctxt, cass):
|
|
def maybe_quote(name):
|
|
if CqlRuleSet.is_valid_cql3_name(name):
|
|
return name
|
|
return "'%s'" % name
|
|
|
|
# disable completion for CREATE USER.
|
|
if ctxt.matched[0][0] == 'K_CREATE':
|
|
return [Hint('<username>')]
|
|
|
|
session = cass.session
|
|
return [maybe_quote(row[0].replace("'", "''")) for row in session.execute("LIST USERS")]
|
|
|
|
# END SYNTAX/COMPLETION RULE DEFINITIONS
|
|
|
|
CqlRuleSet.append_rules(syntax_rules)
|
|
|
|
from cassandra.cqltypes import lookup_casstype
|
|
|
|
class UserTypesMeta(object):
|
|
_meta = {}
|
|
|
|
def __init__(self, meta):
|
|
self._meta = meta
|
|
|
|
@classmethod
|
|
def from_layout(cls, layout):
|
|
result = {}
|
|
for row in layout:
|
|
ksname = row.keyspace_name
|
|
if ksname not in result:
|
|
result[ksname] = {}
|
|
utname = row.type_name
|
|
|
|
result[ksname][utname] = zip(row.field_names, row.field_types)
|
|
return cls(meta=result)
|
|
|
|
def get_usertypes_names(self, keyspace):
|
|
return map(str, self._meta.get(keyspace, {}).keys())
|
|
|
|
def get_field_names(self, keyspace, type):
|
|
return [row[0] for row in self._meta.get(keyspace, {}).get(type, [])]
|
|
|
|
def get_fields_with_types(self, ksname, typename):
|
|
return [(field[0], lookup_casstype(field[1]).cql_parameterized_type()) for field in
|
|
self._meta.get(ksname, {}).get(typename, [])]
|