4. AFL Operator Reference¶

The afl namespace provides direct access to SciDB AFL operators. More information on these operators can be found on the SciDB documentation.

AFL Operators can be used as follows:

sdb = connect()
x = sdb.random((3, 4))
afl = sdb.afl
query = afl.aggregate(x, 'count(*)')
query.query  # The query string
output = query.eval()  # send query to SciDB, return as a SciDB Array

4.1. Operator Reference¶

scidbpy.afl.register_operator(entry, interface=None)¶

Create a new AFL operator, based on a description dictionary

Parameters:

entry: dict with the following keys: :

name : string giving the name of the operator

doc : docstring

signature : list giving the type of each argument

interface : SciDBinterface instance

Which SciDBinterface instance to bind the operator class to

Returns:

A new AFLExpression subclass, representing the operator :

class scidbpy.afl.AFLNamespace(interface)¶

A module-like namespace for all registered operators.

Methods

`count`(array)
`papply`(array, attr, expression)	Shorthand for project(apply(array, attr, expression), attr)
`quote`(val)	Wrap the argument in single quotes.
`redimension_store`(arr_in, arr_out)

papply(array, attr, expression)¶: Shorthand for project(apply(array, attr, expression), attr)

quote(val)¶

Wrap the argument in single quotes.

Useful for AFL operators which expected quoted strings

class scidbpy.afl.adddim(srcArray, newDimName)¶

Produces a result array with one more dimension than the source array.

Parameters:

- srcArray: a source array with srcAttrs and srcDims. :

newDimName: the name of a new dimension.

Examples

Given array A <quantity: uint64, sales:double> [year, item] =

year, item, quantity, sales 2011, 2, 7, 31.64 2011, 3, 6, 19.98 2012, 1, 5, 41.65 2012, 2, 9, 40.68 2012, 3, 8, 26.64
adddim(A, loc) <quantity: uint64, sales: double> [loc, year, item] =

loc, year, item, quantity, sales 0, 2011, 2, 7, 31.64 0, 2011, 3, 6, 19.98 0, 2012, 1, 5, 41.65 0, 2012, 2, 9, 40.68 0, 2012, 3, 8, 26.64

Methods

`eval`([out, store])	Evaluate the expression if necessary, and return the result as a SciDBArray.
`toarray`()	Return the result of the expression as a numpy array

cached_result¶

Return the result if already evaluated, or None.

Returns:	A SciDBArray instance, or None :

eval(out=None, store=True, **kwargs)¶

Evaluate the expression if necessary, and return the result as a SciDBArray.

Parameters:

out : SciDBArray instance (optional)

The array to store the result in. One will be created if necessary

store : bool

If True (the default), the query will be wrapped in a store call, and wrapped in a SciDBAarray (specified by out). If false, this executes the query, but doesn’t save the result

Returns:

out : SciDBArray instance, or None

Notes

The result of eval() is cached, so subsequent calls will not trigger additional database computation

name¶: The SciDB operator name, assumed to be the same as the class name

toarray()¶: Return the result of the expression as a numpy array

class scidbpy.afl.aggregate(*args)¶

aggregate( srcArray {, AGGREGATE_CALL}+ {, groupbyDim}* ): AGGREGATE_CALL := AGGREGATE_FUNC(inputAttr) [as resultName] AGGREGATE_FUNC := approxdc | avg | count | max | min | sum | stdev

var | some_use_defined_aggregate_function

Calculates aggregates over groups of values in an array, given the aggregate types and attributes to aggregate on.

Parameters:

- srcArray: a source array with srcAttrs and srcDims. :

1 or more aggregate calls. Each aggregate call has an AGGREGATE_FUNC, an inputAttr and a resultName. The default resultName is inputAttr followed by ‘_’ and then AGGREGATE_FUNC. For instance, the default resultName for sum(sales) is ‘sales_sum’. The count aggregate may take * as the input attribute, meaning to count all the items in the group including null items. The default resultName for count(*) is ‘count’.

0 or more dimensions that together determines the grouping criteria.

Notes

All the aggregate functions ignore null values, except count(*).

Examples

Given array A <quantity: uint64, sales:double> [year, item] =

year, item, quantity, sales 2011, 2, 7, 31.64 2011, 3, 6, 19.98 2012, 1, 5, 41.65 2012, 2, 9, 40.68 2012, 3, 8, 26.64
aggregate(A, count(*), max(quantity), sum(sales), year) <count: uint64, quantity_max: uint64, sales_sum: double> [year] =

year, count, quantity_max, sales_sum 2011, 2, 7, 51.62 2012, 3, 9, 108.97

Methods

`eval`([out, store])	Evaluate the expression if necessary, and return the result as a SciDBArray.
`toarray`()	Return the result of the expression as a numpy array

cached_result¶

Return the result if already evaluated, or None.

Returns:	A SciDBArray instance, or None :

eval(out=None, store=True, **kwargs)¶

Evaluate the expression if necessary, and return the result as a SciDBArray.

Parameters:

out : SciDBArray instance (optional)

The array to store the result in. One will be created if necessary

store : bool

If True (the default), the query will be wrapped in a store call, and wrapped in a SciDBAarray (specified by out). If false, this executes the query, but doesn’t save the result

Returns:

out : SciDBArray instance, or None

Notes

The result of eval() is cached, so subsequent calls will not trigger additional database computation

name¶: The SciDB operator name, assumed to be the same as the class name

toarray()¶: Return the result of the expression as a numpy array

class scidbpy.afl.cumulate(*args)¶

cumulate ( inputArray {, AGGREGATE_ALL}+ [, aggrDim] )

AGGREGATE_CALL := AGGREGATE_FUNC ( inputAttribute ) [ AS aliasName

]: AGGREGATE_FUNC := approxdc | avg | count | max | min | sum | stdev

var | some_use_defined_aggregate_function

Calculates a running aggregate over some aggregate along some fluxVector (a single dimension of the inputArray).

Parameters:

cumulate(input, sum(v) as sum_v, count(*) as cnt, I) +-I-> J| 00 :

01 02 03 00 01 02 03 V +—-+—-+—-+—-+ +——–+——–+——–+——–+ 00 | 01 | | 02 | | 00 | (1, 1) | | (3, 2) | | +—-+—-+—-+—-+ +——–+——–+——–+——–+ 01 | | 03 | | 04 | 01 | | (3, 1) | | (7, 2) | +—-+—-+—-+—-+ +——–+——–+——–+——–+ 02 | 05 | | 06 | | 02 | (5, 1) | | (11, 2)| | +—-+—-+—-+—-+ +——–+——–+——–+——–+ 03 | | 07 | | 08 | 03 | | (7, 1) | | (15, 2)| +—-+—-+—-+—-+ +——–+——–+——–+——–+

Notes

For now, cumulate does NOT handle input array that have overlaps.

Methods

`eval`([out, store])	Evaluate the expression if necessary, and return the result as a SciDBArray.
`toarray`()	Return the result of the expression as a numpy array

cached_result¶

Return the result if already evaluated, or None.

Returns:	A SciDBArray instance, or None :

eval(out=None, store=True, **kwargs)¶

Evaluate the expression if necessary, and return the result as a SciDBArray.

Parameters:

out : SciDBArray instance (optional)

The array to store the result in. One will be created if necessary

store : bool

If True (the default), the query will be wrapped in a store call, and wrapped in a SciDBAarray (specified by out). If false, this executes the query, but doesn’t save the result

Returns:

out : SciDBArray instance, or None

Notes

The result of eval() is cached, so subsequent calls will not trigger additional database computation

name¶: The SciDB operator name, assumed to be the same as the class name

toarray()¶: Return the result of the expression as a numpy array

class scidbpy.afl.regrid(*args)¶

regrid( srcArray {, blockSize}+ {, AGGREGATE_CALL}+ ): AGGREGATE_CALL := AGGREGATE_FUNC(inputAttr) [as resultName] AGGREGATE_FUNC := approxdc | avg | count | max | min | sum | stdev

var | some_use_defined_aggregate_function

Partitions the cells in the source array into blocks (with the given blockSize in each dimension), and for each block, calculates the required aggregates.

Parameters:

- srcArray: the source array with srcAttrs and srcDims. :

A list of blockSizes, one for each dimension.

1 or more aggregate calls. Each aggregate call has an AGGREGATE_FUNC, an inputAttr and a resultName. The default resultName is inputAttr followed by ‘_’ and then AGGREGATE_FUNC. For instance, the default resultName for sum(sales) is ‘sales_sum’. The count aggregate may take * as the input attribute, meaning to count all the items in the group including null items. The default resultName for count(*) is ‘count’.

Notes

Regrid does not allow a block to span chunks. So for every dimension, the chunk interval needs to be a multiple of the block size.

Methods

`eval`([out, store])	Evaluate the expression if necessary, and return the result as a SciDBArray.
`toarray`()	Return the result of the expression as a numpy array

cached_result¶

Return the result if already evaluated, or None.

Returns:	A SciDBArray instance, or None :

eval(out=None, store=True, **kwargs)¶

Evaluate the expression if necessary, and return the result as a SciDBArray.

Parameters:

out : SciDBArray instance (optional)

The array to store the result in. One will be created if necessary

store : bool

If True (the default), the query will be wrapped in a store call, and wrapped in a SciDBAarray (specified by out). If false, this executes the query, but doesn’t save the result

Returns:

out : SciDBArray instance, or None

Notes

The result of eval() is cached, so subsequent calls will not trigger additional database computation

name¶: The SciDB operator name, assumed to be the same as the class name

toarray()¶: Return the result of the expression as a numpy array

class scidbpy.afl.window(*args)¶

window( srcArray {, leftEdge, rightEdge}+ {, AGGREGATE_CALL}+ [,

METHOD ] ): AGGREGATE_CALL := AGGREGATE_FUNC(inputAttr) [as resultName] AGGREGATE_FUNC := approxdc | avg | count | max | min | sum | stdev

var | some_use_defined_aggregate_function METHOD := ‘materialize’ | ‘probe’

Produces a result array with the same size and dimensions as the source array, where each ouput cell stores some aggregate calculated over a window around the corresponding cell in the source array. A pair of window specification values (leftEdge, rightEdge) must exist for every dimension in the source and output array.

Parameters:

- srcArray: a source array with srcAttrs and srcDims. :

leftEdge: how many cells to the left of the current cell (in one dimension) are included in the window.

rightEdge: how many cells to the right of the current cell (in one dimension) are included in the window.

1 or more aggregate calls. Each aggregate call has an AGGREGATE_FUNC, an inputAttr and a resultName. The default resultName is inputAttr followed by ‘_’ and then AGGREGATE_FUNC. For instance, the default resultName for sum(sales) is ‘sales_sum’. The count aggregate may take * as the input attribute, meaning to count all the items in the group including null items. The default resultName for count(*) is ‘count’.

An optional final argument that specifies how the operator is to perform its calculation. At the moment, we support two internal algorithms: ‘materialize’ (which materializes an entire source chunk before computing the output windows) and ‘probe’ (which probes the source array for the data in each window). In general, materializing the input is a more efficient strategy, but when we’re using thin(...) in conjunction with window(...), we’re often better off using probes, rather than materilization. This is a decision that the optimizer needs to make.

Examples

Given array A <quantity: uint64, sales:double> [year, item] =

year, item, quantity, sales 2011, 2, 7, 31.64 2011, 3, 6, 19.98 2012, 1, 5, 41.65 2012, 2, 9, 40.68 2012, 3, 8, 26.64
window(A, 0, 0, 1, 0, sum(quantity)) <quantity_sum: uint64> [year, item] =

year, item, quantity_sum 2011, 2, 7 2011, 3, 13 2012, 1, 5 2012, 2, 14 2012, 3, 17

Methods

`eval`([out, store])	Evaluate the expression if necessary, and return the result as a SciDBArray.
`toarray`()	Return the result of the expression as a numpy array

cached_result¶

Return the result if already evaluated, or None.

Returns:	A SciDBArray instance, or None :

eval(out=None, store=True, **kwargs)¶

Evaluate the expression if necessary, and return the result as a SciDBArray.

Parameters:

out : SciDBArray instance (optional)

The array to store the result in. One will be created if necessary

store : bool

If True (the default), the query will be wrapped in a store call, and wrapped in a SciDBAarray (specified by out). If false, this executes the query, but doesn’t save the result

Returns:

out : SciDBArray instance, or None

Notes

The result of eval() is cached, so subsequent calls will not trigger additional database computation

name¶: The SciDB operator name, assumed to be the same as the class name

toarray()¶: Return the result of the expression as a numpy array

class scidbpy.afl.allversions(srcArray)¶

Creates a single array containing all versions of an existing array.

Parameters:	- srcArray: a source array with srcAttrs and srcDims. :

Examples

Given array A <quantity: uint64, sales:double> [year, item] =

year, item, quantity, sales 2011, 2, 7, 31.64 2011, 3, 6, 19.98 2012, 1, 5, 41.65 2012, 2, 9, 40.68 2012, 3, 8, 26.64
allversions(A) <quantity: uint64, sales:double> [VersionNo, year, item] =

VersionNo, year, item, quantity, sales 1, 2011, 2, 7, 31.64 1, 2011, 3, 6, 19.98 1, 2012, 1, 5, 41.65 1, 2012, 2, 9, 40.68 1, 2012, 3, 8, 26.64

Methods

`eval`([out, store])	Evaluate the expression if necessary, and return the result as a SciDBArray.
`toarray`()	Return the result of the expression as a numpy array

cached_result¶

Return the result if already evaluated, or None.

Returns:	A SciDBArray instance, or None :

eval(out=None, store=True, **kwargs)¶

Evaluate the expression if necessary, and return the result as a SciDBArray.

Parameters:

out : SciDBArray instance (optional)

The array to store the result in. One will be created if necessary

store : bool

If True (the default), the query will be wrapped in a store call, and wrapped in a SciDBAarray (specified by out). If false, this executes the query, but doesn’t save the result

Returns:

out : SciDBArray instance, or None

Notes

The result of eval() is cached, so subsequent calls will not trigger additional database computation

name¶: The SciDB operator name, assumed to be the same as the class name

toarray()¶: Return the result of the expression as a numpy array

class scidbpy.afl.analyze(srcArray {, attr}*)¶

Returns an array describing the following characteristics of the specified attributes (or all the attributes, if no attribute is specified):

attribute_name
min
max
distinct_count: approximate count of distinct values.
non_null_count: the number of cells with non-null values.

Parameters:

- srcArray: a source array with srcAttrs and srcDims. :

0 or more attributes.

Notes

If multiple attributes are specified, the ordering of the attributes in the result array is determined by the ordering of the attributes in srcAttrs.
The value of attribute_number may be different from the number of an attribute in srcAttrs.

Examples

Given array A <quantity: uint64, sales:double> [year, item] =

year, item, quantity, sales 2011, 2, 7, 31.64 2011, 3, 6, 19.98 2012, 1, 5, 41.65 2012, 2, 9, 40.68 2012, 3, 8, 26.64
analyze(A) <attribute_name:string, min:string, max:string, distinct_count:uint64, non_null_count:uint64> [attribute_number] =

attribute_number, attribute_name, min, max, distinct_count,

non_null_count

0, ‘quantity’ ‘5’ ‘9’ 5, 5 1, ‘sales’ ‘19.98’ ‘41.65’ 5, 5

Methods

`eval`([out, store])	Evaluate the expression if necessary, and return the result as a SciDBArray.
`toarray`()	Return the result of the expression as a numpy array

cached_result¶

Return the result if already evaluated, or None.

Returns:	A SciDBArray instance, or None :

eval(out=None, store=True, **kwargs)¶

Evaluate the expression if necessary, and return the result as a SciDBArray.

Parameters:

out : SciDBArray instance (optional)

The array to store the result in. One will be created if necessary

store : bool

If True (the default), the query will be wrapped in a store call, and wrapped in a SciDBAarray (specified by out). If false, this executes the query, but doesn’t save the result

Returns:

out : SciDBArray instance, or None

Notes

The result of eval() is cached, so subsequent calls will not trigger additional database computation

name¶: The SciDB operator name, assumed to be the same as the class name

toarray()¶: Return the result of the expression as a numpy array

class scidbpy.afl.apply(srcArray {, newAttr, expression}+)¶

Produces a result array with new attributes and computes values for them.

Parameters:

- srcArray: a source array with srcAttrs and srcDims. :

1 or more pairs of a new attribute and the expression to compute the values for the attribute.

Examples

Given array A <quantity: uint64, sales:double> [year, item] =

year, item, quantity, sales 2011, 2, 7, 31.64 2011, 3, 6, 19.98 2012, 1, 5, 41.65 2012, 2, 9, 40.68 2012, 3, 8, 26.64
apply(A, unitprice, sales/quantity) <quantity: uint64, sales: double, unitprice: double> [year, item] =

year, item, quantity, sales, unitprice 2011, 2, 7, 31.64, 4.52 2011, 3, 6, 19.98, 3.33 2012, 1, 5, 41.65, 8.33 2012, 2, 9, 40.68, 4.52 2012, 3, 8, 26.64, 3.33

Methods

`eval`([out, store])	Evaluate the expression if necessary, and return the result as a SciDBArray.
`toarray`()	Return the result of the expression as a numpy array

cached_result¶

Return the result if already evaluated, or None.

Returns:	A SciDBArray instance, or None :

eval(out=None, store=True, **kwargs)¶

Evaluate the expression if necessary, and return the result as a SciDBArray.

Parameters:

out : SciDBArray instance (optional)

The array to store the result in. One will be created if necessary

store : bool

If True (the default), the query will be wrapped in a store call, and wrapped in a SciDBAarray (specified by out). If false, this executes the query, but doesn’t save the result

Returns:

out : SciDBArray instance, or None

Notes

The result of eval() is cached, so subsequent calls will not trigger additional database computation

name¶: The SciDB operator name, assumed to be the same as the class name

toarray()¶: Return the result of the expression as a numpy array

class scidbpy.afl.attribute_rename(srcArray {, srcAttr, newAttr}+)¶

Produces a result array the same as srcArray, but with at least one attribute renamed.

Parameters:

- srcArray: a source array with srcAttrs and srcDims. :

1 or more pairs of a source attribute and the new attribute to rename to.

Examples

Given array A <quantity: uint64, sales:double> [year, item] =

year, item, quantity, sales 2011, 2, 7, 31.64 2011, 3, 6, 19.98 2012, 1, 5, 41.65 2012, 2, 9, 40.68 2012, 3, 8, 26.64
attribute_rename(A, sales, totalsales) <quantity: uint64, totalsales:double> [year, item] =

year, item, quantity, totalsales 2011, 2, 7, 31.64 2011, 3, 6, 19.98 2012, 1, 5, 41.65 2012, 2, 9, 40.68 2012, 3, 8, 26.64

Methods

`eval`([out, store])	Evaluate the expression if necessary, and return the result as a SciDBArray.
`toarray`()	Return the result of the expression as a numpy array

cached_result¶

Return the result if already evaluated, or None.

Returns:	A SciDBArray instance, or None :

eval(out=None, store=True, **kwargs)¶

Evaluate the expression if necessary, and return the result as a SciDBArray.

Parameters:

out : SciDBArray instance (optional)

The array to store the result in. One will be created if necessary

store : bool

If True (the default), the query will be wrapped in a store call, and wrapped in a SciDBAarray (specified by out). If false, this executes the query, but doesn’t save the result

Returns:

out : SciDBArray instance, or None

Notes

The result of eval() is cached, so subsequent calls will not trigger additional database computation

name¶: The SciDB operator name, assumed to be the same as the class name

toarray()¶: Return the result of the expression as a numpy array

class scidbpy.afl.attributes(srcArray)¶

Produces a 1D result array where each cell describes one attribute of the source array.

Parameters:	- srcArray: a source array with srcAttrs and srcDims. :

Examples

Given array A <quantity: uint64, sales:double> [year, item] =

year, item, quantity, sales 2011, 2, 7, 31.64 2011, 3, 6, 19.98 2012, 1, 5, 41.65 2012, 2, 9, 40.68 2012, 3, 8, 26.64
attributes(A) <name:string, type_id:string, nullable:bool> [No] =

