client Package

client Package

blob Module

class crate.client.blob.BlobContainer(container_name, connection)

Bases: object

class that represents a blob collection in crate.

can be used to download, upload and delete blobs

delete(digest)

Delete a blob

Parameters:digest – the hex digest of the blob to be deleted
Returns:True if blob existed
exists(digest)

Check if a blob exists

Parameters:digest – Hex digest of the blob
Returns:Boolean indicating existence of the blob
get(digest)

Return the contents of a blob

Parameters:digest – the hex digest of the blob to return
Returns:generator returning chunks of data
put(f, digest=None)

Upload a blob

Parameters:
  • f – File object to be uploaded (required to support seek if digest is not provided)
  • digest – Optional SHA-1 hex digest of the file contents. Gets computed before actual upload if not provided, which requires an extra file read.
Returns:

The hex digest of the uploaded blob if not provided in the call. Otherwise a boolean indicating if the blob has been newly created

compat Module

crate.client.compat.cprint(s)

connection Module

class crate.client.connection.Connection(servers=None, timeout=None, client=None)

Bases: object

close()

Close the connection now

commit()

Transactions are not supported, so commit is not implemented.

cursor()

Return a new Cursor Object using the connection.

get_blob_container(container_name)

Retrieve a BlobContainer for container_name

Parameters:container_name – the name of the BLOB container.
Returns:a :class:ContainerObject
crate.client.connection.connect(servers=None, timeout=None, client=None)

Create a :class:Connection object

Parameters:
  • servers – either a string in the form of ‘<hostname>:<port>’ or a list of servers in the form of [‘<hostname>:<port>’, ‘...’]
  • timeout – (optional) define the retry timeout for unreachable servers in seconds
  • client – (optional - for testing) client used to communicate with crate.
>>> connect(['host1:9200', 'host2:9200'])
<Connection <Client ['host1:9200', 'host2:9200']>>

crash Module

crate cli

can be used to query crate using SQL

class crate.client.crash.CrateCmd(stdin=None, stdout=None)

Bases: cmd.Cmd

cmdloop(intro=None)

Repeatedly issue a prompt, accept input, parse an initial prefix off the received input, and dispatch to action methods, passing them the remainder of the line as argument.

cols()
completedefault(text, line, begidx, endidx)

Method called to complete an input line when no command-specific complete_*() method is available.

do_EOF(s)
do_connect(server)

connect to one or more server with “connect servername:port”

do_crate(statement)

alias for do_create

do_create(statement)

execute a SQL create statement

E.g.:
“create table locations (id integer, name string)”
do_delete(statement)

execute a SQL delete statement

E.g.:
“delete from locations where name = ‘Algol’”
do_drop(statement)

execute a SQL drop statement

E.g.:
“drop table locations”
do_exit(s)
do_insert(statement)

execute a SQL insert statement

E.g.:
“insert into locations (name) values (‘Algol’)”
do_quit(*args)

exit the shell

do_select(statement)

execute a SQL select statement

E.g.:
“select name from locations where name = ‘Algol’”
do_update(statement)

execute a SQL update statement

E.g.:
“update from locations set name = ‘newName’ where name = ‘Algol’”
emptyline()

Called when an empty line is entered in response to the prompt.

execute(statement)
execute_query(statement)
keywords = ['table', 'index', 'from', 'into', 'where', 'values', 'and', 'or', 'set', 'with', 'by', 'usinginteger', 'string', 'float', 'double', 'short', 'long', 'byte', 'timestamp', 'replicas', 'clustered']
line_delimiter = ';'
multi_line_prompt = '... '
pprint(rows)
print_rows_affected(command, rowcount=0, duration=0.0)

print success status with rows affected and query duration

print_rows_selected(rowcount=0, duration=0.0)

print count of rows in result set and query duration

print_success(command, duration=0.0)

print success status only and duration

prompt = 'cr> '
crate.client.crash.main()

cursor Module

class crate.client.cursor.Cursor(connection)

Bases: object

not thread-safe by intention should not be shared between different threads

close()

Close the cursor now

description

This read-only attribute is a sequence of 7-item sequences.

execute(sql, parameters=None)

Prepare and execute a database operation (query or command).

executemany(sql, seq_of_parameters)

Prepare a database operation (query or command) and then execute it against all parameter sequences or mappings found in the sequence seq_of_parameters.

fetchall()

