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(*args)

Bases: cmd.Cmd

cols()
do_EOF(arg)
do_connect(server)

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

do_delete(statement)

execute a SQL delete statement

E.g.:
“delete from locations where name = ‘Algol’
do_exit(*args)

exit the shell

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’
execute(statement)
execute_query(statement)
pprint(rows)
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)