No, name, type_id, nullable 0, ‘quantity’, ‘uint64’, false 1, ‘sales’, ‘double’, false

Methods

`eval`([out, store])	Evaluate the expression if necessary, and return the result as a SciDBArray.
`toarray`()	Return the result of the expression as a numpy array

cached_result¶

Return the result if already evaluated, or None.

Returns:	A SciDBArray instance, or None :

eval(out=None, store=True, **kwargs)¶

Evaluate the expression if necessary, and return the result as a SciDBArray.

Parameters:

out : SciDBArray instance (optional)

The array to store the result in. One will be created if necessary

store : bool

If True (the default), the query will be wrapped in a store call, and wrapped in a SciDBAarray (specified by out). If false, this executes the query, but doesn’t save the result

Returns:

out : SciDBArray instance, or None

Notes

The result of eval() is cached, so subsequent calls will not trigger additional database computation

name¶: The SciDB operator name, assumed to be the same as the class name

toarray()¶: Return the result of the expression as a numpy array

class scidbpy.afl.bernoulli(srcArray, probability[, seed])¶

Evaluates whether to include a cell in the result array by generating a random number and checks if it is less than probability.

Parameters:

- srcArray: a source array with srcAttrs and srcDims. :

probability: the probability threshold, in [0..1]

an optional seed for the random number generator.

Examples

Given array A <quantity: uint64, sales:double> [year, item] =

year, item, quantity, sales 2011, 2, 7, 31.64 2011, 3, 6, 19.98 2012, 1, 5, 41.65 2012, 2, 9, 40.68 2012, 3, 8, 26.64
bernoulli(A, 0.5, 100) <quantity: uint64, sales:double> [year, item] =

year, item, quantity, sales 2011, 3, 6, 19.98 2012, 1, 5, 41.65 2012, 3, 8, 26.64

Methods

`eval`([out, store])	Evaluate the expression if necessary, and return the result as a SciDBArray.
`toarray`()	Return the result of the expression as a numpy array

cached_result¶

Return the result if already evaluated, or None.

Returns:	A SciDBArray instance, or None :

eval(out=None, store=True, **kwargs)¶

Evaluate the expression if necessary, and return the result as a SciDBArray.

Parameters:

out : SciDBArray instance (optional)

The array to store the result in. One will be created if necessary

store : bool

If True (the default), the query will be wrapped in a store call, and wrapped in a SciDBAarray (specified by out). If false, this executes the query, but doesn’t save the result

Returns:

out : SciDBArray instance, or None

Notes

The result of eval() is cached, so subsequent calls will not trigger additional database computation

name¶: The SciDB operator name, assumed to be the same as the class name

toarray()¶: Return the result of the expression as a numpy array

class scidbpy.afl.between(srcArray {, lowCoord}+ {, highCoord}+)¶

Produces a result array from a specified, contiguous region of a source array.

Parameters:

- srcArray: a source array with srcAttrs and srcDims. :

the low coordinates

the high coordinates

Notes

Almost the same as subarray. The only difference is that the dimensions retain the original start/end/boundaries.

Examples

Given array A <quantity: uint64, sales:double> [year, item] =

year, item, quantity, sales 2011, 2, 7, 31.64 2011, 3, 6, 19.98 2012, 1, 5, 41.65 2012, 2, 9, 40.68 2012, 3, 8, 26.64
between(A, 2011, 1, 2012, 2) <quantity: uint64, sales:double> [year, item] =

year, item, quantity, sales 2011, 2, 7, 31.64 2012, 1, 5, 41.65 2012, 2, 9, 40.68

Methods

`eval`([out, store])	Evaluate the expression if necessary, and return the result as a SciDBArray.
`toarray`()	Return the result of the expression as a numpy array

cached_result¶

Return the result if already evaluated, or None.

Returns:	A SciDBArray instance, or None :

eval(out=None, store=True, **kwargs)¶

Evaluate the expression if necessary, and return the result as a SciDBArray.

Parameters:

out : SciDBArray instance (optional)

The array to store the result in. One will be created if necessary

store : bool

If True (the default), the query will be wrapped in a store call, and wrapped in a SciDBAarray (specified by out). If false, this executes the query, but doesn’t save the result

Returns:

out : SciDBArray instance, or None

Notes

The result of eval() is cached, so subsequent calls will not trigger additional database computation

name¶: The SciDB operator name, assumed to be the same as the class name

toarray()¶: Return the result of the expression as a numpy array

class scidbpy.afl.build(schemaArray | schema, expression, mustBeConstant = false)¶

Produces a result array according to a given schema, and populates values based on the given expression. The schema must have a single attribute.

Parameters:

- schemaArray | schema: an array or a schema, from which attrs and :

dims will be used by the output array.

expression: the expression which is used to compute values for the output array.

mustBeConstant: whether the expression must be a constant.

Notes

The build operator can only take as input bounded dimensions.

Examples

Given array A <quantity: uint64> [year, item] =

year, item, quantity 2011, 2, 7 2011, 3, 6 2012, 1, 5 2012, 2, 9 2012, 3, 8
build(A, 0) <quantity: uint64> [year, item] =

year, item, quantity 2011, 1, 0 2011, 2, 0 2011, 3, 0 2012, 1, 0 2012, 2, 0 2012, 3, 0 Note that the cell (2011, 1), which was empty in the

source array, is populated.

Methods

`eval`([out, store])	Evaluate the expression if necessary, and return the result as a SciDBArray.
`toarray`()	Return the result of the expression as a numpy array

cached_result¶

Return the result if already evaluated, or None.

Returns:	A SciDBArray instance, or None :

eval(out=None, store=True, **kwargs)¶

Evaluate the expression if necessary, and return the result as a SciDBArray.

Parameters:

out : SciDBArray instance (optional)

The array to store the result in. One will be created if necessary

store : bool

If True (the default), the query will be wrapped in a store call, and wrapped in a SciDBAarray (specified by out). If false, this executes the query, but doesn’t save the result

Returns:

out : SciDBArray instance, or None

Notes

The result of eval() is cached, so subsequent calls will not trigger additional database computation

name¶: The SciDB operator name, assumed to be the same as the class name

toarray()¶: Return the result of the expression as a numpy array

class scidbpy.afl.build_sparse(srcArray | schema, expression, expressionIsNonEmpty)¶

Produces a sparse array and assigns values to its non-empty cells. The schema must have a single attribute.

Parameters:

- schemaArray | schema: an array or a schema, from which attrs and :

dims will be used by the output array.

expression: the expression which is used to compute values for the non-empty cells.

expressionIsNonEmpty: the expression which is used to compute whether a cell is not empty.

Notes

The build_sparse operator can only take as input bounded dimensions.

Examples

Given array A <quantity: uint64> [year, item] =

year, item, quantity 2011, 2, 7 2011, 3, 6 2012, 1, 5 2012, 2, 9 2012, 3, 8
build_sparse(A, 0, item!=2) <quantity: uint64> [year, item] =

year, item, quantity 2011, 1, 0 2011, 3, 0 2012, 1, 0 2012, 3, 0

Methods

`eval`([out, store])	Evaluate the expression if necessary, and return the result as a SciDBArray.
`toarray`()	Return the result of the expression as a numpy array

cached_result¶

Return the result if already evaluated, or None.

Returns:	A SciDBArray instance, or None :

eval(out=None, store=True, **kwargs)¶

Evaluate the expression if necessary, and return the result as a SciDBArray.

Parameters:

out : SciDBArray instance (optional)

The array to store the result in. One will be created if necessary

store : bool

If True (the default), the query will be wrapped in a store call, and wrapped in a SciDBAarray (specified by out). If false, this executes the query, but doesn’t save the result

Returns:

out : SciDBArray instance, or None

Notes

The result of eval() is cached, so subsequent calls will not trigger additional database computation

name¶: The SciDB operator name, assumed to be the same as the class name

toarray()¶: Return the result of the expression as a numpy array

class scidbpy.afl.cancel(queryId)¶

Cancels a query by ID.

Parameters:

- queryId: the query ID that can be obtained from the SciDB log or :

via the list() command.

Notes

This operator is designed for internal use.

Methods

`eval`([out, store])	Evaluate the expression if necessary, and return the result as a SciDBArray.
`toarray`()	Return the result of the expression as a numpy array

cached_result¶

Return the result if already evaluated, or None.

Returns:	A SciDBArray instance, or None :

eval(out=None, store=True, **kwargs)¶

Evaluate the expression if necessary, and return the result as a SciDBArray.

Parameters:

out : SciDBArray instance (optional)

The array to store the result in. One will be created if necessary

store : bool

If True (the default), the query will be wrapped in a store call, and wrapped in a SciDBAarray (specified by out). If false, this executes the query, but doesn’t save the result

Returns:

out : SciDBArray instance, or None

Notes

The result of eval() is cached, so subsequent calls will not trigger additional database computation

name¶: The SciDB operator name, assumed to be the same as the class name

toarray()¶: Return the result of the expression as a numpy array

class scidbpy.afl.cast(srcArray, schemaArray | schema)¶

Produces a result array with data from srcArray but with the provided schema. There are three primary purposes:

To change names of attributes or dimensions.
To change types of attributes
To change a non-integer dimension to an integer dimension.
To change a nulls-disallowed attribute to a nulls-allowed attribute.

Parameters:

- srcArray: a source array. :

schemaArray | schema: an array or a schema, from which attrs and dims will be used by the output array.

Examples

Given array A <quantity: uint64, sales:double> [year, item] =

year, item, quantity, sales 2011, 2, 7, 31.64 2011, 3, 6, 19.98 2012, 1, 5, 41.65 2012, 2, 9, 40.68 2012, 3, 8, 26.64
cast(A, <q:uint64, s:double>[y=2011:2012,2,0, i=1:3,3,0]) <q:uint64, s:double> [y, i] =

y, i, q, s 2011, 2, 7, 31.64 2011, 3, 6, 19.98 2012, 1, 5, 41.65 2012, 2, 9, 40.68 2012, 3, 8, 26.64

Methods

`eval`([out, store])	Evaluate the expression if necessary, and return the result as a SciDBArray.
`toarray`()	Return the result of the expression as a numpy array

cached_result¶

Return the result if already evaluated, or None.

Returns:	A SciDBArray instance, or None :

eval(out=None, store=True, **kwargs)¶

Evaluate the expression if necessary, and return the result as a SciDBArray.

Parameters:

out : SciDBArray instance (optional)

The array to store the result in. One will be created if necessary

store : bool

If True (the default), the query will be wrapped in a store call, and wrapped in a SciDBAarray (specified by out). If false, this executes the query, but doesn’t save the result

Returns:

out : SciDBArray instance, or None

Notes

The result of eval() is cached, so subsequent calls will not trigger additional database computation

name¶: The SciDB operator name, assumed to be the same as the class name

toarray()¶: Return the result of the expression as a numpy array

class scidbpy.afl.concat(srcArray1, srcArray2)¶

Produces a result array as the concatenation of two source arrays. The concatenation is performed by the first dimension.

Parameters:

- srcArray1: the first source array with srcAttrs and srcDims1. :

srcArray2: the second source array with srcAttrs and srcDim2, where srcDim2 may differ from srcDims1 only in the start/end of the first dimension.

Examples

Given array A <quantity: uint64, sales:double> [year, item] =

year, item, quantity, sales 2011, 2, 7, 31.64 2011, 3, 6, 19.98 2012, 1, 5, 41.65 2012, 2, 9, 40.68 2012, 3, 8, 26.64
concat(A, A) <quantity: uint64, sales:double> [year, item] =

year, item, quantity, sales 2011, 2, 7, 31.64 2011, 3, 6, 19.98 2012, 1, 5, 41.65 2012, 2, 9, 40.68 2012, 3, 8, 26.64 2013, 2, 7, 31.64 2013, 3, 6, 19.98 2014, 1, 5, 41.65 2014, 2, 9, 40.68 2014, 3, 8, 26.64

Methods

`eval`([out, store])	Evaluate the expression if necessary, and return the result as a SciDBArray.
`toarray`()	Return the result of the expression as a numpy array

cached_result¶

Return the result if already evaluated, or None.

Returns:	A SciDBArray instance, or None :

eval(out=None, store=True, **kwargs)¶

Evaluate the expression if necessary, and return the result as a SciDBArray.

Parameters:

out : SciDBArray instance (optional)

The array to store the result in. One will be created if necessary

store : bool

If True (the default), the query will be wrapped in a store call, and wrapped in a SciDBAarray (specified by out). If false, this executes the query, but doesn’t save the result

Returns:

out : SciDBArray instance, or None

Notes

The result of eval() is cached, so subsequent calls will not trigger additional database computation

name¶: The SciDB operator name, assumed to be the same as the class name

toarray()¶: Return the result of the expression as a numpy array

class scidbpy.afl.consume(array[, numAttrsToScanAtOnce])¶

Causes array parameter to be materialized if not already. numAttrsToScanAtOnce determines the number of attributes to scan as a group. Setting this value to ‘1’ will result in a ‘vertical’ scan—all chunks of the current attribute will be scanned before moving on to the next attribute. Setting this value to the number of attributes will result in a ‘horizontal’ scan—chunk i of every attribute will be scanned before moving on to chunk i+1

Parameters:

- array: the array to consume :

numAttrsToScanAtOnce: optional ‘stride’ of the scan, default is 1

Output array (an empty array):

<

]

Methods

`eval`([out, store])	Evaluate the expression if necessary, and return the result as a SciDBArray.
`toarray`()	Return the result of the expression as a numpy array

cached_result¶

Return the result if already evaluated, or None.

Returns:	A SciDBArray instance, or None :

eval(out=None, store=True, **kwargs)¶

Evaluate the expression if necessary, and return the result as a SciDBArray.

Parameters:

out : SciDBArray instance (optional)

The array to store the result in. One will be created if necessary

store : bool

If True (the default), the query will be wrapped in a store call, and wrapped in a SciDBAarray (specified by out). If false, this executes the query, but doesn’t save the result

Returns:

out : SciDBArray instance, or None

Notes

The result of eval() is cached, so subsequent calls will not trigger additional database computation

name¶: The SciDB operator name, assumed to be the same as the class name

toarray()¶: Return the result of the expression as a numpy array

class scidbpy.afl.cross_join(leftArray, rightArray {, attrLeft, attrRight}*)¶

Calculates the cross product of two arrays, with 0 or more equality conditions on the dimensions. Assume p pairs of equality conditions exist. The result is an (m+n-p) dimensional array. From the coordinates of each cell in the result array, a single cell in leftArray and a single cell in rightArray can be located. The cell in the result array contains the concatenation of the attributes from the two source cells. If a pair of join dimensions have different lengths, the result array uses the smaller of the two.

Parameters:

- leftArray: the left-side source array with leftAttrs and :

leftDims.

rightArray: the right-side source array with rightAttrs and rightDims.

0 or more pairs of an attribute from leftArray and an attribute from rightArray.

Notes

Joining non-integer dimensions does not work.

Examples

Given array A <quantity: uint64, sales:double> [year, item] =

year, item, quantity, sales 2011, 2, 7, 31.64 2011, 3, 6, 19.98 2012, 1, 5, 41.65 2012, 2, 9, 40.68 2012, 3, 8, 26.64
Given array B <v:uint64> [k] =

k, v 1, 10 2, 20 3, 30 4, 40 5, 50
cross_join(A, B, item, k) <quantity: uint64, sales:double, v:uint64> [year, item] =

year, item, quantity, sales, v 2011, 2, 7, 31.64, 20 2011, 3, 6, 19.98, 30 2012, 1, 5, 41.65, 10 2012, 2, 9, 40.68, 20 2012, 3, 8, 26.64, 30

Methods

`eval`([out, store])	Evaluate the expression if necessary, and return the result as a SciDBArray.
`toarray`()	Return the result of the expression as a numpy array

cached_result¶

Return the result if already evaluated, or None.

Returns:	A SciDBArray instance, or None :

eval(out=None, store=True, **kwargs)¶

Evaluate the expression if necessary, and return the result as a SciDBArray.

Parameters:

out : SciDBArray instance (optional)

The array to store the result in. One will be created if necessary

store : bool

If True (the default), the query will be wrapped in a store call, and wrapped in a SciDBAarray (specified by out). If false, this executes the query, but doesn’t save the result

Returns:

out : SciDBArray instance, or None

Notes

The result of eval() is cached, so subsequent calls will not trigger additional database computation

name¶: The SciDB operator name, assumed to be the same as the class name

toarray()¶: Return the result of the expression as a numpy array

class scidbpy.afl.deldim(srcArray)¶

Produces a result array with one fewer dimension than the source array, by deleting the first dimension which must have size 1.

Parameters:

- srcArray: a source array with dim1, dim2, ..., dim_kThe first :

dimension must have size 1.

Methods

`eval`([out, store])	Evaluate the expression if necessary, and return the result as a SciDBArray.
`toarray`()	Return the result of the expression as a numpy array

cached_result¶

Return the result if already evaluated, or None.

Returns:	A SciDBArray instance, or None :

eval(out=None, store=True, **kwargs)¶

Evaluate the expression if necessary, and return the result as a SciDBArray.

Parameters:

out : SciDBArray instance (optional)

The array to store the result in. One will be created if necessary

store : bool

If True (the default), the query will be wrapped in a store call, and wrapped in a SciDBAarray (specified by out). If false, this executes the query, but doesn’t save the result

Returns:

out : SciDBArray instance, or None

Notes

The result of eval() is cached, so subsequent calls will not trigger additional database computation

name¶: The SciDB operator name, assumed to be the same as the class name

toarray()¶: Return the result of the expression as a numpy array

class scidbpy.afl.dimensions(srcArray)¶

List the dimensions of the source array.

Parameters:	- srcArray: a source array. :

Methods

`eval`([out, store])	Evaluate the expression if necessary, and return the result as a SciDBArray.
`toarray`()	Return the result of the expression as a numpy array

cached_result¶

Return the result if already evaluated, or None.

Returns:	A SciDBArray instance, or None :

eval(out=None, store=True, **kwargs)¶

Evaluate the expression if necessary, and return the result as a SciDBArray.

Parameters:

out : SciDBArray instance (optional)

The array to store the result in. One will be created if necessary

store : bool

If True (the default), the query will be wrapped in a store call, and wrapped in a SciDBAarray (specified by out). If false, this executes the query, but doesn’t save the result

Returns:

out : SciDBArray instance, or None

Notes

The result of eval() is cached, so subsequent calls will not trigger additional database computation

name¶: The SciDB operator name, assumed to be the same as the class name

toarray()¶: Return the result of the expression as a numpy array

class scidbpy.afl.diskinfo¶

Checks disk usage.

Notes

For internal usage.

Methods

`eval`([out, store])	Evaluate the expression if necessary, and return the result as a SciDBArray.
`toarray`()	Return the result of the expression as a numpy array

cached_result¶

Return the result if already evaluated, or None.

Returns:	A SciDBArray instance, or None :

eval(out=None, store=True, **kwargs)¶

Evaluate the expression if necessary, and return the result as a SciDBArray.

Parameters:

out : SciDBArray instance (optional)

The array to store the result in. One will be created if necessary

store : bool

If True (the default), the query will be wrapped in a store call, and wrapped in a SciDBAarray (specified by out). If false, this executes the query, but doesn’t save the result

Returns:

out : SciDBArray instance, or None

Notes

The result of eval() is cached, so subsequent calls will not trigger additional database computation

name¶: The SciDB operator name, assumed to be the same as the class name

toarray()¶: Return the result of the expression as a numpy array

class scidbpy.afl.echo(str)¶

Produces a single-element array containing the input string.

Parameters:	- str: an input string. :

Notes

For internal usage.

Methods

`eval`([out, store])	Evaluate the expression if necessary, and return the result as a SciDBArray.
`toarray`()	Return the result of the expression as a numpy array

cached_result¶

Return the result if already evaluated, or None.

Returns:	A SciDBArray instance, or None :