Fetch all (remaining) rows of a query result, returning them as a sequence of sequences (e.g. a list of tuples). Note that the cursor’s arraysize attribute can affect the performance of this operation.

fetchmany(count=None)

Fetch the next set of rows of a query result, returning a sequence of sequences (e.g. a list of tuples). An empty sequence is returned when no more rows are available.

fetchone()

Fetch the next row of a query result set, returning a single sequence, or None when no more data is available. Alias for next().

lastrowid = None
next()

Fetch the next row of a query result set, returning a single sequence, or None when no more data is available.

rowcount

This read-only attribute specifies the number of rows that the last .execute*() produced (for DQL statements like SELECT) or affected (for DML statements like UPDATE or INSERT).

setinputsizes(sizes)

Not supported method.

setoutputsize(size, column=None)

Not supported method.

exceptions Module

exception crate.client.exceptions.BlobException(table, digest)

Bases: exceptions.Exception

exception crate.client.exceptions.ConnectionError(msg=None)

Bases: crate.client.exceptions.OperationalError

exception crate.client.exceptions.DataError(msg=None)

Bases: crate.client.exceptions.DatabaseError

exception crate.client.exceptions.DatabaseError(msg=None)

Bases: crate.client.exceptions.Error

exception crate.client.exceptions.DigestNotFoundException(table, digest)

Bases: crate.client.exceptions.BlobException

exception crate.client.exceptions.Error(msg=None)

Bases: exceptions.StandardError

exception crate.client.exceptions.IntegrityError(msg=None)

Bases: crate.client.exceptions.DatabaseError

exception crate.client.exceptions.InterfaceError(msg=None)

Bases: crate.client.exceptions.Error

exception crate.client.exceptions.InternalError(msg=None)

Bases: crate.client.exceptions.DatabaseError

exception crate.client.exceptions.NotSupportedError(msg=None)

Bases: crate.client.exceptions.DatabaseError

exception crate.client.exceptions.OperationalError(msg=None)

Bases: crate.client.exceptions.DatabaseError

exception crate.client.exceptions.ProgrammingError(msg=None)

Bases: crate.client.exceptions.DatabaseError

exception crate.client.exceptions.Warning

Bases: exceptions.StandardError

http Module

class crate.client.http.Client(servers=None, timeout=None)

Bases: object

Crate connection client using crate’s HTTP API.

blob_del(table, digest)

Deletes the blob with given digest under the given table.

blob_exists(table, digest)

Returns true if the blob with the given digest exists under the given table.

blob_get(table, digest, chunk_size=131072)

Returns a file like object representing the contents of the blob with the given digest.

blob_put(table, digest, data)

Stores the contents of the file like @data object in a blob under the given table and digest.

default_server = '127.0.0.1:9200'

Default server to use if no servers are given on instantiation.

retry_interval = 30

Retry interval for failed servers in seconds.

sql(stmt, parameters=None)

Execute SQL stmt against the crate server.

sql_path = '_sql'

Crate URI path for issuing SQL statements.

test_cursor Module

class crate.client.test_cursor.CursorTest(methodName='runTest')

Bases: unittest.case.TestCase

test_execute_with_args()

test_http Module

class crate.client.test_http.HttpClientTest(methodName='runTest')

Bases: unittest.case.TestCase

test_http_error_is_re_raised(*args, **keywargs)
test_http_error_is_re_raised_in_raise_for_status(*args, **keywargs)
test_no_connection_exception()
test_programming_error_contains_http_error_response_content(*args, **keywargs)
class crate.client.test_http.ThreadSafeHttpClientTest(*args, **kwargs)

Bases: unittest.case.TestCase

Using a pool of 5 Threads to emit commands to the multiple servers through one Client-instance

check if number of servers in _inactive_servers and _active_servers always euqals the number of servers initially given.

num_commands = 1000
num_threads = 5
servers = ['127.0.0.1:9200', '127.0.0.2:9200', '127.0.0.3:9200']
test_client_threaded(*args, **keywargs)

Testing if lists of servers is handled correctly when client is used from multiple threads with some requests failing.

ATTENTION: this test is probabilistic and does not ensure that the client is indeed thread-safe in all cases, it can only show that it withstands this scenario.

thread_timeout = 5.0
crate.client.test_http.fail_sometimes_fake_request(*args, **kwargs)
crate.client.test_http.fake_request(*args, **kwargs)
crate.client.test_http.fake_request_lazy_raise(*args, **kwargs)