Merge branch 'cassandra-2.2' into cassandra-3.0
Project: http://git-wip-us.apache.org/repos/asf/cassandra/repo Commit: http://git-wip-us.apache.org/repos/asf/cassandra/commit/9a2fd8cc Tree: http://git-wip-us.apache.org/repos/asf/cassandra/tree/9a2fd8cc Diff: http://git-wip-us.apache.org/repos/asf/cassandra/diff/9a2fd8cc Branch: refs/heads/cassandra-3.1 Commit: 9a2fd8ccf3a98831a6b30b13987d70753ee8523a Parents: 56965fd 0ee8895 Author: Robert Stupp <sn...@snazy.de> Authored: Fri Nov 27 15:26:02 2015 +0100 Committer: Robert Stupp <sn...@snazy.de> Committed: Fri Nov 27 15:26:02 2015 +0100 ---------------------------------------------------------------------- CHANGES.txt | 1 + bin/cqlsh.py | 62 ++- build.xml | 7 +- conf/cqlshrc.sample | 17 + debian/rules | 3 +- pylib/cqlshlib/helptopics.py | 1078 ++++--------------------------------- 6 files changed, 188 insertions(+), 980 deletions(-) ---------------------------------------------------------------------- http://git-wip-us.apache.org/repos/asf/cassandra/blob/9a2fd8cc/CHANGES.txt ---------------------------------------------------------------------- diff --cc CHANGES.txt index 592cff8,af1a186..0bb05d9 --- a/CHANGES.txt +++ b/CHANGES.txt @@@ -1,16 -1,5 +1,17 @@@ -2.2.4 +3.0.1 + * Fix SELECT statement with IN restrictions on partition key, + ORDER BY and LIMIT (CASSANDRA-10729) + * Improve stress performance over 1k threads (CASSANDRA-7217) + * Wait for migration responses to complete before bootstrapping (CASSANDRA-10731) + * Unable to create a function with argument of type Inet (CASSANDRA-10741) + * Fix backward incompatibiliy in CqlInputFormat (CASSANDRA-10717) + * Correctly preserve deletion info on updated rows when notifying indexers + of single-row deletions (CASSANDRA-10694) + * Notify indexers of partition delete during cleanup (CASSANDRA-10685) + * Keep the file open in trySkipCache (CASSANDRA-10669) + * Updated trigger example (CASSANDRA-10257) +Merged from 2.2: + * Show CQL help in cqlsh in web browser (CASSANDRA-7225) * Serialize on disk the proper SSTable compression ratio (CASSANDRA-10775) * Reject index queries while the index is building (CASSANDRA-8505) * CQL.textile syntax incorrectly includes optional keyspace for aggregate SFUNC and FINALFUNC (CASSANDRA-10747) http://git-wip-us.apache.org/repos/asf/cassandra/blob/9a2fd8cc/bin/cqlsh.py ---------------------------------------------------------------------- diff --cc bin/cqlsh.py index d05a84b,e7dc121..6b87d9f --- a/bin/cqlsh.py +++ b/bin/cqlsh.py @@@ -71,6 -72,31 +72,32 @@@ CQL_LIB_PREFIX = 'cassandra-driver-inte CASSANDRA_PATH = os.path.join(os.path.dirname(os.path.realpath(__file__)), '..') ++# default location of local CQL.html + if os.path.exists(CASSANDRA_PATH + '/doc/cql3/CQL.html'): + # default location of local CQL.html + CASSANDRA_CQL_HTML = 'file://' + CASSANDRA_PATH + '/doc/cql3/CQL.html' + elif os.path.exists('/usr/share/doc/cassandra/CQL.html'): + # fallback to package file + CASSANDRA_CQL_HTML = 'file:///usr/share/doc/cassandra/CQL.html' + else: + # fallback to online version - CASSANDRA_CQL_HTML = 'https://cassandra.apache.org/doc/cql3/CQL-2.2.html' ++ CASSANDRA_CQL_HTML = 'https://cassandra.apache.org/doc/cql3/CQL-3.0.html' + + # On Linux, the Python webbrowser module uses the 'xdg-open' executable + # to open a file/URL. But that only works, if the current session has been + # opened from _within_ a desktop environment. I.e. 'xdg-open' will fail, + # if the session's been opened via ssh to a remote box. + # + # Use 'python' to get some information about the detected browsers. + # >>> import webbrowser + # >>> webbrowser._tryorder + # >>> webbrowser._browser + # + if webbrowser._tryorder[0] == 'xdg-open' and os.environ.get('XDG_DATA_DIRS', '') == '': + # only on Linux (some OS with xdg-open) + webbrowser._tryorder.remove('xdg-open') + webbrowser._tryorder.append('xdg-open') + # use bundled libs for python-cql and thrift, if available. if there # is a ../lib dir, use bundled libs there preferentially. ZIPLIB_DIRS = [os.path.join(CASSANDRA_PATH, 'lib')] http://git-wip-us.apache.org/repos/asf/cassandra/blob/9a2fd8cc/build.xml ---------------------------------------------------------------------- http://git-wip-us.apache.org/repos/asf/cassandra/blob/9a2fd8cc/pylib/cqlshlib/helptopics.py ---------------------------------------------------------------------- diff --cc pylib/cqlshlib/helptopics.py index b5cf09a,c2eebe3..347b17d --- a/pylib/cqlshlib/helptopics.py +++ b/pylib/cqlshlib/helptopics.py @@@ -16,1026 -16,140 +16,152 @@@ from .cql3handling import simple_cql_types - - class CQLHelpTopics(object): -- + class CQL3HelpTopics(object): - def get_help_topics(self): return [t[5:] for t in dir(self) if t.startswith('help_')] - def print_help_topic(self, topic): - getattr(self, 'help_' + topic.lower())() + def get_help_topic(self, topic): + return getattr(self, 'help_' + topic.lower())() def help_types(self): - print "\n CQL types recognized by this version of cqlsh:\n" - for t in simple_cql_types: - print ' ' + t - print """ - For information on the various recognizable input formats for these - types, or on controlling the formatting of cqlsh query output, see - one of the following topics: - - HELP TIMESTAMP_INPUT - HELP DATE_INPUT - HELP TIME_INPUT - HELP BLOB_INPUT - HELP UUID_INPUT - HELP BOOLEAN_INPUT - HELP INT_INPUT - - HELP TEXT_OUTPUT - HELP TIMESTAMP_OUTPUT - """ - - def help_timestamp_input(self): - print """ - Timestamp input - - CQL supports any of the following ISO 8601 formats for timestamp - specification: - - yyyy-mm-dd HH:mm - yyyy-mm-dd HH:mm:ss - yyyy-mm-dd HH:mmZ - yyyy-mm-dd HH:mm:ssZ - yyyy-mm-dd'T'HH:mm - yyyy-mm-dd'T'HH:mmZ - yyyy-mm-dd'T'HH:mm:ss - yyyy-mm-dd'T'HH:mm:ssZ - yyyy-mm-dd - yyyy-mm-ddZ - - The Z in these formats refers to an RFC-822 4-digit time zone, - expressing the time zone's difference from UTC. For example, a - timestamp in Pacific Standard Time might be given thus: - - 2012-01-20 16:14:12-0800 - - If no time zone is supplied, the current time zone for the Cassandra - server node will be used. - """ - - def help_date_input(self): - print """ - Date input - - CQL supports the following format for date specification: - - yyyy-mm-dd - """ - - def help_time_input(self): - print """ - Time input - - CQL supports the following format for time specification: + return 'types' - HH:MM:SS - HH:MM:SS.mmm - HH:MM:SS.mmmuuu - HH:MM:SS.mmmuuunnn - """ + def help_timestamp(self): + return 'usingtimestamps' - def help_blob_input(self): - print """ - Blob input + def help_date(self): + return 'usingdates' - CQL blob data must be specified in a string literal as hexidecimal - data. Example: to store the ASCII values for the characters in the - string "CQL", use '43514c'. - """ + def help_time(self): + return 'usingtime' - def help_uuid_input(self): - print """ - UUID input + def help_blob(self): + return 'constants' - UUIDs may be specified in CQL using 32 hexidecimal characters, - split up using dashes in the standard UUID format: + def help_uuid(self): + return 'constants' - XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX - """ + def help_boolean(self): + return 'constants' - def help_boolean_input(self): - print """ - Boolean input + def help_int(self): + return 'constants' - CQL accepts the strings 'true' and 'false' (case insensitive) - as input for boolean types. - """ + def help_counter(self): + return 'counters' - def help_int_input(self): - print """ - Integer input + def help_text(self): + return 'constants' + help_ascii = help_text - CQL accepts the following integer types: - tinyint - 1-byte signed integer - smallint - 2-byte signed integer - int - 4-byte signed integer - bigint - 8-byte signed integer - """ - - def help_timestamp_output(self): - print """ - Timestamp output - - Cqlsh will display timestamps in the following format by default: - - yyyy-mm-dd HH:mm:ssZ - - which is a format acceptable as CQL timestamp input as well. - The output format can be changed by setting 'time_format' property - in the [ui] section of .cqlshrc file. - """ - - def help_text_output(self): - print """ - Textual output + def help_use(self): + return 'useStmt' - When control characters, or other characters which can't be encoded - in your current locale, are found in values of 'text' or 'ascii' - types, it will be shown as a backslash escape. If color is enabled, - any such backslash escapes will be shown in a different color from - the surrounding text. + def help_insert(self): + return 'insertStmt' - Unicode code points in your data will be output intact, if the - encoding for your locale is capable of decoding them. If you prefer - that non-ascii characters be shown with Python-style "\\uABCD" - escape sequences, invoke cqlsh with an ASCII locale (for example, - by setting the $LANG environment variable to "C"). - """ - help_ascii_output = help_text_output + def help_update(self): + return 'updateStmt' - def help_create_index(self): - print """ - CREATE INDEX [<indexname>] ON <cfname> ( <colname> ); + def help_delete(self): + return 'deleteStmt' - A CREATE INDEX statement is used to create a new, automatic secondary - index on the given CQL table, for the named column. A name for the - index itself can be specified before the ON keyword, if desired. A - single column name must be specified inside the parentheses. It is not - necessary for the column to exist on any current rows (Cassandra is - schema-optional), but the column must already have a type (specified - during the CREATE TABLE, or added afterwards with ALTER TABLE). - """ + def help_select(self): + return 'selectStmt' - def help_drop(self): - print """ - There are different variants of DROP. For more information, see - one of the following: + def help_json(self): + return 'json' + def help_select_json(self): + return 'selectJson' + def help_insert_json(self): + return 'insertJson' - HELP DROP_KEYSPACE; - HELP DROP_TABLE; - HELP DROP_INDEX; - HELP DROP_FUNCTION; - HELP DROP_AGGREGATE; - """ + def help_batch(self): + return 'batchStmt' + help_begin = help_batch + help_apply = help_batch + def help_create_keyspace(self): + return 'createKeyspaceStmt' + def help_alter_keyspace(self): + return 'alterKeyspaceStmt' def help_drop_keyspace(self): - print """ - DROP KEYSPACE <keyspacename>; - - A DROP KEYSPACE statement results in the immediate, irreversible - removal of a keyspace, including all column families in it, and all - data contained in those column families. - """ + return 'dropKeyspaceStmt' + def help_create_table(self): + return 'createTableStmt' + help_create_columnfamily = help_create_table + def help_alter_table(self): + return 'alterTableStmt' def help_drop_table(self): - print """ - DROP TABLE <tablename>; - - A DROP TABLE statement results in the immediate, irreversible - removal of a CQL table and the underlying column family, including all - data contained in it. - """ + return 'dropTableStmt' help_drop_columnfamily = help_drop_table - + def help_create_index(self): + return 'createIndexStmt' def help_drop_index(self): - print """ - DROP INDEX <indexname>; - - A DROP INDEX statement is used to drop an existing secondary index. - """ - - def help_drop_function(self): - print """ - DROP FUNCTION ( IF EXISTS )? - ( <keyspace> '.' )? <function-name> - ( '(' <arg-type> ( ',' <arg-type> )* ')' )? - - DROP FUNCTION statement removes a function created using CREATE FUNCTION. - You must specify the argument types (signature) of the function to drop if there - are multiple functions with the same name but a different signature - (overloaded functions). - - DROP FUNCTION with the optional IF EXISTS keywords drops a function if it exists. - """ - - def help_drop_aggregate(self): - print """ - DROP AGGREGATE ( IF EXISTS )? - ( <keyspace> '.' )? <aggregate-name> - ( '(' <arg-type> ( ',' <arg-type> )* ')' )? - - The DROP AGGREGATE statement removes an aggregate created using CREATE AGGREGATE. - You must specify the argument types of the aggregate to drop if there are multiple - aggregates with the same name but a different signature (overloaded aggregates). - - DROP AGGREGATE with the optional IF EXISTS keywords drops an aggregate if it exists, - and does nothing if a function with the signature does not exist. - - Signatures for user-defined aggregates follow the same rules as for - user-defined functions. - """ + return 'dropIndexStmt' def help_truncate(self): - print """ - TRUNCATE <tablename>; - - TRUNCATE accepts a single argument for the table name, and permanently - removes all data from it. - """ - - def help_create(self): - print """ - There are different variants of CREATE. For more information, see - one of the following: - - HELP CREATE_KEYSPACE; - HELP CREATE_TABLE; - HELP CREATE_INDEX; - HELP CREATE_FUNCTION; - HELP CREATE_AGGREGATE; - """ - - def help_use(self): - print """ - USE <keyspacename>; - - Tells cqlsh and the connected Cassandra instance that you will be - working in the given keyspace. All subsequent operations on tables - or indexes will be in the context of this keyspace, unless otherwise - specified, until another USE command is issued or the connection - terminates. - - As always, when a keyspace name does not work as a normal identifier or - number, it can be quoted using double quotes. - """ - - def help_create_aggregate(self): - print """ - CREATE ( OR REPLACE )? AGGREGATE ( IF NOT EXISTS )? - ( <keyspace> '.' )? <aggregate-name> - '(' <arg-type> ( ',' <arg-type> )* ')' - SFUNC ( <keyspace> '.' )? <state-functionname> - STYPE <state-type> - ( FINALFUNC ( <keyspace> '.' )? <final-functionname> )? - ( INITCOND <init-cond> )? - - CREATE AGGREGATE creates or replaces a user-defined aggregate. - - CREATE AGGREGATE with the optional OR REPLACE keywords either creates an aggregate - or replaces an existing one with the same signature. A CREATE AGGREGATE without - OR REPLACE fails if an aggregate with the same signature already exists. - - CREATE AGGREGATE with the optional IF NOT EXISTS keywords either creates an aggregate - if it does not already exist. - - OR REPLACE and IF NOT EXIST cannot be used together. - - Aggregates belong to a keyspace. If no keyspace is specified in <aggregate-name>, the - current keyspace is used (i.e. the keyspace specified using the USE statement). It is - not possible to create a user-defined aggregate in one of the system keyspaces. - - Signatures for user-defined aggregates follow the same rules as for - user-defined functions. - - STYPE defines the type of the state value and must be specified. + return 'truncateStmt' - The optional INITCOND defines the initial state value for the aggregate. It defaults - to null. A non-null INITCOND must be specified for state functions that are declared - with RETURNS NULL ON NULL INPUT. - - SFUNC references an existing function to be used as the state modifying function. The - type of first argument of the state function must match STYPE. The remaining argument - types of the state function must match the argument types of the aggregate function. - State is not updated for state functions declared with RETURNS NULL ON NULL INPUT and - called with null. - - The optional FINALFUNC is called just before the aggregate result is returned. It must - take only one argument with type STYPE. The return type of the FINALFUNC may be a - different type. A final function declared with RETURNS NULL ON NULL INPUT means that - the aggregate's return value will be null, if the last state is null. - - If no FINALFUNC is defined, the overall return type of the aggregate function is STYPE. - If a FINALFUNC is defined, it is the return type of that function. - """ + def help_create_type(self): + return 'createTypeStmt' + def help_alter_type(self): + return 'alterTypeStmt' + def help_drop_type(self): + return 'dropTypeStmt' def help_create_function(self): - print """ - CREATE ( OR REPLACE )? FUNCTION ( IF NOT EXISTS )? - ( <keyspace> '.' )? <function-name> - '(' <arg-name> <arg-type> ( ',' <arg-name> <arg-type> )* ')' - ( CALLED | RETURNS NULL ) ON NULL INPUT - RETURNS <type> - LANGUAGE <language> - AS <body> - - CREATE FUNCTION creates or replaces a user-defined function. - - Signatures are used to distinguish individual functions. The signature consists of: - - The fully qualified function name - i.e keyspace plus function-name - The concatenated list of all argument types - - Note that keyspace names, function names and argument types are subject to the default - naming conventions and case-sensitivity rules. - - CREATE FUNCTION with the optional OR REPLACE keywords either creates a function or - replaces an existing one with the same signature. A CREATE FUNCTION without OR REPLACE - fails if a function with the same signature already exists. - - Behavior on invocation with null values must be defined for each function. There are - two options: - - RETURNS NULL ON NULL INPUT declares that the function will always return null if any - of the input arguments is null. CALLED ON NULL INPUT declares that the function will - always be executed. - - If the optional IF NOT EXISTS keywords are used, the function will only be created if - another function with the same signature does not exist. - - OR REPLACE and IF NOT EXIST cannot be used together. - - Functions belong to a keyspace. If no keyspace is specified in <function-name>, the - current keyspace is used (i.e. the keyspace specified using the USE statement). - It is not possible to create a user-defined function in one of the system keyspaces. - """ - - def help_create_table(self): - print """ - CREATE TABLE <cfname> ( <colname> <type> PRIMARY KEY [, - <colname> <type> [, ...]] ) - [WITH <optionname> = <val> [AND <optionname> = <val> [...]]]; - - CREATE TABLE statements create a new CQL table under the current - keyspace. Valid table names are strings of alphanumeric characters and - underscores, which begin with a letter. - - Each table requires a primary key, which will correspond to the - underlying columnfamily key and key validator. It's important to - note that the key type you use must be compatible with the partitioner - in use. For example, OrderPreservingPartitioner and - CollatingOrderPreservingPartitioner both require UTF-8 keys. - - In cql3 mode, a table can have multiple columns composing the primary - key (see HELP COMPOUND_PRIMARY_KEYS). - - For more information, see one of the following: - - HELP CREATE_TABLE_TYPES; - HELP CREATE_TABLE_OPTIONS; - """ - help_create_columnfamily = help_create_table - - def help_compound_primary_keys(self): - print """ - CREATE TABLE <cfname> ( <partition_key> <type>, <clustering_key1> type, <clustering_key2> type, - [, ...]], PRIMARY KEY (<partition_key>, <clustering_key1>, <clustering_key2>); - - CREATE TABLE allows a primary key composed of multiple columns. When this is the case, specify - the columns that take part in the compound key after all columns have been specified. - - , PRIMARY KEY( <key1>, <key2>, ... ) - - The partitioning key itself can be a compound key, in which case the first element of the PRIMARY KEY - phrase should be parenthesized, as - - PRIMARY KEY ((<partition_key_part1>, <partition_key_part2>), <clustering_key>) - """ - - def help_create_table_types(self): - print """ - CREATE TABLE: Specifying column types - - CREATE ... (KEY <type> PRIMARY KEY, - othercol <type>) ... - - It is possible to assign columns a type during table creation. Columns - configured with a type are validated accordingly when a write occurs, - and intelligent CQL drivers and interfaces will be able to decode the - column values correctly when receiving them. Column types are specified - as a parenthesized, comma-separated list of column term and type pairs. - See HELP TYPES; for the list of recognized types. - """ - help_create_columnfamily_types = help_create_table_types - - def help_create_table_options(self): - print """ - CREATE TABLE: Specifying columnfamily options - - CREATE TABLE blah (...) - WITH optionname = val AND otheroption = val2; - - A number of optional keyword arguments can be supplied to control the - configuration of a new CQL table, such as the size of the associated - row and key caches for the underlying Cassandra columnfamily. Consult - your CQL reference for the complete list of options and possible - values. - """ - help_create_columnfamily_options = help_create_table_options - - def help_alter_alter(self): - print """ - ALTER TABLE: altering existing typed columns - - ALTER TABLE addamsFamily ALTER lastKnownLocation TYPE uuid; - - ALTER TABLE ... ALTER changes the expected storage type for a column. - The column must already have a type in the column family metadata. The - column may or may not already exist in current rows-- but be aware that - no validation of existing data is done. The bytes stored in values for - that column will remain unchanged, and if existing data is not - deserializable according to the new type, this may cause your CQL - driver or interface to report errors. - """ - - def help_alter_add(self): - print """ - ALTER TABLE: adding a typed column - - ALTER TABLE addamsFamily ADD gravesite varchar; - - The ALTER TABLE ... ADD variant adds a typed column to a column - family. The column must not already have a type in the column family - metadata. See the warnings on HELP ALTER_ALTER regarding the lack of - validation of existing data; they apply here as well. - """ - - def help_alter_drop(self): - print """ - ALTER TABLE: dropping a typed column - - ALTER TABLE addamsFamily DROP gender; - - An ALTER TABLE ... DROP statement removes the type of a column - from the column family metadata. Note that this does _not_ remove the - column from current rows; it just removes the metadata saying that the - bytes stored under that column are expected to be deserializable - according to a certain type. - """ - - def help_alter_with(self): - print """ - ALTER TABLE: changing column family properties - - ALTER TABLE addamsFamily WITH comment = 'Glad to be here!' - AND read_repair_chance = 0.2; - - An ALTER TABLE ... WITH statement makes adjustments to the - table properties, as defined when the table was created (see - HELP CREATE_TABLE_OPTIONS and your Cassandra documentation for - information about the supported parameter names and values). - """ - - def help_delete_columns(self): - print """ - DELETE: specifying columns - - DELETE col1, col2, col3 FROM ... - - Following the DELETE keyword is an optional comma-delimited list of - column name terms. When no column names are given, the remove applies - to the entire row(s) matched by the WHERE clause. - - When column names do not parse as valid CQL identifiers, they can be - quoted in single quotes (CQL 2) or double quotes (CQL 3). - """ - - def help_delete_where(self): - print """ - DELETE: specifying rows - - DELETE ... WHERE keycol = 'some_key_value'; - DELETE ... WHERE keycol1 = 'val1' AND keycol2 = 'val2'; - DELETE ... WHERE keycol IN (key1, key2); - - The WHERE clause is used to determine to which row(s) a DELETE - applies. The first form allows the specification of a precise row - by specifying a particular primary key value (if the primary key has - multiple columns, values for each must be given). The second form - allows a list of key values to be specified using the IN operator - and a parenthesized list of comma-delimited key values. - """ - - def help_update_set(self): - print """ - UPDATE: Specifying Columns and Row - - UPDATE ... SET name1 = value1, name2 = value2 - WHERE <key> = keyname; - UPDATE ... SET name1 = value1, name2 = value2 - WHERE <key> IN ('<key1>', '<key2>', ...) - - Rows are created or updated by supplying column names and values in - term assignment format. Multiple columns can be set by separating the - name/value pairs using commas. - """ - - def help_update_counters(self): - print """ - UPDATE: Updating Counter Columns - - UPDATE ... SET name1 = name1 + <value> ... - UPDATE ... SET name1 = name1 - <value> ... - - Counter columns can be incremented or decremented by an arbitrary - numeric value though the assignment of an expression that adds or - subtracts the value. - """ - - def help_update_where(self): - print """ - UPDATE: Selecting rows to update - - UPDATE ... WHERE <keyname> = <keyval>; - UPDATE ... WHERE <keyname> IN (<keyval1>, <keyval2>, ...); - UPDATE ... WHERE <keycol1> = <keyval1> AND <keycol2> = <keyval2>; - - Each update statement requires a precise set of keys to be specified - using a WHERE clause. - - If the table's primary key consists of multiple columns, an explicit - value must be given for each for the UPDATE statement to make sense. - """ - - def help_select_table(self): - print """ - SELECT: Specifying Table - - SELECT ... FROM [<keyspace>.]<tablename> ... - - The FROM clause is used to specify the CQL table applicable to a SELECT - query. The keyspace in which the table exists can optionally be - specified along with the table name, separated by a dot (.). This will - not change the current keyspace of the session (see HELP USE). - """ - help_select_columnfamily = help_select_table - - def help_select_where(self): - print """ - SELECT: Filtering rows - - SELECT ... WHERE <key> = keyname AND name1 = value1 - SELECT ... WHERE <key> >= startkey and <key> =< endkey AND name1 = value1 - SELECT ... WHERE <key> IN ('<key>', '<key>', '<key>', ...) - - The WHERE clause provides for filtering the rows that appear in - results. The clause can filter on a key name, or range of keys, and in - the case of indexed columns, on column values. Key filters are - specified using the KEY keyword or key alias name, a relational - operator (one of =, >, >=, <, and <=), and a term value. When terms - appear on both sides of a relational operator it is assumed the filter - applies to an indexed column. With column index filters, the term on - the left of the operator is the name, the term on the right is the - value to filter _on_. - - Note: The greater-than and less-than operators (> and <) result in key - ranges that are inclusive of the terms. There is no supported notion of - "strictly" greater-than or less-than; these operators are merely - supported as aliases to >= and <=. - """ - - def help_select_limit(self): - print """ - SELECT: Limiting results - - SELECT ... WHERE <clause> [LIMIT n] ... - - Limiting the number of rows returned can be achieved by adding the - LIMIT option to a SELECT expression. LIMIT defaults to 10,000 when left - unset. - """ - - - class CQL3HelpTopics(CQLHelpTopics): - - def help_create_keyspace(self): - print """ - CREATE KEYSPACE <ksname> - WITH replication = {'class':'<strategy>' [,'<option>':<val>]}; - - The CREATE KEYSPACE statement creates a new top-level namespace (aka - "keyspace"). Valid names are any string constructed of alphanumeric - characters and underscores. Names which do not work as valid - identifiers or integers should be quoted as string literals. Properties - such as replication strategy and count are specified during creation - as key-value pairs in the 'replication' map: - - class [required]: The name of the replication strategy class - which should be used for the new keyspace. Some often-used classes - are SimpleStrategy and NetworkTopologyStrategy. - - other options [optional]: Most strategies require additional arguments - which can be supplied as key-value pairs in the 'replication' map. - - Examples: - - To create a keyspace with NetworkTopologyStrategy and strategy option of "DC1" - with a value of "1" and "DC2" with a value of "2" you would use - the following statement: - CREATE KEYSPACE <ksname> - WITH replication = {'class':'NetworkTopologyStrategy', 'DC1':1, 'DC2':2}; - - To create a keyspace with SimpleStrategy and "replication_factor" option - with a value of "3" you would use this statement: - CREATE KEYSPACE <ksname> - WITH replication = {'class':'SimpleStrategy', 'replication_factor':3}; - """ - - def help_begin(self): - print """ - BEGIN [UNLOGGED|COUNTER] BATCH [USING TIMESTAMP <timestamp>] - <insert or update or delete statement> ; - [ <another insert or update or delete statement ; - [...]] - APPLY BATCH; - - BATCH supports setting a client-supplied optional global timestamp - which will be used for each of the operations included in the batch. - - Only data modification statements (specifically, UPDATE, INSERT, - and DELETE) are allowed in a BATCH statement. BATCH is _not_ an - analogue for SQL transactions. - - _NOTE: Counter mutations are allowed only within COUNTER batches._ - - _NOTE: While there are no isolation guarantees, UPDATE queries are - atomic within a given record._ - """ - help_apply = help_begin - - def help_select(self): - print """ - SELECT <selectExpr> - FROM [<keyspace>.]<table> - [WHERE <clause>] - [ORDER BY <colname> [DESC]] - [LIMIT m]; - - SELECT is used to read one or more records from a CQL table. It returns - a set of rows matching the selection criteria specified. - - For more information, see one of the following: - - HELP SELECT_EXPR - HELP SELECT_TABLE - HELP SELECT_WHERE - HELP SELECT_LIMIT - """ - - def help_delete(self): - print """ - DELETE [<col1> [, <col2>, ...] FROM [<keyspace>.]<tablename> - [USING TIMESTAMP <timestamp>] - WHERE <keyname> = <keyvalue>; - - A DELETE is used to perform the removal of one or more columns from one - or more rows. Each DELETE statement requires a precise set of row keys - to be specified using a WHERE clause and the KEY keyword or key alias. - - For more information, see one of the following: - - HELP DELETE_USING - HELP DELETE_COLUMNS - HELP DELETE_WHERE - """ - - def help_delete_using(self): - print """ - DELETE: the USING clause - - DELETE ... USING TIMESTAMP <timestamp>; - - <timestamp> defines the optional timestamp for the new tombstone - record. It must be an integer. Cassandra timestamps are generally - specified using milliseconds since the Unix epoch (1970-01-01 00:00:00 - UTC). - """ - - def help_update(self): - print """ - UPDATE [<keyspace>.]<columnFamily> - [USING [TIMESTAMP <timestamp>] - [AND TTL <timeToLive>]] - SET name1 = value1, name2 = value2 WHERE <keycol> = keyval - [IF EXISTS]; - - An UPDATE is used to write one or more columns to a record in a table. - No results are returned. The record's primary key must be completely - and uniquely specified; that is, if the primary key includes multiple - columns, all must be explicitly given in the WHERE clause. - - Statements begin with the UPDATE keyword followed by the name of the - table to be updated. - - For more information, see one of the following: - - HELP UPDATE_USING - HELP UPDATE_SET - HELP UPDATE_COUNTERS - HELP UPDATE_WHERE - """ - - def help_update_using(self): - print """ - UPDATE: the USING clause - - UPDATE ... USING TIMESTAMP <timestamp>; - UPDATE ... USING TTL <timeToLive>; - - The USING clause allows setting of certain query and data parameters. - If multiple parameters need to be set, these may be joined using AND. - Example: - - UPDATE ... USING TTL 43200 AND TIMESTAMP 1351620509603 - - <timestamp> defines the optional timestamp for the new column value(s). - It must be an integer. Cassandra timestamps are generally specified - using milliseconds since the Unix epoch (1970-01-01 00:00:00 UTC). - - <timeToLive> defines the optional time to live (TTL) in seconds for the - new column value(s). It must be an integer. - """ - - def help_insert(self): - print """ - INSERT INTO [<keyspace>.]<tablename> - ( <colname1>, <colname2> [, <colname3> [, ...]] ) - VALUES ( <colval1>, <colval2> [, <colval3> [, ...]] ) - [USING TIMESTAMP <timestamp>] - [AND TTL <timeToLive>]; - - An INSERT is used to write one or more columns to a record in a - CQL table. No results are returned. - - Values for all component columns in the table's primary key must - be given. Also, there must be at least one non-primary-key column - specified (Cassandra rows are not considered to exist with only - a key and no associated columns). - - Unlike in SQL, the semantics of INSERT and UPDATE are identical. - In either case a record is created if none existed before, and - udpated when it does. For more information, see one of the - following: - - HELP UPDATE - HELP UPDATE_USING - """ - - def help_select_expr(self): - print """ - SELECT: Specifying Columns - - SELECT name1, name2, name3 FROM ... - SELECT COUNT(*) FROM ... - SELECT MIN(name1), MAX(name2), SUM(name3), AVG(name4) FROM ... - - The SELECT expression determines which columns will appear in the - results and takes the form of a comma separated list of names. - - It is worth noting that unlike the projection in a SQL SELECT, there is - no guarantee that the results will contain all of the columns - specified. This is because Cassandra is schema-less and there are no - guarantees that a given column exists. - - When the COUNT aggregate function is specified as a column to fetch, a - single row will be returned, with a single column named "count" whose - value is the number of rows from the pre-aggregation resultset. - - The MAX and MIN functions can be used to compute the maximum and the - minimum value returned by a query for a given column. - - The SUM function can be used to sum up all the values returned by - a query for a given column. - - The AVG function can be used to compute the average of all the - values returned by a query for a given column. - """ - - def help_alter_drop(self): - print """ - ALTER TABLE: dropping a typed column - - ALTER TABLE addamsFamily DROP gender; - - An ALTER TABLE ... DROP statement removes the type of a column - from the column family metadata. Dropped columns will immediately - become unavailable in the queries and will not be included in - compacted sstables in the future. If a column is readded, queries - won't return values written before the column was last dropped. - It is assumed that timestamps represent actual time, so if this - is not your case, you should NOT readd previously dropped columns. - Columns can't be dropped from tables defined with COMPACT STORAGE. - """ - - def help_create(self): - super(CQL3HelpTopics, self).help_create() - print """ HELP CREATE_USER; - HELP CREATE_ROLE; - """ - - def help_alter(self): - print """ - ALTER TABLE <tablename> ALTER <columnname> TYPE <type>; - ALTER TABLE <tablename> ADD <columnname> <type>; - ALTER TABLE <tablename> RENAME <columnname> TO <columnname> - [AND <columnname> TO <columnname>] - ALTER TABLE <tablename> WITH <optionname> = <val> [AND <optionname> = <val> [...]]; - - An ALTER statement is used to manipulate table metadata. It allows you - to add new typed columns, drop existing columns, change the data - storage type of existing columns, or change table properties. - No results are returned. - - See one of the following for more information: - - HELP ALTER_ALTER; - HELP ALTER_ADD; - HELP ALTER_DROP; - HELP ALTER_RENAME; - HELP ALTER_WITH; - """ - - def help_alter_rename(self): - print """ - ALTER TABLE: renaming a column - - ALTER TABLE <tablename> RENAME <columnname> TO <columnname> - [AND <columnname> TO <columnname>] + return 'createFunctionStmt' + def help_drop_function(self): + return 'dropFunctionStmt' + def help_functions(self): + return 'functions' - The ALTER TABLE ... RENAME variant renames a typed column in a column - family. - """ + def help_create_aggregate(self): + return 'createAggregateStmt' + def help_drop_aggregate(self): + return 'dropAggregateStmt' + def help_aggregates(self): + return 'aggregates' - def help_drop(self): - super(CQL3HelpTopics, self).help_create() - print """ HELP DROP_USER; - HELP DROP_ROLE; - """ + def help_create_trigger(self): + return 'createTriggerStmt' + def help_drop_trigger(self): + return 'dropTriggerStmt' - def help_list(self): - print """ - There are different variants of LIST. For more information, see - one of the following: ++ def help_create_materialized_view(self): ++ return 'createMVStmt' ++ def help_alter_materialized_view(self): ++ return 'alterMVStmt' ++ def help_drop_materialized_view(self): ++ return 'dropMVStmt' + - HELP LIST_USERS; - HELP LIST_PERMISSIONS; - """ + def help_keywords(self): + return 'appendixA' def help_create_user(self): - print """ - CREATE USER <username> [WITH PASSWORD 'password'] [NOSUPERUSER | SUPERUSER]; - - CREATE USER creates a new Cassandra user account. - Only superusers can issue CREATE USER requests. - To create a superuser account use SUPERUSER option (NOSUPERUSER is the default). - - WITH PASSWORD clause should only be used with password-based authenticators, - e.g. PasswordAuthenticator, SimpleAuthenticator. - """ - + return 'createUserStmt' def help_alter_user(self): - print """ - ALTER USER <username> [WITH PASSWORD 'password'] [NOSUPERUSER | SUPERUSER]; - - Use ALTER USER to change a user's superuser status and/or password (only - with password-based authenticators). - Superusers can change a user's password or superuser status (except their own). - Users cannot change their own superuser status. Ordinary users can only change their - password (if the configured authenticator is password-based). - """ - + return 'alterUserStmt' def help_drop_user(self): - print """ - DROP USER <username>; - - DROP USER removes an existing user. You have to be logged in as a superuser - to issue a DROP USER statement. A user cannot drop themselves. - """ - + return 'dropUserStmt' def help_list_users(self): - print """ - LIST USERS; - - List existing users and their superuser status. - """ - - def help_grant(self): - print """ - GRANT (<permission> [PERMISSION] | ALL [PERMISSIONS]) - ON ALL KEYSPACES - | KEYSPACE <keyspace> - | [TABLE] [<keyspace>.]<table> - TO [ROLE <rolename> | USER <username>] - - Grant the specified permission (or all permissions) on a resource - to a role or user. - - To be able to grant a permission on some resource you have to - have that permission yourself and also AUTHORIZE permission on it, - or on one of its parent resources. - - See HELP PERMISSIONS for more info on the available permissions. - """ - - def help_revoke(self): - print """ - REVOKE (<permission> [PERMISSION] | ALL [PERMISSIONS]) - ON ALL KEYSPACES - | KEYSPACE <keyspace> - | [TABLE] [<keyspace>.]<table> - FROM [ROLE <rolename> | USER <username>] - - Revokes the specified permission (or all permissions) on a resource - from a role or user. - - To be able to revoke a permission on some resource you have to - have that permission yourself and also AUTHORIZE permission on it, - or on one of its parent resources. - - See HELP PERMISSIONS for more info on the available permissions. - """ - - def help_list_permissions(self): - print """ - LIST (<permission> [PERMISSION] | ALL [PERMISSIONS]) - [ON ALL KEYSPACES - | KEYSPACE <keyspace> - | [TABLE] [<keyspace>.]<table>] - [OF [ROLE <rolename> | USER <username>] - [NORECURSIVE] - - Omitting ON <resource> part will list permissions on ALL KEYSPACES, - every keyspace and table. - Omitting OF [ROLE <rolename> | USER <username>] part will list permissions - of all roles and users. - Omitting NORECURSIVE specifier will list permissions of the resource - and all its parents (table, table's keyspace and ALL KEYSPACES). - - See HELP PERMISSIONS for more info on the available permissions. - """ - - def help_permissions(self): - print """ - PERMISSIONS - - Cassandra has 6 permissions: - ALTER: required for ALTER KEYSPCE, ALTER TABLE, CREATE INDEX, DROP INDEX - AUTHORIZE: required for GRANT, REVOKE - CREATE: required for CREATE KEYSPACE, CREATE TABLE - DROP: required for DROP KEYSPACE, DROP TABLE - MODIFY: required for INSERT, DELETE, UPDATE, TRUNCATE - SELECT: required for SELECT - """ + return 'listUsersStmt' + def help_create_role(self): - print """ - CREATE ROLE <rolename>; - - CREATE ROLE creates a new Cassandra role. - Only superusers can issue CREATE ROLE requests. - To create a superuser account use SUPERUSER option (NOSUPERUSER is the default). - """ - ++ return 'createRoleStmt' + def help_drop_role(self): - print """ - DROP ROLE <rolename>; - - DROP ROLE removes an existing role. You have to be logged in as a superuser - to issue a DROP ROLE statement. - """ - ++ return 'dropRoleStmt' + def help_list_roles(self): - print """ - LIST ROLES [OF [ROLE <rolename> | USER <username>] [NORECURSIVE]]; ++ return 'listRolesStmt' + - Only superusers can use the OF clause to list the roles granted to a role or user. - If a superuser omits the OF clause then all the created roles will be listed. - If a non-superuser calls LIST ROLES then the roles granted to that user are listed. - If NORECURSIVE is provided then only directly granted roles are listed. - """ - - def help_grant_role(self): - print """ - GRANT ROLE <rolename> TO [ROLE <rolename> | USER <username>] - - Grant the specified role to another role or user. You have to be logged - in as superuser to issue a GRANT ROLE statement. - """ - - def help_revoke_role(self): - print """ - REVOKE ROLE <rolename> FROM [ROLE <rolename> | USER <username>] + def help_permissions(self): + return 'permissions' + def help_list_permissions(self): + return 'listPermissionsStmt' - Revoke the specified role from another role or user. You have to be logged - in as superuser to issue a REVOKE ROLE statement. - """ + def help_grant(self): + return 'grantRoleStmt' + def help_revoke(self): + return 'revokeRoleStmt'