eval(out=None, store=True, **kwargs)¶

Evaluate the expression if necessary, and return the result as a SciDBArray.

Parameters:

out : SciDBArray instance (optional)

The array to store the result in. One will be created if necessary

store : bool

If True (the default), the query will be wrapped in a store call, and wrapped in a SciDBAarray (specified by out). If false, this executes the query, but doesn’t save the result

Returns:

out : SciDBArray instance, or None

Notes

The result of eval() is cached, so subsequent calls will not trigger additional database computation

name¶: The SciDB operator name, assumed to be the same as the class name

toarray()¶: Return the result of the expression as a numpy array

class scidbpy.afl.explain_logical(query, language = 'aql')¶

Produces a single-element array containing the logical query plan.

Parameters:

- query: a query string. :

language: the language string; either ‘aql’ or ‘afl’; default is ‘aql’

Notes

For internal usage.

Methods

`eval`([out, store])	Evaluate the expression if necessary, and return the result as a SciDBArray.
`toarray`()	Return the result of the expression as a numpy array

cached_result¶

Return the result if already evaluated, or None.

Returns:	A SciDBArray instance, or None :

eval(out=None, store=True, **kwargs)¶

Evaluate the expression if necessary, and return the result as a SciDBArray.

Parameters:

out : SciDBArray instance (optional)

The array to store the result in. One will be created if necessary

store : bool

If True (the default), the query will be wrapped in a store call, and wrapped in a SciDBAarray (specified by out). If false, this executes the query, but doesn’t save the result

Returns:

out : SciDBArray instance, or None

Notes

The result of eval() is cached, so subsequent calls will not trigger additional database computation

name¶: The SciDB operator name, assumed to be the same as the class name

toarray()¶: Return the result of the expression as a numpy array

class scidbpy.afl.explain_physical(query, language = 'aql')¶

Produces a single-element array containing the physical query plan.

Parameters:

- query: a query string. :

language: the language string; either ‘aql’ or ‘afl’; default is ‘aql’

Notes

For internal usage.

Methods

`eval`([out, store])	Evaluate the expression if necessary, and return the result as a SciDBArray.
`toarray`()	Return the result of the expression as a numpy array

cached_result¶

Return the result if already evaluated, or None.

Returns:	A SciDBArray instance, or None :

eval(out=None, store=True, **kwargs)¶

Evaluate the expression if necessary, and return the result as a SciDBArray.

Parameters:

out : SciDBArray instance (optional)

The array to store the result in. One will be created if necessary

store : bool

If True (the default), the query will be wrapped in a store call, and wrapped in a SciDBAarray (specified by out). If false, this executes the query, but doesn’t save the result

Returns:

out : SciDBArray instance, or None

Notes

The result of eval() is cached, so subsequent calls will not trigger additional database computation

name¶: The SciDB operator name, assumed to be the same as the class name

toarray()¶: Return the result of the expression as a numpy array

class scidbpy.afl.filter(srcArray, expression)¶

Produces a result array by filtering out (mark as empty) the cells in the source array for which the expression evaluates to False.

Parameters:

- srcArray: a source array with srcAttrs and srcDims. :

expression: an expression which takes a cell in the source array as input and evaluates to either True or False.

Methods

`eval`([out, store])	Evaluate the expression if necessary, and return the result as a SciDBArray.
`toarray`()	Return the result of the expression as a numpy array

cached_result¶

Return the result if already evaluated, or None.

Returns:	A SciDBArray instance, or None :

eval(out=None, store=True, **kwargs)¶

Evaluate the expression if necessary, and return the result as a SciDBArray.

Parameters:

out : SciDBArray instance (optional)

The array to store the result in. One will be created if necessary

store : bool

If True (the default), the query will be wrapped in a store call, and wrapped in a SciDBAarray (specified by out). If false, this executes the query, but doesn’t save the result

Returns:

out : SciDBArray instance, or None

Notes

The result of eval() is cached, so subsequent calls will not trigger additional database computation

name¶: The SciDB operator name, assumed to be the same as the class name

toarray()¶: Return the result of the expression as a numpy array

class scidbpy.afl.help(operator)¶

Produces a single-element array containing the help information for an operator.

Parameters:	- operator: the name of an operator. :

Methods

`eval`([out, store])	Evaluate the expression if necessary, and return the result as a SciDBArray.
`toarray`()	Return the result of the expression as a numpy array

cached_result¶

Return the result if already evaluated, or None.

Returns:	A SciDBArray instance, or None :

eval(out=None, store=True, **kwargs)¶

Evaluate the expression if necessary, and return the result as a SciDBArray.

Parameters:

out : SciDBArray instance (optional)

The array to store the result in. One will be created if necessary

store : bool

If True (the default), the query will be wrapped in a store call, and wrapped in a SciDBAarray (specified by out). If false, this executes the query, but doesn’t save the result

Returns:

out : SciDBArray instance, or None

Notes

The result of eval() is cached, so subsequent calls will not trigger additional database computation

name¶: The SciDB operator name, assumed to be the same as the class name

toarray()¶: Return the result of the expression as a numpy array

class scidbpy.afl.index_lookup(*args)¶

index_lookup (input_array, index_array,: input_array.attribute_name [,output_attribute_name] [,’memory_limit=MEMORY_LIMIT’])
The input_array may have any attributes or dimensions. The index_array must have a single dimension and a single non-nullable attribute. The index array data must be sorted, unique values with no empty cells between them (though it does not necessarily need to be populated to the upper bound). The third argument must correctly refer to one of the attributes of the input array - the looked-up attribute. This attribute must have the same datatype as the only attribute of the index array. The comparison ‘<’ function must be registered in SciDB for this datatype.: The operator will create a new attribute, named input_attribute_name_index by default, or using the provided name, which will be the new last non-empty-tag attribute in the output array. The output attribute will be of type int64 nullable and will contain the respective coordinate of the corresponding input_attribute in index_array. If the corresponding input_attribute is null, or if no value for input_attribute exists in the index_array, the output attribute at that position shall be set to null. The output attribute shall be returned along all the input attributes in a fashion similar to the apply() operator. The operator uses some memory to cache a part of the index_array for fast lookup of values. By default, the size of this cache is limited to MEM_ARRAY_THRESHOLD. Note this is in addition to the memory already consumed by cached MemArrays as the operator is running. If a larger or smaller limit is desired, the ‘memory_limit’ parameter may be used. It is provided in units of megabytes and must be at least 1. The operator may be further optimized to reduce memory footprint, optimized with a more clever data distribution pattern and/or extended to use multiple index arrays at the same time.

Parameters:

input_array <..., input_attribute: type,... > [*] :

index_array <index_attribute: type not null>

[dimension=0:any,any,any]

input_attribute –the name of the input attribute [output_attribute_name] –the name for the output attribute if

desired

[‘memory_limit=MEMORY_LIMIT’] –the memory limit to use MB)

ticker_id, ‘memory_limit=1024’)

Methods

`eval`([out, store])	Evaluate the expression if necessary, and return the result as a SciDBArray.
`toarray`()	Return the result of the expression as a numpy array

cached_result¶

Return the result if already evaluated, or None.

Returns:	A SciDBArray instance, or None :

eval(out=None, store=True, **kwargs)¶

Evaluate the expression if necessary, and return the result as a SciDBArray.

Parameters:

out : SciDBArray instance (optional)

The array to store the result in. One will be created if necessary

store : bool

If True (the default), the query will be wrapped in a store call, and wrapped in a SciDBAarray (specified by out). If false, this executes the query, but doesn’t save the result

Returns:

out : SciDBArray instance, or None

Notes

The result of eval() is cached, so subsequent calls will not trigger additional database computation

name¶: The SciDB operator name, assumed to be the same as the class name

toarray()¶: Return the result of the expression as a numpy array

class scidbpy.afl.input(schemaArray | schema, filename, instance=-2, format='', maxErrors=0, shadowArray='')¶

Produces a result array and loads data from a given file, and optionally stores to shadowArray.

Parameters:

- schemaArray | schema: the array schema. :

filename: where to load data from.

instance: which instance; default is -2. ??

format: ??

maxErrors: ??

shadowArray: if provided, the result array will be written to it.

Notes

[comment from author] Must be called as INPUT(‘existing_array_name’, ‘/path/to/file/on/instance’). ?? schema not allowed??
This really needs to be modified by the author.

Methods

`eval`([out, store])	Evaluate the expression if necessary, and return the result as a SciDBArray.
`toarray`()	Return the result of the expression as a numpy array

cached_result¶

Return the result if already evaluated, or None.

Returns:	A SciDBArray instance, or None :

eval(out=None, store=True, **kwargs)¶

Evaluate the expression if necessary, and return the result as a SciDBArray.

Parameters:

out : SciDBArray instance (optional)

The array to store the result in. One will be created if necessary

store : bool

If True (the default), the query will be wrapped in a store call, and wrapped in a SciDBAarray (specified by out). If false, this executes the query, but doesn’t save the result

Returns:

out : SciDBArray instance, or None

Notes

The result of eval() is cached, so subsequent calls will not trigger additional database computation

name¶: The SciDB operator name, assumed to be the same as the class name

toarray()¶: Return the result of the expression as a numpy array

class scidbpy.afl.insert(sourceArray, targetArrayName)¶

Inserts all data from left array into the persistent targetArray. targetArray must exist with matching dimensions and attributes. targetArray must also be mutable. The operator shall create a new version of targetArray that contains all data of the array that would have been received by merge(sourceArray, targetArrayName). In other words, new data is inserted between old data and overwrites any overlapping old values. The resulting array is then returned.

Parameters:

- sourceArray the array or query that provides inserted data :

targetArrayName: the name of the persistent array inserted into

Notes

Some might wonder - if this returns the same result as merge(sourceArray, targetArrayName), then why not use store(merge())? The answer is that 1. this runs a lot faster - it does not perform a full scan of

targetArray

this also generates less chunk headers

Methods

`eval`([out, store])	Evaluate the expression if necessary, and return the result as a SciDBArray.
`toarray`()	Return the result of the expression as a numpy array

cached_result¶

Return the result if already evaluated, or None.

Returns:	A SciDBArray instance, or None :

eval(out=None, store=True, **kwargs)¶

Evaluate the expression if necessary, and return the result as a SciDBArray.

Parameters:

out : SciDBArray instance (optional)

The array to store the result in. One will be created if necessary

store : bool

If True (the default), the query will be wrapped in a store call, and wrapped in a SciDBAarray (specified by out). If false, this executes the query, but doesn’t save the result

Returns:

out : SciDBArray instance, or None

Notes

The result of eval() is cached, so subsequent calls will not trigger additional database computation

name¶: The SciDB operator name, assumed to be the same as the class name

toarray()¶: Return the result of the expression as a numpy array

class scidbpy.afl.join(leftArray, rightArray)¶

Combines the attributes of two arrays at matching dimension values. The two arrays must have the same dimension start coordinates, the same chunk size, and the same chunk overlap. The join result has the same dimension names as the first input. The cell in the result array contains the concatenation of the attributes from the two source cells. If a pair of join dimensions have different lengths, the result array uses the smaller of the two.

Parameters:

- leftArray: the left-side source array with leftAttrs and :

leftDims.

rightArray: the right-side source array with rightAttrs and rightDims.

Notes

join() is a special case of cross_join() with all pairs of dimensions given.

Methods

`eval`([out, store])	Evaluate the expression if necessary, and return the result as a SciDBArray.
`toarray`()	Return the result of the expression as a numpy array

cached_result¶

Return the result if already evaluated, or None.

Returns:	A SciDBArray instance, or None :

eval(out=None, store=True, **kwargs)¶

Evaluate the expression if necessary, and return the result as a SciDBArray.

Parameters:

out : SciDBArray instance (optional)

The array to store the result in. One will be created if necessary

store : bool

If True (the default), the query will be wrapped in a store call, and wrapped in a SciDBAarray (specified by out). If false, this executes the query, but doesn’t save the result

Returns:

out : SciDBArray instance, or None

Notes

The result of eval() is cached, so subsequent calls will not trigger additional database computation

name¶: The SciDB operator name, assumed to be the same as the class name

toarray()¶: Return the result of the expression as a numpy array

class scidbpy.afl.list(what='arrays', showSystem=false)¶

Produces a result array and loads data from a given file, and optionally stores to shadowArray. The available things to list include:

aggregates: show all the aggregate operators.
arrays: show all the arrays.
chunk descriptors: show all the chunk descriptors.
chunk map: show the chunk map.
functions: show all the functions.
instances: show all SciDB instances.
libraries: show all the libraries that are loaded in the current SciDB session.
operators: show all the operators and the libraries in which they reside.
types: show all the datatypes that SciDB supports.
queries: show all the active queries.

Parameters:

- what: what to list. :

showSystem: whether to show systems information.

Methods

`eval`([out, store])	Evaluate the expression if necessary, and return the result as a SciDBArray.
`toarray`()	Return the result of the expression as a numpy array

cached_result¶

Return the result if already evaluated, or None.

Returns:	A SciDBArray instance, or None :

eval(out=None, store=True, **kwargs)¶

Evaluate the expression if necessary, and return the result as a SciDBArray.

Parameters:

out : SciDBArray instance (optional)

The array to store the result in. One will be created if necessary

store : bool

If True (the default), the query will be wrapped in a store call, and wrapped in a SciDBAarray (specified by out). If false, this executes the query, but doesn’t save the result

Returns:

out : SciDBArray instance, or None

Notes

The result of eval() is cached, so subsequent calls will not trigger additional database computation

name¶: The SciDB operator name, assumed to be the same as the class name

toarray()¶: Return the result of the expression as a numpy array

class scidbpy.afl.load(outputArray, filename, instanceId=-2, format='', maxErrors=0, shadowArray='')¶

Loads data to an existing outputArray from a given file, and optionally stores to shadowArray.

Parameters:

- outputArray: the output array to store data into. :

filename: A path to file where to load data from.

instanceId: positive number means an instance ID on which file will be saved. -1 means to save file on every instance. -2 - on coordinator.

format: format in which file will be stored. Possible values are ‘store’, ‘lcsv+’, ‘lsparse’, ‘dcsv’, ‘opaque’, ‘(<custom plugin>=’‘>)’

maxErrors: a maximum number of errors which can take place due loading. After that exception is raised.

shadowArray: if provided a name of array where error of reading will be specified. The schema of array is the same as output array but all attribute has string data type + attribute [row_offset: int64]. It contains an error or reading every attribute with related name and row_offset - a position in file where an error was detected.

Notes

Must be called as INPUT(‘existing_array_name’, ‘/path/to/file/on/instance’).
This really needs to be checked by the author.

Methods

`eval`([out, store])	Evaluate the expression if necessary, and return the result as a SciDBArray.
`toarray`()	Return the result of the expression as a numpy array

cached_result¶

Return the result if already evaluated, or None.

Returns:	A SciDBArray instance, or None :

eval(out=None, store=True, **kwargs)¶

Evaluate the expression if necessary, and return the result as a SciDBArray.

Parameters:

out : SciDBArray instance (optional)

The array to store the result in. One will be created if necessary

store : bool

If True (the default), the query will be wrapped in a store call, and wrapped in a SciDBAarray (specified by out). If false, this executes the query, but doesn’t save the result

Returns:

out : SciDBArray instance, or None

Notes

The result of eval() is cached, so subsequent calls will not trigger additional database computation

name¶: The SciDB operator name, assumed to be the same as the class name

toarray()¶: Return the result of the expression as a numpy array

class scidbpy.afl.load_library(library)¶

Loads a SciDB plugin.

Parameters:	- library: the name of the library to load. :

Notes

A library may be unloaded using unload_library()

Methods

`eval`([out, store])	Evaluate the expression if necessary, and return the result as a SciDBArray.
`toarray`()	Return the result of the expression as a numpy array

cached_result¶

Return the result if already evaluated, or None.

Returns:	A SciDBArray instance, or None :

eval(out=None, store=True, **kwargs)¶

Evaluate the expression if necessary, and return the result as a SciDBArray.

Parameters:

out : SciDBArray instance (optional)

The array to store the result in. One will be created if necessary

store : bool

If True (the default), the query will be wrapped in a store call, and wrapped in a SciDBAarray (specified by out). If false, this executes the query, but doesn’t save the result

Returns:

out : SciDBArray instance, or None

Notes

The result of eval() is cached, so subsequent calls will not trigger additional database computation

name¶: The SciDB operator name, assumed to be the same as the class name

toarray()¶: Return the result of the expression as a numpy array

class scidbpy.afl.load_module(*args)¶

Methods

`eval`([out, store])	Evaluate the expression if necessary, and return the result as a SciDBArray.
`toarray`()	Return the result of the expression as a numpy array

cached_result¶

Return the result if already evaluated, or None.

Returns:	A SciDBArray instance, or None :

eval(out=None, store=True, **kwargs)¶

Evaluate the expression if necessary, and return the result as a SciDBArray.

Parameters:

out : SciDBArray instance (optional)

The array to store the result in. One will be created if necessary

store : bool

If True (the default), the query will be wrapped in a store call, and wrapped in a SciDBAarray (specified by out). If false, this executes the query, but doesn’t save the result

Returns:

out : SciDBArray instance, or None

Notes

The result of eval() is cached, so subsequent calls will not trigger additional database computation

name¶: The SciDB operator name, assumed to be the same as the class name

toarray()¶: Return the result of the expression as a numpy array

class scidbpy.afl.lookup(coordArray, srcArray)¶

Retrieves the elements from srcArray, using coordinates stored in coordArray.

Parameters:

- coordArray: coordDims will be used as the dims in the output :

array, coordAttrs define coordinates in srcArray.

srcArray: srcDims and srcAttrs.

Methods

`eval`([out, store])	Evaluate the expression if necessary, and return the result as a SciDBArray.
`toarray`()	Return the result of the expression as a numpy array

cached_result¶

Return the result if already evaluated, or None.

Returns:	A SciDBArray instance, or None :

eval(out=None, store=True, **kwargs)¶

Evaluate the expression if necessary, and return the result as a SciDBArray.

Parameters:

out : SciDBArray instance (optional)

The array to store the result in. One will be created if necessary

store : bool

If True (the default), the query will be wrapped in a store call, and wrapped in a SciDBAarray (specified by out). If false, this executes the query, but doesn’t save the result

Returns:

out : SciDBArray instance, or None

Notes

The result of eval() is cached, so subsequent calls will not trigger additional database computation

name¶: The SciDB operator name, assumed to be the same as the class name

toarray()¶: Return the result of the expression as a numpy array

class scidbpy.afl.materialize(srcArray, format)¶

Produces a materialized version of an source array.

Parameters:

- srcArray: the sourcce array with srcDims and srcAttrs. :

format: uint32, the materialize format.

Methods

`eval`([out, store])	Evaluate the expression if necessary, and return the result as a SciDBArray.
`toarray`()	Return the result of the expression as a numpy array

cached_result¶

Return the result if already evaluated, or None.

Returns:	A SciDBArray instance, or None :

eval(out=None, store=True, **kwargs)¶

Evaluate the expression if necessary, and return the result as a SciDBArray.

Parameters:

out : SciDBArray instance (optional)

The array to store the result in. One will be created if necessary

store : bool

If True (the default), the query will be wrapped in a store call, and wrapped in a SciDBAarray (specified by out). If false, this executes the query, but doesn’t save the result

Returns:

out : SciDBArray instance, or None

Notes

The result of eval() is cached, so subsequent calls will not trigger additional database computation

name¶: The SciDB operator name, assumed to be the same as the class name

toarray()¶: Return the result of the expression as a numpy array

class scidbpy.afl.merge(leftArray, rightArray)¶

Combines elements from the input arrays the following way: for each cell in the two inputs, if the cell of leftArray is not empty, the attributes from that cell are selected and placed in the output array; otherwise, the attributes from the corresponding cell in rightArray are taken. The two arrays should have the same attribute list, number of dimensions, and dimension start index. If the dimensions are not the same size, the output array uses the larger of the two.

Parameters:

- leftArray: the left-hand-side array. :

rightArray: the right-hand-side array.

Methods

`eval`([out, store])	Evaluate the expression if necessary, and return the result as a SciDBArray.
`toarray`()	Return the result of the expression as a numpy array

cached_result¶

Return the result if already evaluated, or None.

Returns:	A SciDBArray instance, or None :

eval(out=None, store=True, **kwargs)¶

Evaluate the expression if necessary, and return the result as a SciDBArray.

Parameters:

out : SciDBArray instance (optional)

The array to store the result in. One will be created if necessary

store : bool

If True (the default), the query will be wrapped in a store call, and wrapped in a SciDBAarray (specified by out). If false, this executes the query, but doesn’t save the result

Returns:

out : SciDBArray instance, or None

Notes

The result of eval() is cached, so subsequent calls will not trigger additional database computation

name¶: The SciDB operator name, assumed to be the same as the class name

toarray()¶: Return the result of the expression as a numpy array

class scidbpy.afl.mstat¶

Gathers mallinfo from all the instances.

Methods

`eval`([out, store])	Evaluate the expression if necessary, and return the result as a SciDBArray.
`toarray`()	Return the result of the expression as a numpy array

cached_result¶

Return the result if already evaluated, or None.

Returns:	A SciDBArray instance, or None :

eval(out=None, store=True, **kwargs)¶

Evaluate the expression if necessary, and return the result as a SciDBArray.

Parameters:

out : SciDBArray instance (optional)

The array to store the result in. One will be created if necessary

store : bool

If True (the default), the query will be wrapped in a store call, and wrapped in a SciDBAarray (specified by out). If false, this executes the query, but doesn’t save the result

Returns:

out : SciDBArray instance, or None

Notes

The result of eval() is cached, so subsequent calls will not trigger additional database computation

name¶: The SciDB operator name, assumed to be the same as the class name

toarray()¶: Return the result of the expression as a numpy array

class scidbpy.afl.normalize(srcArray)¶

Produces a result array by dividing each element of a 1-attribute vector by the square root of the sum of squares of the elements.

Parameters:

- srcArray: the source array with srcAttrs and srcDims. There :

should be exactly one attribute (of double type) and exactly one dimension.

Methods

`eval`([out, store])	Evaluate the expression if necessary, and return the result as a SciDBArray.
`toarray`()	Return the result of the expression as a numpy array

cached_result¶

Return the result if already evaluated, or None.

Returns:	A SciDBArray instance, or None :

eval(out=None, store=True, **kwargs)¶

Evaluate the expression if necessary, and return the result as a SciDBArray.

Parameters:

out : SciDBArray instance (optional)

The array to store the result in. One will be created if necessary

store : bool

If True (the default), the query will be wrapped in a store call, and wrapped in a SciDBAarray (specified by out). If false, this executes the query, but doesn’t save the result

Returns:

out : SciDBArray instance, or None

Notes

The result of eval() is cached, so subsequent calls will not trigger additional database computation

name¶: The SciDB operator name, assumed to be the same as the class name

toarray()¶: Return the result of the expression as a numpy array

class scidbpy.afl.project(srcArray {, selectedAttr}+)¶

Produces a result array that includes some attributes of the source array.

Parameters:

- srcArray: the source array with srcAttrs and srcDims. :

a list of at least one selectedAttrs from the source array.

Methods

`eval`([out, store])	Evaluate the expression if necessary, and return the result as a SciDBArray.
`toarray`()	Return the result of the expression as a numpy array

cached_result¶

Return the result if already evaluated, or None.

Returns:	A SciDBArray instance, or None :

eval(out=None, store=True, **kwargs)¶

Evaluate the expression if necessary, and return the result as a SciDBArray.

Parameters:

out : SciDBArray instance (optional)

The array to store the result in. One will be created if necessary

store : bool

If True (the default), the query will be wrapped in a store call, and wrapped in a SciDBAarray (specified by out). If false, this executes the query, but doesn’t save the result

Returns:

out : SciDBArray instance, or None

Notes

The result of eval() is cached, so subsequent calls will not trigger additional database computation

name¶: The SciDB operator name, assumed to be the same as the class name

toarray()¶: Return the result of the expression as a numpy array

class scidbpy.afl.avg_rank(srcArray[, attr {, groupbyDim}*])¶

Ranks the array elements, where each element is ranked as the average of the upper bound (UB) and lower bound (LB) rankings. The LB ranking of an element E is the number of elements less than E, plus 1. The UB ranking of an element E is the number of elements less than or equal to E, plus 1.

Parameters:

- srcArray: a source array with srcAttrs and srcDims. :

0 or 1 attribute to rank with. If no attribute is provided, the first attribute is used.

an optional list of groupbyDims used to group the elements, such that the rankings are calculated within each group. If no groupbyDim is provided, the whole array is treated as one group.

Notes

For any element with a distinct value, its UB ranking and LB ranking are equal.

Examples

Given array A <quantity: uint64, sales:double> [year, item] =

year, item, quantity, sales 2011, 2, 7, 31.64 2011, 3, 6, 19.98 2012, 1, 5, 41.65 2012, 2, 9, 40.68 2012, 3, 8, 26.64
avg_rank(A, sales, year) <sales:double, sales_rank: uint64> [year, item] =

year, item, sales, sales_rank 2011, 2, 31.64, 2 2011, 3, 19.98, 1 2012, 1, 41.65, 3 2012, 2, 40.68, 2 2012, 3, 26.64, 1

Methods

`eval`([out, store])	Evaluate the expression if necessary, and return the result as a SciDBArray.
`toarray`()	Return the result of the expression as a numpy array

cached_result¶

Return the result if already evaluated, or None.

Returns:	A SciDBArray instance, or None :

eval(out=None, store=True, **kwargs)¶

Evaluate the expression if necessary, and return the result as a SciDBArray.

Parameters:

out : SciDBArray instance (optional)

The array to store the result in. One will be created if necessary

store : bool

If True (the default), the query will be wrapped in a store call, and wrapped in a SciDBAarray (specified by out). If false, this executes the query, but doesn’t save the result

Returns:

out : SciDBArray instance, or None

Notes

The result of eval() is cached, so subsequent calls will not trigger additional database computation

name¶: The SciDB operator name, assumed to be the same as the class name

toarray()¶: Return the result of the expression as a numpy array

class scidbpy.afl.quantile(srcArray, numQuantiles[, attr {, groupbyDim}*])¶

Computes the quantiles of an array, based on the ordering of attr (within each group as specified by groupbyDim, if specified). If groupbyDim is not specified, global ordering will be performed. If attr is not specified, the first attribute will be used.

Parameters:

- srcArray: the source array with srcAttrs and srcDims. :

numQuantiles: the number of quantiles.

attr: which attribute to sort on. The default is the first attribute.

groupbyDim: if provided, the ordering will be performed among the records in the same group.

Methods

`eval`([out, store])	Evaluate the expression if necessary, and return the result as a SciDBArray.
`toarray`()	Return the result of the expression as a numpy array

cached_result¶

Return the result if already evaluated, or None.

Returns:	A SciDBArray instance, or None :

eval(out=None, store=True, **kwargs)¶

Evaluate the expression if necessary, and return the result as a SciDBArray.

Parameters:

out : SciDBArray instance (optional)

The array to store the result in. One will be created if necessary

store : bool

If True (the default), the query will be wrapped in a store call, and wrapped in a SciDBAarray (specified by out). If false, this executes the query, but doesn’t save the result

Returns:

out : SciDBArray instance, or None

Notes

The result of eval() is cached, so subsequent calls will not trigger additional database computation

name¶: The SciDB operator name, assumed to be the same as the class name

toarray()¶: Return the result of the expression as a numpy array

class scidbpy.afl.rank(srcArray[, attr {, groupbyDim}*])¶

Computes the rankings of an array, based on the ordering of attr (within each group as specified by the list of groupbyDims, if provided). If groupbyDims is not specified, global ordering will be performed. If attr is not specified, the first attribute will be used.

Parameters:

- srcArray: the source array with srcAttrs and srcDims. :

attr: which attribute to sort on. The default is the first attribute.

groupbyDim: if provided, the ordering will be performed among the records in the same group.

Methods

`eval`([out, store])	Evaluate the expression if necessary, and return the result as a SciDBArray.
`toarray`()	Return the result of the expression as a numpy array

cached_result¶

Return the result if already evaluated, or None.

Returns:	A SciDBArray instance, or None :

eval(out=None, store=True, **kwargs)¶

Evaluate the expression if necessary, and return the result as a SciDBArray.

Parameters:

out : SciDBArray instance (optional)

The array to store the result in. One will be created if necessary

store : bool

If True (the default), the query will be wrapped in a store call, and wrapped in a SciDBAarray (specified by out). If false, this executes the query, but doesn’t save the result

Returns:

out : SciDBArray instance, or None

Notes

The result of eval() is cached, so subsequent calls will not trigger additional database computation

name¶: The SciDB operator name, assumed to be the same as the class name

toarray()¶: Return the result of the expression as a numpy array

class scidbpy.afl.redimension(*args)¶

redimension( srcArray, schemaArray | schema {, AGGREGATE_CALL}* ): AGGREGATE_CALL := AGGREGATE_FUNC(inputAttr) [as resultName] AGGREGATE_FUNC := approxdc | avg | count | max | min | sum | stdev

var | some_use_defined_aggregate_function

Produces a array using some or all of the variables of a source array, potentially changing some or all of those variables from dimensions to attributes or vice versa, and optionally calculating aggregates to be included in the new array.

Parameters:

- srcArray: a source array with srcAttrs and srcDims. :

schemaArray | schema: an array or schema from which outputAttrs and outputDims can be acquired. All the dimensions in outputDims must exist either in srcAttrs or in srcDims, with one exception. One new dimension called the synthetic dimension is allowed. All the attributes in outputAttrs, which is not the result of an aggregate, must exist either in srcAttrs or in srcDims.

0 or more aggregate calls. Each aggregate call has an AGGREGATE_FUNC, an inputAttr and a resultName. The default resultName is inputAttr followed by ‘_’ and then AGGREGATE_FUNC. The resultNames must already exist in outputAttrs.

Notes

The synthetic dimension cannot co-exist with aggregates. That is, if there exists at least one aggregate call, the synthetic dimension must not exist.
When multiple values are ‘redimensioned’ into the same cell in the output array, the collision handling depends on the schema: (a) If there exists a synthetic dimension, all the values are retained in a vector along the synthetic dimension. (b) Otherwise, for an aggregate attribute, the aggregate result of the values is stored. (c) Otherwise, an arbitrary value is picked and the rest are discarded.
Current redimension() does not support Non-integer dimensions or data larger than memory.

Methods

`eval`([out, store])	Evaluate the expression if necessary, and return the result as a SciDBArray.
`toarray`()	Return the result of the expression as a numpy array

cached_result¶

Return the result if already evaluated, or None.

Returns:	A SciDBArray instance, or None :

eval(out=None, store=True, **kwargs)¶

Evaluate the expression if necessary, and return the result as a SciDBArray.

Parameters:

out : SciDBArray instance (optional)

The array to store the result in. One will be created if necessary

store : bool

If True (the default), the query will be wrapped in a store call, and wrapped in a SciDBAarray (specified by out). If false, this executes the query, but doesn’t save the result

Returns:

out : SciDBArray instance, or None

Notes

The result of eval() is cached, so subsequent calls will not trigger additional database computation

name¶: The SciDB operator name, assumed to be the same as the class name

toarray()¶: Return the result of the expression as a numpy array

class scidbpy.afl.reduce_distro(replicatedArray, partitioningSchema)¶

Makes a replicated array appear as if it has the required partitioningSchema.

Parameters:

- replicatedArray: an source array which is replicated across all :

the instances.

partitioningSchema: the desired partitioning schema.

Methods

`eval`([out, store])	Evaluate the expression if necessary, and return the result as a SciDBArray.
`toarray`()	Return the result of the expression as a numpy array

cached_result¶

Return the result if already evaluated, or None.

Returns:	A SciDBArray instance, or None :

eval(out=None, store=True, **kwargs)¶

Evaluate the expression if necessary, and return the result as a SciDBArray.

Parameters:

out : SciDBArray instance (optional)

The array to store the result in. One will be created if necessary

store : bool

If True (the default), the query will be wrapped in a store call, and wrapped in a SciDBAarray (specified by out). If false, this executes the query, but doesn’t save the result

Returns:

out : SciDBArray instance, or None

Notes

The result of eval() is cached, so subsequent calls will not trigger additional database computation

name¶: The SciDB operator name, assumed to be the same as the class name

toarray()¶: Return the result of the expression as a numpy array

class scidbpy.afl.remove(arrayToRemove)¶

Drops an array.

Parameters:	- arrayToRemove: the array to drop. :

Methods

`eval`([out, store])	Evaluate the expression if necessary, and return the result as a SciDBArray.
`toarray`()	Return the result of the expression as a numpy array

cached_result¶

Return the result if already evaluated, or None.

Returns:	A SciDBArray instance, or None :

eval(out=None, store=True, **kwargs)¶

Evaluate the expression if necessary, and return the result as a SciDBArray.

Parameters:

out : SciDBArray instance (optional)

The array to store the result in. One will be created if necessary

store : bool

If True (the default), the query will be wrapped in a store call, and wrapped in a SciDBAarray (specified by out). If false, this executes the query, but doesn’t save the result

Returns:

out : SciDBArray instance, or None

Notes

The result of eval() is cached, so subsequent calls will not trigger additional database computation

name¶: The SciDB operator name, assumed to be the same as the class name

toarray()¶: Return the result of the expression as a numpy array

class scidbpy.afl.rename(oldArray, newArray)¶

Changes the name of an array.

Parameters:

- oldArray: an existing array. :

newArray: the new name of the array.

Methods

`eval`([out, store])	Evaluate the expression if necessary, and return the result as a SciDBArray.
`toarray`()	Return the result of the expression as a numpy array

cached_result¶

Return the result if already evaluated, or None.

Returns:	A SciDBArray instance, or None :

eval(out=None, store=True, **kwargs)¶

Evaluate the expression if necessary, and return the result as a SciDBArray.

Parameters:

out : SciDBArray instance (optional)

The array to store the result in. One will be created if necessary

store : bool

If True (the default), the query will be wrapped in a store call, and wrapped in a SciDBAarray (specified by out). If false, this executes the query, but doesn’t save the result

Returns:

out : SciDBArray instance, or None

Notes

The result of eval() is cached, so subsequent calls will not trigger additional database computation

name¶: The SciDB operator name, assumed to be the same as the class name

toarray()¶: Return the result of the expression as a numpy array

class scidbpy.afl.repart(srcArray, schema)¶

Produces a result array similar to the source array, but with different chunk sizes, different chunk overlaps, or both.

Parameters:

- srcArray: the source array with srcAttrs and srcDims. :

schema: the desired schema.

Methods

`eval`([out, store])	Evaluate the expression if necessary, and return the result as a SciDBArray.
`toarray`()	Return the result of the expression as a numpy array

cached_result¶

Return the result if already evaluated, or None.

Returns:	A SciDBArray instance, or None :

eval(out=None, store=True, **kwargs)¶

Evaluate the expression if necessary, and return the result as a SciDBArray.

Parameters:

out : SciDBArray instance (optional)

The array to store the result in. One will be created if necessary

store : bool

If True (the default), the query will be wrapped in a store call, and wrapped in a SciDBAarray (specified by out). If false, this executes the query, but doesn’t save the result

Returns:

out : SciDBArray instance, or None

Notes

The result of eval() is cached, so subsequent calls will not trigger additional database computation

name¶: The SciDB operator name, assumed to be the same as the class name

toarray()¶: Return the result of the expression as a numpy array

class scidbpy.afl.reshape(srcArray, schema)¶

Produces a result array containing the same cells as, but a different shape from, the source array.

Parameters:

- srcArray: the source array with srcAttrs and srcDims. :

schema: the desired schema, with the same attributes as srcAttrs, but with different size and/or number of dimensions. The restriction is that the product of the dimension sizes is equal to the number of cells in srcArray.

Methods

`eval`([out, store])	Evaluate the expression if necessary, and return the result as a SciDBArray.
`toarray`()	Return the result of the expression as a numpy array

cached_result¶

Return the result if already evaluated, or None.

Returns:	A SciDBArray instance, or None :

eval(out=None, store=True, **kwargs)¶

Evaluate the expression if necessary, and return the result as a SciDBArray.

Parameters:

out : SciDBArray instance (optional)

The array to store the result in. One will be created if necessary

store : bool

If True (the default), the query will be wrapped in a store call, and wrapped in a SciDBAarray (specified by out). If false, this executes the query, but doesn’t save the result

Returns:

out : SciDBArray instance, or None

Notes

The result of eval() is cached, so subsequent calls will not trigger additional database computation

name¶: The SciDB operator name, assumed to be the same as the class name

toarray()¶: Return the result of the expression as a numpy array

class scidbpy.afl.reverse(srcArray)¶

Produces a result array, where the values of every dimension is reversed.

Parameters:	- srcArray: the source array with srcAttrs and srcDims. :

Methods

`eval`([out, store])	Evaluate the expression if necessary, and return the result as a SciDBArray.
`toarray`()	Return the result of the expression as a numpy array

cached_result¶

Return the result if already evaluated, or None.

Returns:	A SciDBArray instance, or None :

eval(out=None, store=True, **kwargs)¶

Evaluate the expression if necessary, and return the result as a SciDBArray.

Parameters:

out : SciDBArray instance (optional)

The array to store the result in. One will be created if necessary

store : bool

If True (the default), the query will be wrapped in a store call, and wrapped in a SciDBAarray (specified by out). If false, this executes the query, but doesn’t save the result

Returns:

out : SciDBArray instance, or None

Notes

The result of eval() is cached, so subsequent calls will not trigger additional database computation

name¶: The SciDB operator name, assumed to be the same as the class name

toarray()¶: Return the result of the expression as a numpy array

class scidbpy.afl.sample(srcArray, probability[, seed])¶

Produces a result array containing randomly sampled chunks from srcArray.

Parameters:

- srcArray: the source array with srcAttrs and srcDims. :

probability: a double value from 0 to 1, as the probability that a chunk is selected.

seed: an int64 value as the seed to the random number generator.

Methods

`eval`([out, store])	Evaluate the expression if necessary, and return the result as a SciDBArray.
`toarray`()	Return the result of the expression as a numpy array

cached_result¶

Return the result if already evaluated, or None.

Returns:	A SciDBArray instance, or None :

eval(out=None, store=True, **kwargs)¶

Evaluate the expression if necessary, and return the result as a SciDBArray.

Parameters:

out : SciDBArray instance (optional)

The array to store the result in. One will be created if necessary

store : bool

If True (the default), the query will be wrapped in a store call, and wrapped in a SciDBAarray (specified by out). If false, this executes the query, but doesn’t save the result

Returns:

out : SciDBArray instance, or None

Notes

The result of eval() is cached, so subsequent calls will not trigger additional database computation

name¶: The SciDB operator name, assumed to be the same as the class name

toarray()¶: Return the result of the expression as a numpy array

class scidbpy.afl.save(srcArray, file, instanceId = -2, format = 'store')¶

Saves the data in an array to a file.

Parameters:

- srcArray: the source array to save from. :

file: the file to save to.

instanceId: positive number means an instance ID on which file will be saved. -1 means to save file on every instance. -2 - on coordinator.

format: format in which file will be stored. Possible values are ‘store’, ‘lcsv+’, ‘lsparse’, ‘dcsv’, ‘opaque’, ‘(<custom plugin>=’‘>)’

Notes

n/a Must be called as SAVE(‘existing_array_name’, ‘/path/to/file/on/instance’)

Methods

`eval`([out, store])	Evaluate the expression if necessary, and return the result as a SciDBArray.
`toarray`()	Return the result of the expression as a numpy array

cached_result¶

Return the result if already evaluated, or None.

Returns:	A SciDBArray instance, or None :

eval(out=None, store=True, **kwargs)¶

Evaluate the expression if necessary, and return the result as a SciDBArray.

Parameters:

out : SciDBArray instance (optional)

The array to store the result in. One will be created if necessary

store : bool

If True (the default), the query will be wrapped in a store call, and wrapped in a SciDBAarray (specified by out). If false, this executes the query, but doesn’t save the result

Returns:

out : SciDBArray instance, or None

Notes

The result of eval() is cached, so subsequent calls will not trigger additional database computation

name¶: The SciDB operator name, assumed to be the same as the class name

toarray()¶: Return the result of the expression as a numpy array

class scidbpy.afl.scan(srcArray)¶

Produces a result array that is equivalent to a stored array.

Parameters:	- srcArray: the array to scan, with srcAttrs and srcDims :

Methods

`eval`([out, store])	Evaluate the expression if necessary, and return the result as a SciDBArray.
`toarray`()	Return the result of the expression as a numpy array

cached_result¶

Return the result if already evaluated, or None.

Returns:	A SciDBArray instance, or None :

eval(out=None, store=True, **kwargs)¶

Evaluate the expression if necessary, and return the result as a SciDBArray.

Parameters:

out : SciDBArray instance (optional)

The array to store the result in. One will be created if necessary

store : bool

If True (the default), the query will be wrapped in a store call, and wrapped in a SciDBAarray (specified by out). If false, this executes the query, but doesn’t save the result

Returns:

out : SciDBArray instance, or None

Notes

The result of eval() is cached, so subsequent calls will not trigger additional database computation

name¶: The SciDB operator name, assumed to be the same as the class name

toarray()¶: Return the result of the expression as a numpy array

class scidbpy.afl.setopt(option[, newValue])¶

Gets/Sets a config option at runtime.

Parameters:

- option: the config option. :

newValue: an optional new value for the config option. If provided, the option is set. Either way, the option value(s) is returned.

Methods

`eval`([out, store])	Evaluate the expression if necessary, and return the result as a SciDBArray.
`toarray`()	Return the result of the expression as a numpy array

cached_result¶

Return the result if already evaluated, or None.

Returns:	A SciDBArray instance, or None :

eval(out=None, store=True, **kwargs)¶

Evaluate the expression if necessary, and return the result as a SciDBArray.

Parameters:

out : SciDBArray instance (optional)

The array to store the result in. One will be created if necessary

store : bool

If True (the default), the query will be wrapped in a store call, and wrapped in a SciDBAarray (specified by out). If false, this executes the query, but doesn’t save the result

Returns:

out : SciDBArray instance, or None

Notes

The result of eval() is cached, so subsequent calls will not trigger additional database computation

name¶: The SciDB operator name, assumed to be the same as the class name

toarray()¶: Return the result of the expression as a numpy array

class scidbpy.afl.sg(srcArray, partitionSchema, instanceId=-1, outputArray='', isStore=true, offsetVector=null)¶

SCATTER/GATHER distributes array chunks over the instances of a cluster. The result array is returned. It is the only operator that uses the network manager. Typically this operator is inserted by the optimizer into the physical plan.

Parameters:

- srcArray: the source array, with srcAttrs and srcDims. :

partitionSchema:

0 = psReplication, 1 = psHashPartitioned, 2 = psLocalInstance, 3 = psByRow, 4 = psByCol, 5 = psUndefined.

instanceId:

-2 = to coordinator (same with 0), -1 = all instances participate, 0..#instances-1 = to a particular instance. [TO-DO: The usage of instanceId, in calculating which instance a

chunk should go to, requires further documentation.]

outputArray: if not empty, the result will be stored into this array

isStore: whether to store into the specified outputArray.

[TO-DO: Donghui believes this parameter is not needed and should

be removed.]

offsetVector: a vector of #dimensions values.

To calculate which instance a chunk belongs, the chunkPos is

augmented with the offset vector before calculation.

Methods

`eval`([out, store])	Evaluate the expression if necessary, and return the result as a SciDBArray.
`toarray`()	Return the result of the expression as a numpy array

cached_result¶

Return the result if already evaluated, or None.

Returns:	A SciDBArray instance, or None :

eval(out=None, store=True, **kwargs)¶

Evaluate the expression if necessary, and return the result as a SciDBArray.

Parameters:

out : SciDBArray instance (optional)

The array to store the result in. One will be created if necessary

store : bool

If True (the default), the query will be wrapped in a store call, and wrapped in a SciDBAarray (specified by out). If false, this executes the query, but doesn’t save the result

Returns:

out : SciDBArray instance, or None

Notes

The result of eval() is cached, so subsequent calls will not trigger additional database computation

name¶: The SciDB operator name, assumed to be the same as the class name

toarray()¶: Return the result of the expression as a numpy array

class scidbpy.afl.show(schemaArray | schema | queryString[, 'aql' | 'afl'])¶

Shows the schema of an array.

Parameters:

- schemaArray | schema | queryString: an array where the schema is :

used, the schema itself or arbitrary query string

o

Methods

`eval`([out, store])	Evaluate the expression if necessary, and return the result as a SciDBArray.
`toarray`()	Return the result of the expression as a numpy array

cached_result¶

Return the result if already evaluated, or None.

Returns:	A SciDBArray instance, or None :

eval(out=None, store=True, **kwargs)¶

Evaluate the expression if necessary, and return the result as a SciDBArray.

Parameters:

out : SciDBArray instance (optional)

The array to store the result in. One will be created if necessary

store : bool

If True (the default), the query will be wrapped in a store call, and wrapped in a SciDBAarray (specified by out). If false, this executes the query, but doesn’t save the result

Returns:

out : SciDBArray instance, or None

Notes

The result of eval() is cached, so subsequent calls will not trigger additional database computation

name¶: The SciDB operator name, assumed to be the same as the class name

toarray()¶: Return the result of the expression as a numpy array

class scidbpy.afl.slice(srcArray {, dim, dimValue}*)¶

Produces a ‘slice’ of the source array, by holding zero or more dimension values constant. The result array does not include the dimensions that are used for slicing.

Parameters:

- srcArray: the source array with srcAttrs and srcDims. :

dim: one of the dimensions to be used for slicing.

dimValue: the constant value in the dimension to slice.

Methods

`eval`([out, store])	Evaluate the expression if necessary, and return the result as a SciDBArray.
`toarray`()	Return the result of the expression as a numpy array

cached_result¶

Return the result if already evaluated, or None.

Returns:	A SciDBArray instance, or None :

eval(out=None, store=True, **kwargs)¶

Evaluate the expression if necessary, and return the result as a SciDBArray.

Parameters:

out : SciDBArray instance (optional)

The array to store the result in. One will be created if necessary

store : bool

If True (the default), the query will be wrapped in a store call, and wrapped in a SciDBAarray (specified by out). If false, this executes the query, but doesn’t save the result

Returns:

out : SciDBArray instance, or None

Notes

The result of eval() is cached, so subsequent calls will not trigger additional database computation

name¶: The SciDB operator name, assumed to be the same as the class name

toarray()¶: Return the result of the expression as a numpy array

class scidbpy.afl.sort(srcArray {, attr [asc | desc]}* {, chunkSize}?)¶

Produces a 1D array by sorting the non-empty cells of a source array.

Parameters:

- srcArray: the source array with srcAttrs and srcDim. :

attr: the list of attributes to sort by. If no attribute is provided, the first attribute will be used.

asc | desc: whether ascending or descending order of the attribute should be used. The default is asc.

chunkSize: the size of a chunk in the result array. If not provided, 1M will be used.

Notes

Assuming null < NaN < other values

Methods

`eval`([out, store])	Evaluate the expression if necessary, and return the result as a SciDBArray.
`toarray`()	Return the result of the expression as a numpy array

cached_result¶

Return the result if already evaluated, or None.

Returns:	A SciDBArray instance, or None :

eval(out=None, store=True, **kwargs)¶

Evaluate the expression if necessary, and return the result as a SciDBArray.

Parameters:

out : SciDBArray instance (optional)

The array to store the result in. One will be created if necessary

store : bool

If True (the default), the query will be wrapped in a store call, and wrapped in a SciDBAarray (specified by out). If false, this executes the query, but doesn’t save the result

Returns:

out : SciDBArray instance, or None

Notes

The result of eval() is cached, so subsequent calls will not trigger additional database computation

name¶: The SciDB operator name, assumed to be the same as the class name

toarray()¶: Return the result of the expression as a numpy array

class scidbpy.afl.sort2(srcArray {, attr [asc | desc]}* {, chunkSize}?)¶

Produces a 1D array by sorting the non-empty cells of a source array.

Parameters:

- srcArray: the source array with srcAttrs and srcDim. :

attr: the list of attributes to sort by. If no attribute is provided, the first attribute will be used.

asc | desc: whether ascending or descending order of the attribute should be used. The default is asc.

chunkSize: the size of a chunk in the result array. If not provided, 1M will be used.

Notes

Assuming null < NaN < other values

Methods

`eval`([out, store])	Evaluate the expression if necessary, and return the result as a SciDBArray.
`toarray`()	Return the result of the expression as a numpy array

cached_result¶

Return the result if already evaluated, or None.

Returns:	A SciDBArray instance, or None :

eval(out=None, store=True, **kwargs)¶

Evaluate the expression if necessary, and return the result as a SciDBArray.

Parameters:

out : SciDBArray instance (optional)

The array to store the result in. One will be created if necessary

store : bool

If True (the default), the query will be wrapped in a store call, and wrapped in a SciDBAarray (specified by out). If false, this executes the query, but doesn’t save the result

Returns:

out : SciDBArray instance, or None

Notes

The result of eval() is cached, so subsequent calls will not trigger additional database computation

name¶: The SciDB operator name, assumed to be the same as the class name

toarray()¶: Return the result of the expression as a numpy array

class scidbpy.afl.store(srcArray, outputArray)¶

Stores an array to the database. Each execution of store() causes a new version of the array to be created.

Parameters:

- srcArray: the source array with srcAttrs and srcDim. :

outputArray: an existing array in the database, with the same schema as srcArray.

Methods

`eval`([out, store])	Evaluate the expression if necessary, and return the result as a SciDBArray.
`toarray`()	Return the result of the expression as a numpy array

cached_result¶

Return the result if already evaluated, or None.

Returns:	A SciDBArray instance, or None :

eval(out=None, store=True, **kwargs)¶

Evaluate the expression if necessary, and return the result as a SciDBArray.

Parameters:

out : SciDBArray instance (optional)

The array to store the result in. One will be created if necessary

store : bool

If True (the default), the query will be wrapped in a store call, and wrapped in a SciDBAarray (specified by out). If false, this executes the query, but doesn’t save the result

Returns:

out : SciDBArray instance, or None

Notes

The result of eval() is cached, so subsequent calls will not trigger additional database computation

name¶: The SciDB operator name, assumed to be the same as the class name

toarray()¶: Return the result of the expression as a numpy array

class scidbpy.afl.subarray(srcArray {, lowCoord}+ {, highCoord}+)¶

Produces a result array from a specified, contiguous region of a source array.

Parameters:

- srcArray: a source array with srcAttrs and srcDims. :

the low coordinates

the high coordinates

Notes

Almost the same as between(). The only difference is that the dimensions are ‘cropped’.

Examples

Given array A <quantity: uint64, sales:double> [year, item] =

year, item, quantity, sales 2011, 2, 7, 31.64 2011, 3, 6, 19.98 2012, 1, 5, 41.65 2012, 2, 9, 40.68 2012, 3, 8, 26.64
subarray(A, 2011, 1, 2012, 2) <quantity: uint64, sales:double> [year, item] =

year, item, quantity, sales 0, 1, 7, 31.64 1, 0, 5, 41.65 1, 1, 9, 40.68

Methods

`eval`([out, store])	Evaluate the expression if necessary, and return the result as a SciDBArray.
`toarray`()	Return the result of the expression as a numpy array

cached_result¶

Return the result if already evaluated, or None.

Returns:	A SciDBArray instance, or None :

eval(out=None, store=True, **kwargs)¶

Evaluate the expression if necessary, and return the result as a SciDBArray.

Parameters:

out : SciDBArray instance (optional)

The array to store the result in. One will be created if necessary

store : bool

If True (the default), the query will be wrapped in a store call, and wrapped in a SciDBAarray (specified by out). If false, this executes the query, but doesn’t save the result

Returns:

out : SciDBArray instance, or None

Notes

The result of eval() is cached, so subsequent calls will not trigger additional database computation

name¶: The SciDB operator name, assumed to be the same as the class name

toarray()¶: Return the result of the expression as a numpy array

class scidbpy.afl.substitute(srcArray, substituteArray {, attr}*)¶

Produces a result array the same as srcArray, but with null values (of selected attributes) substituted using the values in substituteArray.

Parameters:

- srcArray: a source array with srcAttrs and srcDims, that may :

contain null values.

substituteArray: the array from which the values may be used to substitute the null values in srcArray. It must have a single dimension which starts at 0, and a single attribute.

An optional list of attributes to substitute. The default is to substitute all nullable attributes.

Methods

`eval`([out, store])	Evaluate the expression if necessary, and return the result as a SciDBArray.
`toarray`()	Return the result of the expression as a numpy array

cached_result¶

Return the result if already evaluated, or None.

Returns:	A SciDBArray instance, or None :

eval(out=None, store=True, **kwargs)¶

Evaluate the expression if necessary, and return the result as a SciDBArray.

Parameters:

out : SciDBArray instance (optional)

The array to store the result in. One will be created if necessary

store : bool

If True (the default), the query will be wrapped in a store call, and wrapped in a SciDBAarray (specified by out). If false, this executes the query, but doesn’t save the result

Returns:

out : SciDBArray instance, or None

Notes

The result of eval() is cached, so subsequent calls will not trigger additional database computation

name¶: The SciDB operator name, assumed to be the same as the class name

toarray()¶: Return the result of the expression as a numpy array

class scidbpy.afl.thin(srcArray {, start, step}+)¶

Selects regularly-spaced elements of the source array in each dimension. A (start, step) pair must be provided for every dimension.

Parameters:

- srcArray: a source array with srcAttrs and srcDims. :

start: the starting coordinate of a dimension.

step: how many coordinates to advance to the next coordinate to select. A step of 1 means to select everything.

Methods

`eval`([out, store])	Evaluate the expression if necessary, and return the result as a SciDBArray.
`toarray`()	Return the result of the expression as a numpy array

cached_result¶

Return the result if already evaluated, or None.

Returns:	A SciDBArray instance, or None :

eval(out=None, store=True, **kwargs)¶

Evaluate the expression if necessary, and return the result as a SciDBArray.

Parameters:

out : SciDBArray instance (optional)

The array to store the result in. One will be created if necessary

store : bool

If True (the default), the query will be wrapped in a store call, and wrapped in a SciDBAarray (specified by out). If false, this executes the query, but doesn’t save the result

Returns:

out : SciDBArray instance, or None

Notes

The result of eval() is cached, so subsequent calls will not trigger additional database computation

name¶: The SciDB operator name, assumed to be the same as the class name

toarray()¶: Return the result of the expression as a numpy array

class scidbpy.afl.transpose(srcArray)¶

Produces an array with the same data in srcArray but with the list of dimensions reversd.

Parameters:	- srcArray: a source array with srcAttrs and srcDims. :

Methods

`eval`([out, store])	Evaluate the expression if necessary, and return the result as a SciDBArray.
`toarray`()	Return the result of the expression as a numpy array

cached_result¶

Return the result if already evaluated, or None.

Returns:	A SciDBArray instance, or None :

eval(out=None, store=True, **kwargs)¶

Evaluate the expression if necessary, and return the result as a SciDBArray.

Parameters:

out : SciDBArray instance (optional)

The array to store the result in. One will be created if necessary

store : bool

If True (the default), the query will be wrapped in a store call, and wrapped in a SciDBAarray (specified by out). If false, this executes the query, but doesn’t save the result

Returns:

out : SciDBArray instance, or None

Notes

The result of eval() is cached, so subsequent calls will not trigger additional database computation

name¶: The SciDB operator name, assumed to be the same as the class name

toarray()¶: Return the result of the expression as a numpy array

class scidbpy.afl.uniq(*args)¶

uniq (input_array [,’chunk_size=CHUNK_SIZE’] )

The input array must have a single attribute of any type and a single dimension. The data in the input array must be sorted and dense. The operator is built to accept the output produced by sort() with a single attribute. The output array shall have the same attribute with the dimension i starting at 0 and chunk size of 1 million. An optional chunk_size parameter may be used to set a different output chunk size. Data is compared using a simple bitwise comparison of underlying memory. Null values are discarded from the output.

Parameters:

array <single_attribute: INPUT_ATTRIBUTE_TYPE> [single_dimension= :

*]

‘chuk_size=100000’), string_attribute_index )

Methods

`eval`([out, store])	Evaluate the expression if necessary, and return the result as a SciDBArray.
`toarray`()	Return the result of the expression as a numpy array

cached_result¶

Return the result if already evaluated, or None.

Returns:	A SciDBArray instance, or None :

eval(out=None, store=True, **kwargs)¶

Evaluate the expression if necessary, and return the result as a SciDBArray.

Parameters:

out : SciDBArray instance (optional)

The array to store the result in. One will be created if necessary

store : bool

If True (the default), the query will be wrapped in a store call, and wrapped in a SciDBAarray (specified by out). If false, this executes the query, but doesn’t save the result

Returns:

out : SciDBArray instance, or None

Notes

The result of eval() is cached, so subsequent calls will not trigger additional database computation

name¶: The SciDB operator name, assumed to be the same as the class name

toarray()¶: Return the result of the expression as a numpy array

class scidbpy.afl.unload_library(library)¶

Unloads a SciDB plugin.

Parameters:	- library: the name of the library to unload. :

Notes

This operator is the reverse of load_library().

Methods

`eval`([out, store])	Evaluate the expression if necessary, and return the result as a SciDBArray.
`toarray`()	Return the result of the expression as a numpy array

cached_result¶

Return the result if already evaluated, or None.

Returns:	A SciDBArray instance, or None :

eval(out=None, store=True, **kwargs)¶

Evaluate the expression if necessary, and return the result as a SciDBArray.

Parameters:

out : SciDBArray instance (optional)

The array to store the result in. One will be created if necessary

store : bool

If True (the default), the query will be wrapped in a store call, and wrapped in a SciDBAarray (specified by out). If false, this executes the query, but doesn’t save the result

Returns:

out : SciDBArray instance, or None

Notes

The result of eval() is cached, so subsequent calls will not trigger additional database computation

name¶: The SciDB operator name, assumed to be the same as the class name

toarray()¶: Return the result of the expression as a numpy array

class scidbpy.afl.old_unpack(srcArray, newDim)¶

Unpacks a multi-dimensional array into a single-dimensional array, creating new attributes to represent the dimensions in the source array.

Parameters:

- srcArray: a source array with srcAttrs and srcDims. :

newDim: the name of the dimension in the result 1D array.

Methods

`eval`([out, store])	Evaluate the expression if necessary, and return the result as a SciDBArray.
`toarray`()	Return the result of the expression as a numpy array

cached_result¶

Return the result if already evaluated, or None.

Returns:	A SciDBArray instance, or None :

eval(out=None, store=True, **kwargs)¶

Evaluate the expression if necessary, and return the result as a SciDBArray.

Parameters:

out : SciDBArray instance (optional)

The array to store the result in. One will be created if necessary

store : bool

If True (the default), the query will be wrapped in a store call, and wrapped in a SciDBAarray (specified by out). If false, this executes the query, but doesn’t save the result

Returns:

out : SciDBArray instance, or None

Notes

The result of eval() is cached, so subsequent calls will not trigger additional database computation

name¶: The SciDB operator name, assumed to be the same as the class name

toarray()¶: Return the result of the expression as a numpy array

class scidbpy.afl.unpack(srcArray, newDim)¶

Unpacks a multi-dimensional array into a single-dimensional array, creating new attributes to represent the dimensions in the source array.

Parameters:

- srcArray: a source array with srcAttrs and srcDims. :

newDim: the name of the dimension in the result 1D array.

Methods

`eval`([out, store])	Evaluate the expression if necessary, and return the result as a SciDBArray.
`toarray`()	Return the result of the expression as a numpy array

cached_result¶

Return the result if already evaluated, or None.

Returns:	A SciDBArray instance, or None :

eval(out=None, store=True, **kwargs)¶

Evaluate the expression if necessary, and return the result as a SciDBArray.

Parameters:

out : SciDBArray instance (optional)

The array to store the result in. One will be created if necessary

store : bool

If True (the default), the query will be wrapped in a store call, and wrapped in a SciDBAarray (specified by out). If false, this executes the query, but doesn’t save the result

Returns:

out : SciDBArray instance, or None

Notes

The result of eval() is cached, so subsequent calls will not trigger additional database computation

name¶: The SciDB operator name, assumed to be the same as the class name

toarray()¶: Return the result of the expression as a numpy array

class scidbpy.afl.variable_window(*args)¶

variable_window( srcArray, dim, leftEdge, rightEdge {,

AGGREGATE_CALL}+ ): AGGREGATE_CALL := AGGREGATE_FUNC(inputAttr) [as resultName] AGGREGATE_FUNC := approxdc | avg | count | max | min | sum | stdev

var | some_use_defined_aggregate_function

Produces a result array with the same dimensions as the source array, where each cell stores some aggregates calculated over a 1D window covering the current cell. The window has fixed number of non-empty elements. For instance, when rightEdge is 1, the window extends to the right-hand side however number of coordinatesthat are needed, to cover the next larger non-empty cell.

Parameters:

- srcArray: a source array with srcAttrs and srcDims. :

dim: along which dimension is the window defined.

leftEdge: how many cells to the left of the current cell are included in the window.

rightEdge: how many cells to the right of the current cell are included in the window.

1 or more aggregate calls. Each aggregate call has an AGGREGATE_FUNC, an inputAttr and a resultName. The default resultName is inputAttr followed by ‘_’ and then AGGREGATE_FUNC.

Notes

For a dense array, this is a special case of window().
For the aggregate function approxdc(), the attribute name is currently non-conventional. It is xxx_ApproxDC instead of xxx_approxdc. Should change.

Examples

Given array A <quantity: uint64, sales:double> [year, item] =

year, item, quantity, sales 2011, 2, 7, 31.64 2011, 3, 6, 19.98 2012, 1, 5, 41.65 2012, 2, 9, 40.68 2012, 3, 8, 26.64
variable_window(A, item, 1, 0, sum(quantity)) <quantity_sum: uint64> [year, item] =

year, item, quantity_sum 2011, 2, 7 2011, 3, 13 2012, 1, 5 2012, 2, 14 2012, 3, 17

Methods

`eval`([out, store])	Evaluate the expression if necessary, and return the result as a SciDBArray.
`toarray`()	Return the result of the expression as a numpy array

cached_result¶

Return the result if already evaluated, or None.

Returns:	A SciDBArray instance, or None :

eval(out=None, store=True, **kwargs)¶

Evaluate the expression if necessary, and return the result as a SciDBArray.

Parameters:

out : SciDBArray instance (optional)

The array to store the result in. One will be created if necessary

store : bool

If True (the default), the query will be wrapped in a store call, and wrapped in a SciDBAarray (specified by out). If false, this executes the query, but doesn’t save the result

Returns:

out : SciDBArray instance, or None

Notes

The result of eval() is cached, so subsequent calls will not trigger additional database computation

name¶: The SciDB operator name, assumed to be the same as the class name

toarray()¶: Return the result of the expression as a numpy array

class scidbpy.afl.versions(srcArray)¶

Lists all versions of an array in the database.

Parameters:	- srcArray: a source array. :

Methods

`eval`([out, store])	Evaluate the expression if necessary, and return the result as a SciDBArray.
`toarray`()	Return the result of the expression as a numpy array

cached_result¶

Return the result if already evaluated, or None.

Returns:	A SciDBArray instance, or None :

eval(out=None, store=True, **kwargs)¶

Evaluate the expression if necessary, and return the result as a SciDBArray.

Parameters:

out : SciDBArray instance (optional)

The array to store the result in. One will be created if necessary

store : bool

If True (the default), the query will be wrapped in a store call, and wrapped in a SciDBAarray (specified by out). If false, this executes the query, but doesn’t save the result

Returns:

out : SciDBArray instance, or None

Notes

The result of eval() is cached, so subsequent calls will not trigger additional database computation

name¶: The SciDB operator name, assumed to be the same as the class name

toarray()¶: Return the result of the expression as a numpy array

class scidbpy.afl.xgrid(srcArray {, scale}+)¶

Produces a result array by ‘scaling up’ the source array. Within each dimension, the operator duplicates each cell a specified number of times before moving to the next cell. A scale must be provided for every dimension.

Parameters:

- srcArray: a source array with srcAttrs and srcDims. :

scale: for each dimension, a scale is provided telling how much larger the dimension should grow.

Examples

Given array A <quantity: uint64, sales:double> [year, item] =

year, item, quantity, sales 2011, 2, 7, 31.64 2011, 3, 6, 19.98 2012, 1, 5, 41.65 2012, 2, 9, 40.68 2012, 3, 8, 26.64
xgrid(A, 1, 2) <quantity: uint64, sales:double> [year, item] =

year, item, quantity, sales 2011, 3, 7, 31.64 2011, 4, 7, 31.64 2011, 5, 6, 19.98 2011, 6, 6, 19.98 2012, 1, 5, 41.65 2012, 2, 5, 41.65 2012, 3, 9, 40.68 2012, 4, 9, 40.68 2012, 5, 8, 26.64 2012, 6, 8, 26.64

Methods

`eval`([out, store])	Evaluate the expression if necessary, and return the result as a SciDBArray.
`toarray`()	Return the result of the expression as a numpy array

cached_result¶

Return the result if already evaluated, or None.

Returns:	A SciDBArray instance, or None :

eval(out=None, store=True, **kwargs)¶

Evaluate the expression if necessary, and return the result as a SciDBArray.

Parameters:

out : SciDBArray instance (optional)

The array to store the result in. One will be created if necessary

store : bool

If True (the default), the query will be wrapped in a store call, and wrapped in a SciDBAarray (specified by out). If false, this executes the query, but doesn’t save the result

Returns:

out : SciDBArray instance, or None

Notes

The result of eval() is cached, so subsequent calls will not trigger additional database computation

name¶: The SciDB operator name, assumed to be the same as the class name

toarray()¶: Return the result of the expression as a numpy array

class scidbpy.afl.abs(*args)¶

The scalar function abs

Methods

`eval`([out, store])	Evaluate the expression if necessary, and return the result as a SciDBArray.
`toarray`()	Return the result of the expression as a numpy array

cached_result¶

Return the result if already evaluated, or None.

Returns:	A SciDBArray instance, or None :

eval(out=None, store=True, **kwargs)¶

Evaluate the expression if necessary, and return the result as a SciDBArray.

Parameters:

out : SciDBArray instance (optional)

The array to store the result in. One will be created if necessary

store : bool

If True (the default), the query will be wrapped in a store call, and wrapped in a SciDBAarray (specified by out). If false, this executes the query, but doesn’t save the result

Returns:

out : SciDBArray instance, or None

Notes

The result of eval() is cached, so subsequent calls will not trigger additional database computation

name¶: The SciDB operator name, assumed to be the same as the class name

toarray()¶: Return the result of the expression as a numpy array

class scidbpy.afl.acos(*args)¶

The scalar function acos

Methods

`eval`([out, store])	Evaluate the expression if necessary, and return the result as a SciDBArray.
`toarray`()	Return the result of the expression as a numpy array

cached_result¶

Return the result if already evaluated, or None.

Returns:	A SciDBArray instance, or None :

eval(out=None, store=True, **kwargs)¶

Evaluate the expression if necessary, and return the result as a SciDBArray.

Parameters:

out : SciDBArray instance (optional)

The array to store the result in. One will be created if necessary

store : bool

If True (the default), the query will be wrapped in a store call, and wrapped in a SciDBAarray (specified by out). If false, this executes the query, but doesn’t save the result

Returns:

out : SciDBArray instance, or None

Notes

The result of eval() is cached, so subsequent calls will not trigger additional database computation

name¶: The SciDB operator name, assumed to be the same as the class name

toarray()¶: Return the result of the expression as a numpy array

class scidbpy.afl.and(*args)¶

The scalar function and

Methods

`eval`([out, store])	Evaluate the expression if necessary, and return the result as a SciDBArray.
`toarray`()	Return the result of the expression as a numpy array

cached_result¶

Return the result if already evaluated, or None.

Returns:	A SciDBArray instance, or None :

eval(out=None, store=True, **kwargs)¶

Evaluate the expression if necessary, and return the result as a SciDBArray.

Parameters:

out : SciDBArray instance (optional)

The array to store the result in. One will be created if necessary

store : bool

If True (the default), the query will be wrapped in a store call, and wrapped in a SciDBAarray (specified by out). If false, this executes the query, but doesn’t save the result

Returns:

out : SciDBArray instance, or None

Notes

The result of eval() is cached, so subsequent calls will not trigger additional database computation

name¶: The SciDB operator name, assumed to be the same as the class name

toarray()¶: Return the result of the expression as a numpy array

class scidbpy.afl.append_offset(*args)¶

The scalar function append_offset

Methods

`eval`([out, store])	Evaluate the expression if necessary, and return the result as a SciDBArray.
`toarray`()	Return the result of the expression as a numpy array

cached_result¶

Return the result if already evaluated, or None.

Returns:	A SciDBArray instance, or None :

eval(out=None, store=True, **kwargs)¶

Evaluate the expression if necessary, and return the result as a SciDBArray.

Parameters:

out : SciDBArray instance (optional)

The array to store the result in. One will be created if necessary

store : bool

If True (the default), the query will be wrapped in a store call, and wrapped in a SciDBAarray (specified by out). If false, this executes the query, but doesn’t save the result

Returns:

out : SciDBArray instance, or None

Notes

The result of eval() is cached, so subsequent calls will not trigger additional database computation

name¶: The SciDB operator name, assumed to be the same as the class name

toarray()¶: Return the result of the expression as a numpy array

class scidbpy.afl.apply_offset(*args)¶

The scalar function apply_offset

Methods

`eval`([out, store])	Evaluate the expression if necessary, and return the result as a SciDBArray.
`toarray`()	Return the result of the expression as a numpy array

cached_result¶

Return the result if already evaluated, or None.

Returns:	A SciDBArray instance, or None :

eval(out=None, store=True, **kwargs)¶

Evaluate the expression if necessary, and return the result as a SciDBArray.

Parameters:

out : SciDBArray instance (optional)

The array to store the result in. One will be created if necessary

store : bool

If True (the default), the query will be wrapped in a store call, and wrapped in a SciDBAarray (specified by out). If false, this executes the query, but doesn’t save the result

Returns:

out : SciDBArray instance, or None

Notes

The result of eval() is cached, so subsequent calls will not trigger additional database computation

name¶: The SciDB operator name, assumed to be the same as the class name

toarray()¶: Return the result of the expression as a numpy array

class scidbpy.afl.asin(*args)¶

The scalar function asin

Methods

`eval`([out, store])	Evaluate the expression if necessary, and return the result as a SciDBArray.
`toarray`()	Return the result of the expression as a numpy array

cached_result¶

Return the result if already evaluated, or None.

Returns:	A SciDBArray instance, or None :

eval(out=None, store=True, **kwargs)¶

Evaluate the expression if necessary, and return the result as a SciDBArray.

Parameters:

out : SciDBArray instance (optional)

The array to store the result in. One will be created if necessary

store : bool

If True (the default), the query will be wrapped in a store call, and wrapped in a SciDBAarray (specified by out). If false, this executes the query, but doesn’t save the result

Returns:

out : SciDBArray instance, or None

Notes

The result of eval() is cached, so subsequent calls will not trigger additional database computation

name¶: The SciDB operator name, assumed to be the same as the class name

toarray()¶: Return the result of the expression as a numpy array

class scidbpy.afl.atan(*args)¶

The scalar function atan

Methods

`eval`([out, store])	Evaluate the expression if necessary, and return the result as a SciDBArray.
`toarray`()	Return the result of the expression as a numpy array

cached_result¶

Return the result if already evaluated, or None.

Returns:	A SciDBArray instance, or None :

eval(out=None, store=True, **kwargs)¶

Evaluate the expression if necessary, and return the result as a SciDBArray.

Parameters:

out : SciDBArray instance (optional)

The array to store the result in. One will be created if necessary

store : bool

If True (the default), the query will be wrapped in a store call, and wrapped in a SciDBAarray (specified by out). If false, this executes the query, but doesn’t save the result

Returns:

out : SciDBArray instance, or None

Notes

The result of eval() is cached, so subsequent calls will not trigger additional database computation

name¶: The SciDB operator name, assumed to be the same as the class name

toarray()¶: Return the result of the expression as a numpy array

class scidbpy.afl.ceil(*args)¶

The scalar function ceil

Methods

`eval`([out, store])	Evaluate the expression if necessary, and return the result as a SciDBArray.
`toarray`()	Return the result of the expression as a numpy array

cached_result¶

Return the result if already evaluated, or None.

Returns:	A SciDBArray instance, or None :

eval(out=None, store=True, **kwargs)¶

Evaluate the expression if necessary, and return the result as a SciDBArray.

Parameters:

out : SciDBArray instance (optional)

The array to store the result in. One will be created if necessary

store : bool

If True (the default), the query will be wrapped in a store call, and wrapped in a SciDBAarray (specified by out). If false, this executes the query, but doesn’t save the result

Returns:

out : SciDBArray instance, or None

Notes

The result of eval() is cached, so subsequent calls will not trigger additional database computation

name¶: The SciDB operator name, assumed to be the same as the class name

toarray()¶: Return the result of the expression as a numpy array

class scidbpy.afl.cos(*args)¶

The scalar function cos

Methods

`eval`([out, store])	Evaluate the expression if necessary, and return the result as a SciDBArray.
`toarray`()	Return the result of the expression as a numpy array

cached_result¶

Return the result if already evaluated, or None.

Returns:	A SciDBArray instance, or None :

eval(out=None, store=True, **kwargs)¶

Evaluate the expression if necessary, and return the result as a SciDBArray.

Parameters:

out : SciDBArray instance (optional)

The array to store the result in. One will be created if necessary

store : bool

If True (the default), the query will be wrapped in a store call, and wrapped in a SciDBAarray (specified by out). If false, this executes the query, but doesn’t save the result

Returns:

out : SciDBArray instance, or None

Notes

The result of eval() is cached, so subsequent calls will not trigger additional database computation

name¶: The SciDB operator name, assumed to be the same as the class name

toarray()¶: Return the result of the expression as a numpy array

class scidbpy.afl.day_of_week(*args)¶

The scalar function day_of_week

Methods

`eval`([out, store])	Evaluate the expression if necessary, and return the result as a SciDBArray.
`toarray`()	Return the result of the expression as a numpy array

cached_result¶

Return the result if already evaluated, or None.

Returns:	A SciDBArray instance, or None :

eval(out=None, store=True, **kwargs)¶

Evaluate the expression if necessary, and return the result as a SciDBArray.

Parameters:

out : SciDBArray instance (optional)

The array to store the result in. One will be created if necessary

store : bool

If True (the default), the query will be wrapped in a store call, and wrapped in a SciDBAarray (specified by out). If false, this executes the query, but doesn’t save the result

Returns:

out : SciDBArray instance, or None

Notes

The result of eval() is cached, so subsequent calls will not trigger additional database computation

name¶: The SciDB operator name, assumed to be the same as the class name

toarray()¶: Return the result of the expression as a numpy array

class scidbpy.afl.exp(*args)¶

The scalar function exp

Methods

`eval`([out, store])	Evaluate the expression if necessary, and return the result as a SciDBArray.
`toarray`()	Return the result of the expression as a numpy array

cached_result¶

Return the result if already evaluated, or None.

Returns:	A SciDBArray instance, or None :

eval(out=None, store=True, **kwargs)¶

Evaluate the expression if necessary, and return the result as a SciDBArray.

Parameters:

out : SciDBArray instance (optional)

The array to store the result in. One will be created if necessary

store : bool

If True (the default), the query will be wrapped in a store call, and wrapped in a SciDBAarray (specified by out). If false, this executes the query, but doesn’t save the result

Returns:

out : SciDBArray instance, or None

Notes

The result of eval() is cached, so subsequent calls will not trigger additional database computation

name¶: The SciDB operator name, assumed to be the same as the class name

toarray()¶: Return the result of the expression as a numpy array

class scidbpy.afl.first_index(*args)¶

The scalar function first_index

Methods

`eval`([out, store])	Evaluate the expression if necessary, and return the result as a SciDBArray.
`toarray`()	Return the result of the expression as a numpy array

cached_result¶

Return the result if already evaluated, or None.

Returns:	A SciDBArray instance, or None :

eval(out=None, store=True, **kwargs)¶

Evaluate the expression if necessary, and return the result as a SciDBArray.

Parameters:

out : SciDBArray instance (optional)

The array to store the result in. One will be created if necessary

store : bool

If True (the default), the query will be wrapped in a store call, and wrapped in a SciDBAarray (specified by out). If false, this executes the query, but doesn’t save the result

Returns:

out : SciDBArray instance, or None

Notes

The result of eval() is cached, so subsequent calls will not trigger additional database computation

name¶: The SciDB operator name, assumed to be the same as the class name

toarray()¶: Return the result of the expression as a numpy array

class scidbpy.afl.floor(*args)¶

The scalar function floor

Methods

`eval`([out, store])	Evaluate the expression if necessary, and return the result as a SciDBArray.
`toarray`()	Return the result of the expression as a numpy array

cached_result¶

Return the result if already evaluated, or None.

Returns:	A SciDBArray instance, or None :

eval(out=None, store=True, **kwargs)¶

Evaluate the expression if necessary, and return the result as a SciDBArray.

Parameters:

out : SciDBArray instance (optional)

The array to store the result in. One will be created if necessary

store : bool

If True (the default), the query will be wrapped in a store call, and wrapped in a SciDBAarray (specified by out). If false, this executes the query, but doesn’t save the result

Returns:

out : SciDBArray instance, or None

Notes

The result of eval() is cached, so subsequent calls will not trigger additional database computation

name¶: The SciDB operator name, assumed to be the same as the class name

toarray()¶: Return the result of the expression as a numpy array

class scidbpy.afl.format(*args)¶

The scalar function format

Methods

`eval`([out, store])	Evaluate the expression if necessary, and return the result as a SciDBArray.
`toarray`()	Return the result of the expression as a numpy array

cached_result¶

Return the result if already evaluated, or None.

Returns:	A SciDBArray instance, or None :

eval(out=None, store=True, **kwargs)¶

Evaluate the expression if necessary, and return the result as a SciDBArray.

Parameters:

out : SciDBArray instance (optional)

The array to store the result in. One will be created if necessary

store : bool

If True (the default), the query will be wrapped in a store call, and wrapped in a SciDBAarray (specified by out). If false, this executes the query, but doesn’t save the result

Returns:

out : SciDBArray instance, or None

Notes

The result of eval() is cached, so subsequent calls will not trigger additional database computation

name¶: The SciDB operator name, assumed to be the same as the class name

toarray()¶: Return the result of the expression as a numpy array

class scidbpy.afl.get_offset(*args)¶

The scalar function get_offset

Methods

`eval`([out, store])	Evaluate the expression if necessary, and return the result as a SciDBArray.
`toarray`()	Return the result of the expression as a numpy array

cached_result¶

Return the result if already evaluated, or None.

Returns:	A SciDBArray instance, or None :

eval(out=None, store=True, **kwargs)¶

Evaluate the expression if necessary, and return the result as a SciDBArray.

Parameters:

out : SciDBArray instance (optional)

The array to store the result in. One will be created if necessary

store : bool

If True (the default), the query will be wrapped in a store call, and wrapped in a SciDBAarray (specified by out). If false, this executes the query, but doesn’t save the result

Returns:

out : SciDBArray instance, or None

Notes

The result of eval() is cached, so subsequent calls will not trigger additional database computation

name¶: The SciDB operator name, assumed to be the same as the class name

toarray()¶: Return the result of the expression as a numpy array

class scidbpy.afl.high(*args)¶

The scalar function high

Methods

`eval`([out, store])	Evaluate the expression if necessary, and return the result as a SciDBArray.
`toarray`()	Return the result of the expression as a numpy array

cached_result¶

Return the result if already evaluated, or None.

Returns:	A SciDBArray instance, or None :

eval(out=None, store=True, **kwargs)¶

Evaluate the expression if necessary, and return the result as a SciDBArray.

Parameters:

out : SciDBArray instance (optional)

The array to store the result in. One will be created if necessary

store : bool

If True (the default), the query will be wrapped in a store call, and wrapped in a SciDBAarray (specified by out). If false, this executes the query, but doesn’t save the result

Returns:

out : SciDBArray instance, or None

Notes

The result of eval() is cached, so subsequent calls will not trigger additional database computation

name¶: The SciDB operator name, assumed to be the same as the class name

toarray()¶: Return the result of the expression as a numpy array

class scidbpy.afl.hour_of_day(*args)¶

The scalar function hour_of_day

Methods

`eval`([out, store])	Evaluate the expression if necessary, and return the result as a SciDBArray.
`toarray`()	Return the result of the expression as a numpy array

cached_result¶

Return the result if already evaluated, or None.

Returns:	A SciDBArray instance, or None :

eval(out=None, store=True, **kwargs)¶

Evaluate the expression if necessary, and return the result as a SciDBArray.

Parameters:

out : SciDBArray instance (optional)

The array to store the result in. One will be created if necessary

store : bool

If True (the default), the query will be wrapped in a store call, and wrapped in a SciDBAarray (specified by out). If false, this executes the query, but doesn’t save the result

Returns:

out : SciDBArray instance, or None

Notes

The result of eval() is cached, so subsequent calls will not trigger additional database computation

name¶: The SciDB operator name, assumed to be the same as the class name

toarray()¶: Return the result of the expression as a numpy array

class scidbpy.afl.iif(*args)¶

The scalar function iif

Methods

`eval`([out, store])	Evaluate the expression if necessary, and return the result as a SciDBArray.
`toarray`()	Return the result of the expression as a numpy array

cached_result¶

Return the result if already evaluated, or None.

Returns:	A SciDBArray instance, or None :

eval(out=None, store=True, **kwargs)¶

Evaluate the expression if necessary, and return the result as a SciDBArray.

Parameters:

out : SciDBArray instance (optional)

The array to store the result in. One will be created if necessary

store : bool

If True (the default), the query will be wrapped in a store call, and wrapped in a SciDBAarray (specified by out). If false, this executes the query, but doesn’t save the result

Returns:

out : SciDBArray instance, or None

Notes

The result of eval() is cached, so subsequent calls will not trigger additional database computation

name¶: The SciDB operator name, assumed to be the same as the class name

toarray()¶: Return the result of the expression as a numpy array

class scidbpy.afl.instanceid(*args)¶

The scalar function instanceid

Methods

`eval`([out, store])	Evaluate the expression if necessary, and return the result as a SciDBArray.
`toarray`()	Return the result of the expression as a numpy array

cached_result¶

Return the result if already evaluated, or None.

Returns:	A SciDBArray instance, or None :

eval(out=None, store=True, **kwargs)¶

Evaluate the expression if necessary, and return the result as a SciDBArray.

Parameters:

out : SciDBArray instance (optional)

The array to store the result in. One will be created if necessary

store : bool

If True (the default), the query will be wrapped in a store call, and wrapped in a SciDBAarray (specified by out). If false, this executes the query, but doesn’t save the result

Returns:

out : SciDBArray instance, or None

Notes

The result of eval() is cached, so subsequent calls will not trigger additional database computation

name¶: The SciDB operator name, assumed to be the same as the class name

toarray()¶: Return the result of the expression as a numpy array

class scidbpy.afl.is_nan(*args)¶

The scalar function is_nan

Methods

`eval`([out, store])	Evaluate the expression if necessary, and return the result as a SciDBArray.
`toarray`()	Return the result of the expression as a numpy array

cached_result¶

Return the result if already evaluated, or None.

Returns:	A SciDBArray instance, or None :

eval(out=None, store=True, **kwargs)¶

Evaluate the expression if necessary, and return the result as a SciDBArray.

Parameters:

out : SciDBArray instance (optional)

The array to store the result in. One will be created if necessary

store : bool

If True (the default), the query will be wrapped in a store call, and wrapped in a SciDBAarray (specified by out). If false, this executes the query, but doesn’t save the result

Returns:

out : SciDBArray instance, or None

Notes

The result of eval() is cached, so subsequent calls will not trigger additional database computation

name¶: The SciDB operator name, assumed to be the same as the class name

toarray()¶: Return the result of the expression as a numpy array

class scidbpy.afl.is_null(*args)¶

The scalar function is_null

Methods

`eval`([out, store])	Evaluate the expression if necessary, and return the result as a SciDBArray.
`toarray`()	Return the result of the expression as a numpy array

cached_result¶

Return the result if already evaluated, or None.

Returns:	A SciDBArray instance, or None :

eval(out=None, store=True, **kwargs)¶

Evaluate the expression if necessary, and return the result as a SciDBArray.

Parameters:

out : SciDBArray instance (optional)

The array to store the result in. One will be created if necessary

store : bool

If True (the default), the query will be wrapped in a store call, and wrapped in a SciDBAarray (specified by out). If false, this executes the query, but doesn’t save the result

Returns:

out : SciDBArray instance, or None

Notes

The result of eval() is cached, so subsequent calls will not trigger additional database computation

name¶: The SciDB operator name, assumed to be the same as the class name

toarray()¶: Return the result of the expression as a numpy array

class scidbpy.afl.last_index(*args)¶

The scalar function last_index

Methods

`eval`([out, store])	Evaluate the expression if necessary, and return the result as a SciDBArray.
`toarray`()	Return the result of the expression as a numpy array

cached_result¶

Return the result if already evaluated, or None.

Returns:	A SciDBArray instance, or None :

eval(out=None, store=True, **kwargs)¶

Evaluate the expression if necessary, and return the result as a SciDBArray.

Parameters:

out : SciDBArray instance (optional)

The array to store the result in. One will be created if necessary

store : bool

If True (the default), the query will be wrapped in a store call, and wrapped in a SciDBAarray (specified by out). If false, this executes the query, but doesn’t save the result

Returns:

out : SciDBArray instance, or None

Notes

The result of eval() is cached, so subsequent calls will not trigger additional database computation

name¶: The SciDB operator name, assumed to be the same as the class name

toarray()¶: Return the result of the expression as a numpy array

class scidbpy.afl.length(*args)¶

The scalar function length

Methods

`eval`([out, store])	Evaluate the expression if necessary, and return the result as a SciDBArray.
`toarray`()	Return the result of the expression as a numpy array

cached_result¶

Return the result if already evaluated, or None.

Returns:	A SciDBArray instance, or None :

eval(out=None, store=True, **kwargs)¶

Evaluate the expression if necessary, and return the result as a SciDBArray.

Parameters:

out : SciDBArray instance (optional)

The array to store the result in. One will be created if necessary

store : bool

If True (the default), the query will be wrapped in a store call, and wrapped in a SciDBAarray (specified by out). If false, this executes the query, but doesn’t save the result

Returns:

out : SciDBArray instance, or None

Notes

The result of eval() is cached, so subsequent calls will not trigger additional database computation

name¶: The SciDB operator name, assumed to be the same as the class name

toarray()¶: Return the result of the expression as a numpy array

class scidbpy.afl.log(*args)¶

The scalar function log

Methods

`eval`([out, store])	Evaluate the expression if necessary, and return the result as a SciDBArray.
`toarray`()	Return the result of the expression as a numpy array

cached_result¶

Return the result if already evaluated, or None.

Returns:	A SciDBArray instance, or None :

eval(out=None, store=True, **kwargs)¶

Evaluate the expression if necessary, and return the result as a SciDBArray.

Parameters:

out : SciDBArray instance (optional)

The array to store the result in. One will be created if necessary

store : bool

If True (the default), the query will be wrapped in a store call, and wrapped in a SciDBAarray (specified by out). If false, this executes the query, but doesn’t save the result

Returns:

out : SciDBArray instance, or None

Notes

The result of eval() is cached, so subsequent calls will not trigger additional database computation

name¶: The SciDB operator name, assumed to be the same as the class name

toarray()¶: Return the result of the expression as a numpy array

class scidbpy.afl.log10(*args)¶

The scalar function log10

Methods

`eval`([out, store])	Evaluate the expression if necessary, and return the result as a SciDBArray.
`toarray`()	Return the result of the expression as a numpy array

cached_result¶

Return the result if already evaluated, or None.

Returns:	A SciDBArray instance, or None :

eval(out=None, store=True, **kwargs)¶

Evaluate the expression if necessary, and return the result as a SciDBArray.

Parameters:

out : SciDBArray instance (optional)

The array to store the result in. One will be created if necessary

store : bool

If True (the default), the query will be wrapped in a store call, and wrapped in a SciDBAarray (specified by out). If false, this executes the query, but doesn’t save the result

Returns:

out : SciDBArray instance, or None

Notes

The result of eval() is cached, so subsequent calls will not trigger additional database computation

name¶: The SciDB operator name, assumed to be the same as the class name

toarray()¶: Return the result of the expression as a numpy array

class scidbpy.afl.low(*args)¶

The scalar function low

Methods

`eval`([out, store])	Evaluate the expression if necessary, and return the result as a SciDBArray.
`toarray`()	Return the result of the expression as a numpy array

cached_result¶

Return the result if already evaluated, or None.

Returns:	A SciDBArray instance, or None :

eval(out=None, store=True, **kwargs)¶

Evaluate the expression if necessary, and return the result as a SciDBArray.

Parameters:

out : SciDBArray instance (optional)

The array to store the result in. One will be created if necessary

store : bool

If True (the default), the query will be wrapped in a store call, and wrapped in a SciDBAarray (specified by out). If false, this executes the query, but doesn’t save the result

Returns:

out : SciDBArray instance, or None

Notes

The result of eval() is cached, so subsequent calls will not trigger additional database computation

name¶: The SciDB operator name, assumed to be the same as the class name

toarray()¶: Return the result of the expression as a numpy array

class scidbpy.afl.max(*args)¶

The scalar function max

Methods

`eval`([out, store])	Evaluate the expression if necessary, and return the result as a SciDBArray.
`toarray`()	Return the result of the expression as a numpy array

cached_result¶

Return the result if already evaluated, or None.

Returns:	A SciDBArray instance, or None :

eval(out=None, store=True, **kwargs)¶

Evaluate the expression if necessary, and return the result as a SciDBArray.

Parameters:

out : SciDBArray instance (optional)

The array to store the result in. One will be created if necessary

store : bool

If True (the default), the query will be wrapped in a store call, and wrapped in a SciDBAarray (specified by out). If false, this executes the query, but doesn’t save the result

Returns:

out : SciDBArray instance, or None

Notes

The result of eval() is cached, so subsequent calls will not trigger additional database computation

name¶: The SciDB operator name, assumed to be the same as the class name

toarray()¶: Return the result of the expression as a numpy array

class scidbpy.afl.min(*args)¶

The scalar function min

Methods

`eval`([out, store])	Evaluate the expression if necessary, and return the result as a SciDBArray.
`toarray`()	Return the result of the expression as a numpy array

cached_result¶

Return the result if already evaluated, or None.

Returns:	A SciDBArray instance, or None :

eval(out=None, store=True, **kwargs)¶

Evaluate the expression if necessary, and return the result as a SciDBArray.

Parameters:

out : SciDBArray instance (optional)

The array to store the result in. One will be created if necessary

store : bool

If True (the default), the query will be wrapped in a store call, and wrapped in a SciDBAarray (specified by out). If false, this executes the query, but doesn’t save the result

Returns:

out : SciDBArray instance, or None

Notes

The result of eval() is cached, so subsequent calls will not trigger additional database computation

name¶: The SciDB operator name, assumed to be the same as the class name

toarray()¶: Return the result of the expression as a numpy array

class scidbpy.afl.missing(*args)¶

The scalar function missing

Methods

`eval`([out, store])	Evaluate the expression if necessary, and return the result as a SciDBArray.
`toarray`()	Return the result of the expression as a numpy array

cached_result¶

Return the result if already evaluated, or None.

Returns:	A SciDBArray instance, or None :

eval(out=None, store=True, **kwargs)¶

Evaluate the expression if necessary, and return the result as a SciDBArray.

Parameters:

out : SciDBArray instance (optional)

The array to store the result in. One will be created if necessary

store : bool

If True (the default), the query will be wrapped in a store call, and wrapped in a SciDBAarray (specified by out). If false, this executes the query, but doesn’t save the result

Returns:

out : SciDBArray instance, or None

Notes

The result of eval() is cached, so subsequent calls will not trigger additional database computation

name¶: The SciDB operator name, assumed to be the same as the class name

toarray()¶: Return the result of the expression as a numpy array

class scidbpy.afl.missing_reason(*args)¶

The scalar function missing_reason

Methods

`eval`([out, store])	Evaluate the expression if necessary, and return the result as a SciDBArray.
`toarray`()	Return the result of the expression as a numpy array

cached_result¶

Return the result if already evaluated, or None.

Returns:	A SciDBArray instance, or None :

eval(out=None, store=True, **kwargs)¶

Evaluate the expression if necessary, and return the result as a SciDBArray.

Parameters:

out : SciDBArray instance (optional)

The array to store the result in. One will be created if necessary

store : bool

If True (the default), the query will be wrapped in a store call, and wrapped in a SciDBAarray (specified by out). If false, this executes the query, but doesn’t save the result

Returns:

out : SciDBArray instance, or None

Notes

The result of eval() is cached, so subsequent calls will not trigger additional database computation

name¶: The SciDB operator name, assumed to be the same as the class name

toarray()¶: Return the result of the expression as a numpy array

class scidbpy.afl.not(*args)¶

The scalar function not

Methods

`eval`([out, store])	Evaluate the expression if necessary, and return the result as a SciDBArray.
`toarray`()	Return the result of the expression as a numpy array

cached_result¶

Return the result if already evaluated, or None.

Returns:	A SciDBArray instance, or None :

eval(out=None, store=True, **kwargs)¶

Evaluate the expression if necessary, and return the result as a SciDBArray.

Parameters:

out : SciDBArray instance (optional)

The array to store the result in. One will be created if necessary

store : bool

If True (the default), the query will be wrapped in a store call, and wrapped in a SciDBAarray (specified by out). If false, this executes the query, but doesn’t save the result

Returns:

out : SciDBArray instance, or None

Notes

The result of eval() is cached, so subsequent calls will not trigger additional database computation

name¶: The SciDB operator name, assumed to be the same as the class name

toarray()¶: Return the result of the expression as a numpy array

class scidbpy.afl.now(*args)¶

The scalar function now

Methods

`eval`([out, store])	Evaluate the expression if necessary, and return the result as a SciDBArray.
`toarray`()	Return the result of the expression as a numpy array

cached_result¶

Return the result if already evaluated, or None.

Returns:	A SciDBArray instance, or None :

eval(out=None, store=True, **kwargs)¶

Evaluate the expression if necessary, and return the result as a SciDBArray.

Parameters:

out : SciDBArray instance (optional)

The array to store the result in. One will be created if necessary

store : bool

If True (the default), the query will be wrapped in a store call, and wrapped in a SciDBAarray (specified by out). If false, this executes the query, but doesn’t save the result

Returns:

out : SciDBArray instance, or None

Notes

The result of eval() is cached, so subsequent calls will not trigger additional database computation

name¶: The SciDB operator name, assumed to be the same as the class name

toarray()¶: Return the result of the expression as a numpy array

class scidbpy.afl.or(*args)¶

The scalar function or

Methods

`eval`([out, store])	Evaluate the expression if necessary, and return the result as a SciDBArray.
`toarray`()	Return the result of the expression as a numpy array

cached_result¶

Return the result if already evaluated, or None.

Returns:	A SciDBArray instance, or None :

eval(out=None, store=True, **kwargs)¶

Evaluate the expression if necessary, and return the result as a SciDBArray.

Parameters:

out : SciDBArray instance (optional)

The array to store the result in. One will be created if necessary

store : bool

If True (the default), the query will be wrapped in a store call, and wrapped in a SciDBAarray (specified by out). If false, this executes the query, but doesn’t save the result

Returns:

out : SciDBArray instance, or None

Notes

The result of eval() is cached, so subsequent calls will not trigger additional database computation

name¶: The SciDB operator name, assumed to be the same as the class name

toarray()¶: Return the result of the expression as a numpy array

class scidbpy.afl.pow(*args)¶

The scalar function pow

Methods

`eval`([out, store])	Evaluate the expression if necessary, and return the result as a SciDBArray.
`toarray`()	Return the result of the expression as a numpy array

cached_result¶

Return the result if already evaluated, or None.

Returns:	A SciDBArray instance, or None :

eval(out=None, store=True, **kwargs)¶

Evaluate the expression if necessary, and return the result as a SciDBArray.

Parameters:

out : SciDBArray instance (optional)

The array to store the result in. One will be created if necessary

store : bool

If True (the default), the query will be wrapped in a store call, and wrapped in a SciDBAarray (specified by out). If false, this executes the query, but doesn’t save the result

Returns:

out : SciDBArray instance, or None

Notes

The result of eval() is cached, so subsequent calls will not trigger additional database computation

name¶: The SciDB operator name, assumed to be the same as the class name

toarray()¶: Return the result of the expression as a numpy array

class scidbpy.afl.random(*args)¶

The scalar function random

Methods

`eval`([out, store])	Evaluate the expression if necessary, and return the result as a SciDBArray.
`toarray`()	Return the result of the expression as a numpy array

cached_result¶

Return the result if already evaluated, or None.

Returns:	A SciDBArray instance, or None :

eval(out=None, store=True, **kwargs)¶

Evaluate the expression if necessary, and return the result as a SciDBArray.

Parameters:

out : SciDBArray instance (optional)

The array to store the result in. One will be created if necessary

store : bool

If True (the default), the query will be wrapped in a store call, and wrapped in a SciDBAarray (specified by out). If false, this executes the query, but doesn’t save the result

Returns:

out : SciDBArray instance, or None

Notes

The result of eval() is cached, so subsequent calls will not trigger additional database computation

name¶: The SciDB operator name, assumed to be the same as the class name

toarray()¶: Return the result of the expression as a numpy array

class scidbpy.afl.regex(*args)¶

The scalar function regex

Methods

`eval`([out, store])	Evaluate the expression if necessary, and return the result as a SciDBArray.
`toarray`()	Return the result of the expression as a numpy array

cached_result¶

Return the result if already evaluated, or None.

Returns:	A SciDBArray instance, or None :

eval(out=None, store=True, **kwargs)¶

Evaluate the expression if necessary, and return the result as a SciDBArray.

Parameters:

out : SciDBArray instance (optional)

The array to store the result in. One will be created if necessary

store : bool

If True (the default), the query will be wrapped in a store call, and wrapped in a SciDBAarray (specified by out). If false, this executes the query, but doesn’t save the result

Returns:

out : SciDBArray instance, or None

Notes

The result of eval() is cached, so subsequent calls will not trigger additional database computation

name¶: The SciDB operator name, assumed to be the same as the class name

toarray()¶: Return the result of the expression as a numpy array

class scidbpy.afl.sin(*args)¶

The scalar function sin

Methods

`eval`([out, store])	Evaluate the expression if necessary, and return the result as a SciDBArray.
`toarray`()	Return the result of the expression as a numpy array

cached_result¶

Return the result if already evaluated, or None.

Returns:	A SciDBArray instance, or None :

eval(out=None, store=True, **kwargs)¶

Evaluate the expression if necessary, and return the result as a SciDBArray.

Parameters:

out : SciDBArray instance (optional)

The array to store the result in. One will be created if necessary

store : bool

If True (the default), the query will be wrapped in a store call, and wrapped in a SciDBAarray (specified by out). If false, this executes the query, but doesn’t save the result

Returns:

out : SciDBArray instance, or None

Notes

The result of eval() is cached, so subsequent calls will not trigger additional database computation

name¶: The SciDB operator name, assumed to be the same as the class name

toarray()¶: Return the result of the expression as a numpy array

class scidbpy.afl.sqrt(*args)¶

The scalar function sqrt

Methods

`eval`([out, store])	Evaluate the expression if necessary, and return the result as a SciDBArray.
`toarray`()	Return the result of the expression as a numpy array

cached_result¶

Return the result if already evaluated, or None.

Returns:	A SciDBArray instance, or None :

eval(out=None, store=True, **kwargs)¶

Evaluate the expression if necessary, and return the result as a SciDBArray.

Parameters:

out : SciDBArray instance (optional)

The array to store the result in. One will be created if necessary

store : bool

If True (the default), the query will be wrapped in a store call, and wrapped in a SciDBAarray (specified by out). If false, this executes the query, but doesn’t save the result

Returns:

out : SciDBArray instance, or None

Notes

The result of eval() is cached, so subsequent calls will not trigger additional database computation

name¶: The SciDB operator name, assumed to be the same as the class name

toarray()¶: Return the result of the expression as a numpy array

class scidbpy.afl.strchar(*args)¶

The scalar function strchar

Methods

`eval`([out, store])	Evaluate the expression if necessary, and return the result as a SciDBArray.
`toarray`()	Return the result of the expression as a numpy array

cached_result¶

Return the result if already evaluated, or None.

Returns:	A SciDBArray instance, or None :

eval(out=None, store=True, **kwargs)¶

Evaluate the expression if necessary, and return the result as a SciDBArray.

Parameters:

out : SciDBArray instance (optional)

The array to store the result in. One will be created if necessary

store : bool

If True (the default), the query will be wrapped in a store call, and wrapped in a SciDBAarray (specified by out). If false, this executes the query, but doesn’t save the result

Returns:

out : SciDBArray instance, or None

Notes

The result of eval() is cached, so subsequent calls will not trigger additional database computation

name¶: The SciDB operator name, assumed to be the same as the class name

toarray()¶: Return the result of the expression as a numpy array

class scidbpy.afl.strftime(*args)¶

The scalar function strftime

Methods

`eval`([out, store])	Evaluate the expression if necessary, and return the result as a SciDBArray.
`toarray`()	Return the result of the expression as a numpy array

cached_result¶

Return the result if already evaluated, or None.

Returns:	A SciDBArray instance, or None :

eval(out=None, store=True, **kwargs)¶

Evaluate the expression if necessary, and return the result as a SciDBArray.

Parameters:

out : SciDBArray instance (optional)

The array to store the result in. One will be created if necessary

store : bool

If True (the default), the query will be wrapped in a store call, and wrapped in a SciDBAarray (specified by out). If false, this executes the query, but doesn’t save the result

Returns:

out : SciDBArray instance, or None

Notes

The result of eval() is cached, so subsequent calls will not trigger additional database computation

name¶: The SciDB operator name, assumed to be the same as the class name

toarray()¶: Return the result of the expression as a numpy array

class scidbpy.afl.strip_offset(*args)¶

The scalar function strip_offset

Methods

`eval`([out, store])	Evaluate the expression if necessary, and return the result as a SciDBArray.
`toarray`()	Return the result of the expression as a numpy array

cached_result¶

Return the result if already evaluated, or None.

Returns:	A SciDBArray instance, or None :

eval(out=None, store=True, **kwargs)¶

Evaluate the expression if necessary, and return the result as a SciDBArray.

Parameters:

out : SciDBArray instance (optional)

The array to store the result in. One will be created if necessary

store : bool

If True (the default), the query will be wrapped in a store call, and wrapped in a SciDBAarray (specified by out). If false, this executes the query, but doesn’t save the result

Returns:

out : SciDBArray instance, or None

Notes

The result of eval() is cached, so subsequent calls will not trigger additional database computation

name¶: The SciDB operator name, assumed to be the same as the class name

toarray()¶: Return the result of the expression as a numpy array

class scidbpy.afl.strlen(*args)¶

The scalar function strlen

Methods

`eval`([out, store])	Evaluate the expression if necessary, and return the result as a SciDBArray.
`toarray`()	Return the result of the expression as a numpy array

cached_result¶

Return the result if already evaluated, or None.

Returns:	A SciDBArray instance, or None :

eval(out=None, store=True, **kwargs)¶

Evaluate the expression if necessary, and return the result as a SciDBArray.

Parameters:

out : SciDBArray instance (optional)

The array to store the result in. One will be created if necessary

store : bool

If True (the default), the query will be wrapped in a store call, and wrapped in a SciDBAarray (specified by out). If false, this executes the query, but doesn’t save the result

Returns:

out : SciDBArray instance, or None

Notes

The result of eval() is cached, so subsequent calls will not trigger additional database computation

name¶: The SciDB operator name, assumed to be the same as the class name

toarray()¶: Return the result of the expression as a numpy array

class scidbpy.afl.substr(*args)¶

The scalar function substr

Methods

`eval`([out, store])	Evaluate the expression if necessary, and return the result as a SciDBArray.
`toarray`()	Return the result of the expression as a numpy array

cached_result¶

Return the result if already evaluated, or None.

Returns:	A SciDBArray instance, or None :

eval(out=None, store=True, **kwargs)¶

Evaluate the expression if necessary, and return the result as a SciDBArray.

Parameters:

out : SciDBArray instance (optional)

The array to store the result in. One will be created if necessary

store : bool

If True (the default), the query will be wrapped in a store call, and wrapped in a SciDBAarray (specified by out). If false, this executes the query, but doesn’t save the result

Returns:

out : SciDBArray instance, or None

Notes

The result of eval() is cached, so subsequent calls will not trigger additional database computation

name¶: The SciDB operator name, assumed to be the same as the class name

toarray()¶: Return the result of the expression as a numpy array

class scidbpy.afl.tan(*args)¶

The scalar function tan

Methods

`eval`([out, store])	Evaluate the expression if necessary, and return the result as a SciDBArray.
`toarray`()	Return the result of the expression as a numpy array

cached_result¶

Return the result if already evaluated, or None.

Returns:	A SciDBArray instance, or None :

eval(out=None, store=True, **kwargs)¶

Evaluate the expression if necessary, and return the result as a SciDBArray.

Parameters:

out : SciDBArray instance (optional)

The array to store the result in. One will be created if necessary

store : bool

If True (the default), the query will be wrapped in a store call, and wrapped in a SciDBAarray (specified by out). If false, this executes the query, but doesn’t save the result

Returns:

out : SciDBArray instance, or None

Notes

The result of eval() is cached, so subsequent calls will not trigger additional database computation

name¶: The SciDB operator name, assumed to be the same as the class name

toarray()¶: Return the result of the expression as a numpy array

class scidbpy.afl.togmt(*args)¶

The scalar function togmt

Methods

`eval`([out, store])	Evaluate the expression if necessary, and return the result as a SciDBArray.
`toarray`()	Return the result of the expression as a numpy array

cached_result¶

Return the result if already evaluated, or None.

Returns:	A SciDBArray instance, or None :

eval(out=None, store=True, **kwargs)¶

Evaluate the expression if necessary, and return the result as a SciDBArray.

Parameters:

out : SciDBArray instance (optional)

The array to store the result in. One will be created if necessary

store : bool

If True (the default), the query will be wrapped in a store call, and wrapped in a SciDBAarray (specified by out). If false, this executes the query, but doesn’t save the result

Returns:

out : SciDBArray instance, or None

Notes

The result of eval() is cached, so subsequent calls will not trigger additional database computation

name¶: The SciDB operator name, assumed to be the same as the class name

toarray()¶: Return the result of the expression as a numpy array

class scidbpy.afl.tznow(*args)¶

The scalar function tznow

Methods

`eval`([out, store])	Evaluate the expression if necessary, and return the result as a SciDBArray.
`toarray`()	Return the result of the expression as a numpy array

cached_result¶

Return the result if already evaluated, or None.

Returns:	A SciDBArray instance, or None :

eval(out=None, store=True, **kwargs)¶

Evaluate the expression if necessary, and return the result as a SciDBArray.

Parameters:

out : SciDBArray instance (optional)

The array to store the result in. One will be created if necessary

store : bool

If True (the default), the query will be wrapped in a store call, and wrapped in a SciDBAarray (specified by out). If false, this executes the query, but doesn’t save the result

Returns:

out : SciDBArray instance, or None

Notes

The result of eval() is cached, so subsequent calls will not trigger additional database computation

name¶: The SciDB operator name, assumed to be the same as the class name

toarray()¶: Return the result of the expression as a numpy array

class scidbpy.afl.as_(*args)¶

The operator as

Methods

`eval`([out, store])	Evaluate the expression if necessary, and return the result as a SciDBArray.
`toarray`()	Return the result of the expression as a numpy array

cached_result¶

Return the result if already evaluated, or None.

Returns:	A SciDBArray instance, or None :

eval(out=None, store=True, **kwargs)¶

Evaluate the expression if necessary, and return the result as a SciDBArray.

Parameters:

out : SciDBArray instance (optional)

The array to store the result in. One will be created if necessary

store : bool

If True (the default), the query will be wrapped in a store call, and wrapped in a SciDBAarray (specified by out). If false, this executes the query, but doesn’t save the result

Returns:

out : SciDBArray instance, or None

Notes

The result of eval() is cached, so subsequent calls will not trigger additional database computation

name¶: The SciDB operator name, assumed to be the same as the class name

toarray()¶: Return the result of the expression as a numpy array

class scidbpy.afl.add(*args)¶

The operator +

Methods

`eval`([out, store])	Evaluate the expression if necessary, and return the result as a SciDBArray.
`toarray`()	Return the result of the expression as a numpy array

cached_result¶

Return the result if already evaluated, or None.

Returns:	A SciDBArray instance, or None :

eval(out=None, store=True, **kwargs)¶

Evaluate the expression if necessary, and return the result as a SciDBArray.

Parameters:

out : SciDBArray instance (optional)

The array to store the result in. One will be created if necessary

store : bool

If True (the default), the query will be wrapped in a store call, and wrapped in a SciDBAarray (specified by out). If false, this executes the query, but doesn’t save the result

Returns:

out : SciDBArray instance, or None

Notes

The result of eval() is cached, so subsequent calls will not trigger additional database computation

name¶: The SciDB operator name, assumed to be the same as the class name

toarray()¶: Return the result of the expression as a numpy array

class scidbpy.afl.sub(*args)¶

The operator -

Methods

`eval`([out, store])	Evaluate the expression if necessary, and return the result as a SciDBArray.
`toarray`()	Return the result of the expression as a numpy array

cached_result¶

Return the result if already evaluated, or None.

Returns:	A SciDBArray instance, or None :

eval(out=None, store=True, **kwargs)¶

Evaluate the expression if necessary, and return the result as a SciDBArray.

Parameters:

out : SciDBArray instance (optional)

The array to store the result in. One will be created if necessary

store : bool

If True (the default), the query will be wrapped in a store call, and wrapped in a SciDBAarray (specified by out). If false, this executes the query, but doesn’t save the result

Returns:

out : SciDBArray instance, or None

Notes

The result of eval() is cached, so subsequent calls will not trigger additional database computation

name¶: The SciDB operator name, assumed to be the same as the class name

toarray()¶: Return the result of the expression as a numpy array

class scidbpy.afl.mul(*args)¶

The operator *

Methods

`eval`([out, store])	Evaluate the expression if necessary, and return the result as a SciDBArray.
`toarray`()	Return the result of the expression as a numpy array

cached_result¶

Return the result if already evaluated, or None.

Returns:	A SciDBArray instance, or None :

eval(out=None, store=True, **kwargs)¶

Evaluate the expression if necessary, and return the result as a SciDBArray.

Parameters:

out : SciDBArray instance (optional)

The array to store the result in. One will be created if necessary

store : bool

If True (the default), the query will be wrapped in a store call, and wrapped in a SciDBAarray (specified by out). If false, this executes the query, but doesn’t save the result

Returns:

out : SciDBArray instance, or None

Notes

The result of eval() is cached, so subsequent calls will not trigger additional database computation

name¶: The SciDB operator name, assumed to be the same as the class name

toarray()¶: Return the result of the expression as a numpy array

class scidbpy.afl.div(*args)¶

The operator /

Methods

`eval`([out, store])	Evaluate the expression if necessary, and return the result as a SciDBArray.
`toarray`()	Return the result of the expression as a numpy array

cached_result¶

Return the result if already evaluated, or None.

Returns:	A SciDBArray instance, or None :

eval(out=None, store=True, **kwargs)¶

Evaluate the expression if necessary, and return the result as a SciDBArray.

Parameters:

out : SciDBArray instance (optional)

The array to store the result in. One will be created if necessary

store : bool

If True (the default), the query will be wrapped in a store call, and wrapped in a SciDBAarray (specified by out). If false, this executes the query, but doesn’t save the result

Returns:

out : SciDBArray instance, or None

Notes

The result of eval() is cached, so subsequent calls will not trigger additional database computation

name¶: The SciDB operator name, assumed to be the same as the class name

toarray()¶: Return the result of the expression as a numpy array

class scidbpy.afl.mod(*args)¶

The operator %

Methods

`eval`([out, store])	Evaluate the expression if necessary, and return the result as a SciDBArray.
`toarray`()	Return the result of the expression as a numpy array

cached_result¶

Return the result if already evaluated, or None.

Returns:	A SciDBArray instance, or None :

eval(out=None, store=True, **kwargs)¶

Evaluate the expression if necessary, and return the result as a SciDBArray.

Parameters:

out : SciDBArray instance (optional)

The array to store the result in. One will be created if necessary

store : bool

If True (the default), the query will be wrapped in a store call, and wrapped in a SciDBAarray (specified by out). If false, this executes the query, but doesn’t save the result

Returns:

out : SciDBArray instance, or None

Notes

The result of eval() is cached, so subsequent calls will not trigger additional database computation

name¶: The SciDB operator name, assumed to be the same as the class name

toarray()¶: Return the result of the expression as a numpy array

class scidbpy.afl.lt(*args)¶

The operator <

Methods

`eval`([out, store])	Evaluate the expression if necessary, and return the result as a SciDBArray.
`toarray`()	Return the result of the expression as a numpy array

cached_result¶

Return the result if already evaluated, or None.

Returns:	A SciDBArray instance, or None :

eval(out=None, store=True, **kwargs)¶

Evaluate the expression if necessary, and return the result as a SciDBArray.

Parameters:

out : SciDBArray instance (optional)

The array to store the result in. One will be created if necessary

store : bool

If True (the default), the query will be wrapped in a store call, and wrapped in a SciDBAarray (specified by out). If false, this executes the query, but doesn’t save the result

Returns:

out : SciDBArray instance, or None

Notes

The result of eval() is cached, so subsequent calls will not trigger additional database computation

name¶: The SciDB operator name, assumed to be the same as the class name

toarray()¶: Return the result of the expression as a numpy array

class scidbpy.afl.le(*args)¶

The operator <=

Methods

`eval`([out, store])	Evaluate the expression if necessary, and return the result as a SciDBArray.
`toarray`()	Return the result of the expression as a numpy array

cached_result¶

Return the result if already evaluated, or None.

Returns:	A SciDBArray instance, or None :

eval(out=None, store=True, **kwargs)¶

Evaluate the expression if necessary, and return the result as a SciDBArray.

Parameters:

out : SciDBArray instance (optional)

The array to store the result in. One will be created if necessary

store : bool

If True (the default), the query will be wrapped in a store call, and wrapped in a SciDBAarray (specified by out). If false, this executes the query, but doesn’t save the result

Returns:

out : SciDBArray instance, or None

Notes

The result of eval() is cached, so subsequent calls will not trigger additional database computation

name¶: The SciDB operator name, assumed to be the same as the class name

toarray()¶: Return the result of the expression as a numpy array

class scidbpy.afl.ne(*args)¶

The operator <>

Methods

`eval`([out, store])	Evaluate the expression if necessary, and return the result as a SciDBArray.
`toarray`()	Return the result of the expression as a numpy array

cached_result¶

Return the result if already evaluated, or None.

Returns:	A SciDBArray instance, or None :

eval(out=None, store=True, **kwargs)¶

Evaluate the expression if necessary, and return the result as a SciDBArray.

Parameters:

out : SciDBArray instance (optional)

The array to store the result in. One will be created if necessary

store : bool

If True (the default), the query will be wrapped in a store call, and wrapped in a SciDBAarray (specified by out). If false, this executes the query, but doesn’t save the result

Returns:

out : SciDBArray instance, or None

Notes

The result of eval() is cached, so subsequent calls will not trigger additional database computation

name¶: The SciDB operator name, assumed to be the same as the class name

toarray()¶: Return the result of the expression as a numpy array

class scidbpy.afl.eq(*args)¶

The operator =

Methods

`eval`([out, store])	Evaluate the expression if necessary, and return the result as a SciDBArray.
`toarray`()	Return the result of the expression as a numpy array

cached_result¶

Return the result if already evaluated, or None.

Returns:	A SciDBArray instance, or None :

eval(out=None, store=True, **kwargs)¶

Evaluate the expression if necessary, and return the result as a SciDBArray.

Parameters:

out : SciDBArray instance (optional)

The array to store the result in. One will be created if necessary

store : bool

If True (the default), the query will be wrapped in a store call, and wrapped in a SciDBAarray (specified by out). If false, this executes the query, but doesn’t save the result

Returns:

out : SciDBArray instance, or None

Notes

The result of eval() is cached, so subsequent calls will not trigger additional database computation

name¶: The SciDB operator name, assumed to be the same as the class name

toarray()¶: Return the result of the expression as a numpy array

class scidbpy.afl.ge(*args)¶

The operator >=

Methods

`eval`([out, store])	Evaluate the expression if necessary, and return the result as a SciDBArray.
`toarray`()	Return the result of the expression as a numpy array

cached_result¶

Return the result if already evaluated, or None.

Returns:	A SciDBArray instance, or None :

eval(out=None, store=True, **kwargs)¶

Evaluate the expression if necessary, and return the result as a SciDBArray.

Parameters:

out : SciDBArray instance (optional)

The array to store the result in. One will be created if necessary

store : bool

If True (the default), the query will be wrapped in a store call, and wrapped in a SciDBAarray (specified by out). If false, this executes the query, but doesn’t save the result

Returns:

out : SciDBArray instance, or None

Notes

The result of eval() is cached, so subsequent calls will not trigger additional database computation

name¶: The SciDB operator name, assumed to be the same as the class name

toarray()¶: Return the result of the expression as a numpy array

class scidbpy.afl.gt(*args)¶

The operator >

Methods

`eval`([out, store])	Evaluate the expression if necessary, and return the result as a SciDBArray.
`toarray`()	Return the result of the expression as a numpy array

cached_result¶

Return the result if already evaluated, or None.

Returns:	A SciDBArray instance, or None :

eval(out=None, store=True, **kwargs)¶

Evaluate the expression if necessary, and return the result as a SciDBArray.

Parameters:

out : SciDBArray instance (optional)

The array to store the result in. One will be created if necessary

store : bool

If True (the default), the query will be wrapped in a store call, and wrapped in a SciDBAarray (specified by out). If false, this executes the query, but doesn’t save the result

Returns:

out : SciDBArray instance, or None

Notes

The result of eval() is cached, so subsequent calls will not trigger additional database computation

name¶: The SciDB operator name, assumed to be the same as the class name

toarray()¶: Return the result of the expression as a numpy array

4. AFL Operator Reference¶

4.1. Operator Reference¶

Table Of Contents

This Page

Navigation

4. AFL Operator Reference¶

4.1. Operator Reference¶

Table Of Contents

This Page

Quick search

Navigation