chainalysis.data_solutions_table package¶
Submodules¶
chainalysis.data_solutions_table.analytical_table module¶
- class chainalysis.data_solutions_table.analytical_table.AnalyticalTable(api_key: str, chain_table_name: str)[source]¶
-
Bases:
Select
The AnalyticalTable class implements the Select base class for querying a chain-specific table within the Data Solutions system.
It provides the structure for constructing and executing SQL queries using Common Table Expressions.
- execute(polling_interval_sec: int = 5, autopaginate: bool = True) Analytical [source]¶
-
Execute the query and return an Analytical object.
- Parameters:
-
-
polling_interval_sec (int, optional) – The interval in seconds between status checks. The minimum value is 5 seconds.
-
autopaginate (bool, optional) – Whether to automatically retrieve full results instead of individual pages.
-
- Returns:
-
Analytical object.
- Return type:
- get_table(chain, table) Table [source]¶
-
Return a SQLAlchemy Table object for the given chain and table name.
- Parameters:
-
-
chain (str) – The chain name.
-
table (str) – The table name.
-
- Returns:
-
A SQLAlchemy Table object.
- Return type:
-
Table
- Raises:
-
ValueException – If the chain or table does not exist in the database.
chainalysis.data_solutions_table.data_solutions_table module¶
- class chainalysis.data_solutions_table.data_solutions_table.Select(api_key: str, chain_table_name: str)[source]¶
-
Bases:
Select
,ABC
Select is an abstract base class that represents an interface for querying a chain-specific table within the Data Solutions system.
It provides the structure for constructing and executing SQL queries using Common Table Expressions. Child classes must implement methods to retrieve tables and execute queries, which will return the appropriate result type.
- __init__(api_key: str, chain_table_name: str)[source]¶
-
Initialize the Select object.
- Parameters:
-
-
api_key (str) – The API key for the Data Solutions API.
-
chain_table_name (str) – The chain and table name formatted as ‘chain.table’.
-
- Raises:
-
ValueException – If the table name is not formatted correctly.
- property c: ColumnCollection¶
-
Return the columns of the table.
- Returns:
-
A collection of column objects associated with the table.
- Return type:
-
ColumnCollection
- abstract execute() Transactional | Analytical [source]¶
-
Execute the query and return a Transactional or Analytical object.
- Returns:
-
Transactional or Analytical object.
- Return type:
-
Union[Transactional, Analytical]
- abstract get_table(chain, table: str) Table [source]¶
-
Return a SQLAlchemy Table object for the given chain and table name.
- Parameters:
-
-
chain – The chain name.
-
table – The table name.
-
- Returns:
-
A SQLAlchemy Table object.
- Return type:
-
Table
- Raises:
-
ValueException – If the chain or table does not exist in the database.
- chainalysis.data_solutions_table.data_solutions_table.and_(*clauses)[source]¶
-
Produce a conjunction of expressions joined by
AND
.E.g.:
from sqlalchemy import and_ stmt = select(users_table).where( and_( users_table.c.name == 'wendy', users_table.c.enrolled == True ) )
The
and_()
conjunction is also available using the Python&
operator (though note that compound expressions need to be parenthesized in order to function with Python operator precedence behavior):stmt = select(users_table).where( (users_table.c.name == 'wendy') & (users_table.c.enrolled == True) )
The
and_()
operation is also implicit in some cases; the_expression.Select.where()
method for example can be invoked multiple times against a statement, which will have the effect of each clause being combined usingand_()
:stmt = select(users_table).\ where(users_table.c.name == 'wendy').\ where(users_table.c.enrolled == True)
The
and_()
construct must be given at least one positional argument in order to be valid; aand_()
construct with no arguments is ambiguous. To produce an “empty” or dynamically generatedand_()
expression, from a given list of expressions, a “default” element of_sql.true()
(or justTrue
) should be specified:from sqlalchemy import true criteria = and_(true(), *expressions)
The above expression will compile to SQL as the expression
true
or1 = 1
, depending on backend, if no other expressions are present. If expressions are present, then the_sql.true()
value is ignored as it does not affect the outcome of an AND expression that has other elements.Deprecated since version 1.4: The
and_()
element now requires that at least one argument is passed; creating theand_()
construct with no arguments is deprecated, and will emit a deprecation warning while continuing to produce a blank SQL string.See also
- chainalysis.data_solutions_table.data_solutions_table.between(expr: _ColumnExpressionOrLiteralArgument[_T], lower_bound: Any, upper_bound: Any, symmetric: bool = False) BinaryExpression[bool] [source]¶
-
Produce a
BETWEEN
predicate clause.E.g.:
from sqlalchemy import between stmt = select(users_table).where(between(users_table.c.id, 5, 7))
Would produce SQL resembling:
SELECT id, name FROM user WHERE id BETWEEN :id_1 AND :id_2
The
between()
function is a standalone version of the_expression.ColumnElement.between()
method available on all SQL expressions, as in:stmt = select(users_table).where(users_table.c.id.between(5, 7))
All arguments passed to
between()
, including the left side column expression, are coerced from Python scalar values if a the value is not a_expression.ColumnElement
subclass. For example, three fixed values can be compared as in:print(between(5, 3, 7))
Which would produce:
:param_1 BETWEEN :param_2 AND :param_3
- Parameters:
-
-
expr – a column expression, typically a
_expression.ColumnElement
instance or alternatively a Python scalar expression to be coerced into a column expression, serving as the left side of theBETWEEN
expression. -
lower_bound – a column or Python scalar expression serving as the lower bound of the right side of the
BETWEEN
expression. -
upper_bound – a column or Python scalar expression serving as the upper bound of the right side of the
BETWEEN
expression. -
symmetric – if True, will render “ BETWEEN SYMMETRIC “. Note that not all databases support this syntax.
-
See also
_expression.ColumnElement.between()
- chainalysis.data_solutions_table.data_solutions_table.case(*whens: typing_Tuple[_ColumnExpressionArgument[bool], Any] | Mapping[Any, Any], value: Any | None = None, else_: Any | None = None) Case[Any] [source]¶
-
Produce a
CASE
expression.The
CASE
construct in SQL is a conditional object that acts somewhat analogously to an “if/then” construct in other languages. It returns an instance ofCase
.case()
in its usual form is passed a series of “when” constructs, that is, a list of conditions and results as tuples:from sqlalchemy import case stmt = select(users_table).\ where( case( (users_table.c.name == 'wendy', 'W'), (users_table.c.name == 'jack', 'J'), else_='E' ) )
The above statement will produce SQL resembling:
SELECT id, name FROM user WHERE CASE WHEN (name = :name_1) THEN :param_1 WHEN (name = :name_2) THEN :param_2 ELSE :param_3 END
When simple equality expressions of several values against a single parent column are needed,
case()
also has a “shorthand” format used via the :paramref:`.case.value` parameter, which is passed a column expression to be compared. In this form, the :paramref:`.case.whens` parameter is passed as a dictionary containing expressions to be compared against keyed to result expressions. The statement below is equivalent to the preceding statement:stmt = select(users_table).\ where( case( {"wendy": "W", "jack": "J"}, value=users_table.c.name, else_='E' ) )
The values which are accepted as result values in :paramref:`.case.whens` as well as with :paramref:`.case.else_` are coerced from Python literals into
bindparam()
constructs. SQL expressions, e.g._expression.ColumnElement
constructs, are accepted as well. To coerce a literal string expression into a constant expression rendered inline, use the_expression.literal_column()
construct, as in:from sqlalchemy import case, literal_column case( ( orderline.c.qty > 100, literal_column("'greaterthan100'") ), ( orderline.c.qty > 10, literal_column("'greaterthan10'") ), else_=literal_column("'lessthan10'") )
The above will render the given constants without using bound parameters for the result values (but still for the comparison values), as in:
CASE WHEN (orderline.qty > :qty_1) THEN 'greaterthan100' WHEN (orderline.qty > :qty_2) THEN 'greaterthan10' ELSE 'lessthan10' END
- Parameters:
-
-
*whens –
The criteria to be compared against, :paramref:`.case.whens` accepts two different forms, based on whether or not :paramref:`.case.value` is used.
Changed in version 1.4: the
_sql.case()
function now accepts the series of WHEN conditions positionallyIn the first form, it accepts multiple 2-tuples passed as positional arguments; each 2-tuple consists of
(<sql expression>, <value>)
, where the SQL expression is a boolean expression and “value” is a resulting value, e.g.:case( (users_table.c.name == 'wendy', 'W'), (users_table.c.name == 'jack', 'J') )
In the second form, it accepts a Python dictionary of comparison values mapped to a resulting value; this form requires :paramref:`.case.value` to be present, and values will be compared using the
==
operator, e.g.:case( {"wendy": "W", "jack": "J"}, value=users_table.c.name )
-
value – An optional SQL expression which will be used as a fixed “comparison point” for candidate values within a dictionary passed to :paramref:`.case.whens`.
-
else_ – An optional SQL expression which will be the evaluated result of the
CASE
construct if all expressions within :paramref:`.case.whens` evaluate to false. When omitted, most databases will produce a result of NULL if none of the “when” expressions evaluate to true.
-
- chainalysis.data_solutions_table.data_solutions_table.distinct(expr: _ColumnExpressionArgument[_T]) UnaryExpression[_T] [source]¶
-
Produce an column-expression-level unary
DISTINCT
clause.This applies the
DISTINCT
keyword to an individual column expression (e.g. not the whole statement), and renders specifically in that column position; this is used for containment within an aggregate function, as in:from sqlalchemy import distinct, func stmt = select(users_table.c.id, func.count(distinct(users_table.c.name)))
The above would produce an statement resembling:
SELECT user.id, count(DISTINCT user.name) FROM user
Tip
The
_sql.distinct()
function does not apply DISTINCT to the full SELECT statement, instead applying a DISTINCT modifier to individual column expressions. For generalSELECT DISTINCT
support, use the_sql.Select.distinct()
method on_sql.Select
.The
distinct()
function is also available as a column-level method, e.g._expression.ColumnElement.distinct()
, as in:stmt = select(func.count(users_table.c.name.distinct()))
The
distinct()
operator is different from the_expression.Select.distinct()
method of_expression.Select
, which produces aSELECT
statement withDISTINCT
applied to the result set as a whole, e.g. aSELECT DISTINCT
expression. See that method for further information.See also
_expression.ColumnElement.distinct()
_expression.Select.distinct()
func
- chainalysis.data_solutions_table.data_solutions_table.except_(*selects: _SelectStatementForCompoundArgument) CompoundSelect [source]¶
-
Return an
EXCEPT
of multiple selectables.The returned object is an instance of
_expression.CompoundSelect
.- Parameters:
-
*selects – a list of
_expression.Select
instances.
- chainalysis.data_solutions_table.data_solutions_table.except_all(*selects: _SelectStatementForCompoundArgument) CompoundSelect [source]¶
-
Return an
EXCEPT ALL
of multiple selectables.The returned object is an instance of
_expression.CompoundSelect
.- Parameters:
-
*selects – a list of
_expression.Select
instances.
- chainalysis.data_solutions_table.data_solutions_table.exists(__argument: _ColumnsClauseArgument[Any] | SelectBase | ScalarSelect[Any] | None = None) Exists [source]¶
-
Construct a new
_expression.Exists
construct.The
_sql.exists()
can be invoked by itself to produce an_sql.Exists
construct, which will accept simple WHERE criteria:exists_criteria = exists().where(table1.c.col1 == table2.c.col2)
However, for greater flexibility in constructing the SELECT, an existing
_sql.Select
construct may be converted to an_sql.Exists
, most conveniently by making use of the_sql.SelectBase.exists()
method:exists_criteria = ( select(table2.c.col2). where(table1.c.col1 == table2.c.col2). exists() )
The EXISTS criteria is then used inside of an enclosing SELECT:
stmt = select(table1.c.col1).where(exists_criteria)
The above statement will then be of the form:
SELECT col1 FROM table1 WHERE EXISTS (SELECT table2.col2 FROM table2 WHERE table2.col2 = table1.col1)
See also
tutorial_exists - in the 2.0 style tutorial.
_sql.SelectBase.exists()
- method to transform aSELECT
to anEXISTS
clause.
- chainalysis.data_solutions_table.data_solutions_table.intersect(*selects: _SelectStatementForCompoundArgument) CompoundSelect [source]¶
-
Return an
INTERSECT
of multiple selectables.The returned object is an instance of
_expression.CompoundSelect
.- Parameters:
-
*selects – a list of
_expression.Select
instances.
- chainalysis.data_solutions_table.data_solutions_table.intersect_all(*selects: _SelectStatementForCompoundArgument) CompoundSelect [source]¶
-
Return an
INTERSECT ALL
of multiple selectables.The returned object is an instance of
_expression.CompoundSelect
.- Parameters:
-
*selects – a list of
_expression.Select
instances.
- chainalysis.data_solutions_table.data_solutions_table.join(left: _FromClauseArgument, right: _FromClauseArgument, onclause: _OnClauseArgument | None = None, isouter: bool = False, full: bool = False) Join [source]¶
-
Produce a
_expression.Join
object, given two_expression.FromClause
expressions.E.g.:
j = join(user_table, address_table, user_table.c.id == address_table.c.user_id) stmt = select(user_table).select_from(j)
would emit SQL along the lines of:
SELECT user.id, user.name FROM user JOIN address ON user.id = address.user_id
Similar functionality is available given any
_expression.FromClause
object (e.g. such as a_schema.Table
) using the_expression.FromClause.join()
method.- Parameters:
-
-
left – The left side of the join.
-
right – the right side of the join; this is any
_expression.FromClause
object such as a_schema.Table
object, and may also be a selectable-compatible object such as an ORM-mapped class. -
onclause – a SQL expression representing the ON clause of the join. If left at
None
,_expression.FromClause.join()
will attempt to join the two tables based on a foreign key relationship. -
isouter – if True, render a LEFT OUTER JOIN, instead of JOIN.
-
full – if True, render a FULL OUTER JOIN, instead of JOIN.
-
See also
_expression.FromClause.join()
- method form, based on a given left side._expression.Join
- the type of object produced.
- chainalysis.data_solutions_table.data_solutions_table.lateral(selectable: SelectBase | _FromClauseArgument, name: str | None = None) LateralFromClause [source]¶
-
Return a
_expression.Lateral
object._expression.Lateral
is an_expression.Alias
subclass that represents a subquery with the LATERAL keyword applied to it.The special behavior of a LATERAL subquery is that it appears in the FROM clause of an enclosing SELECT, but may correlate to other FROM clauses of that SELECT. It is a special case of subquery only supported by a small number of backends, currently more recent PostgreSQL versions.
See also
tutorial_lateral_correlation - overview of usage.
- chainalysis.data_solutions_table.data_solutions_table.literal(value: Any, type_: _TypeEngineArgument[Any] | None = None, literal_execute: bool = False) BindParameter[Any] [source]¶
-
Return a literal clause, bound to a bind parameter.
Literal clauses are created automatically when non-
_expression.ClauseElement
objects (such as strings, ints, dates, etc.) are used in a comparison operation with a_expression.ColumnElement
subclass, such as aColumn
object. Use this function to force the generation of a literal clause, which will be created as aBindParameter
with a bound value.- Parameters:
-
-
value – the value to be bound. Can be any Python object supported by the underlying DB-API, or is translatable via the given type argument.
-
type_ – an optional
TypeEngine
which will provide bind-parameter translation for this literal. -
literal_execute –
optional bool, when True, the SQL engine will attempt to render the bound value directly in the SQL statement at execution time rather than providing as a parameter value.
Added in version 2.0.
-
- chainalysis.data_solutions_table.data_solutions_table.not_(clause: _ColumnExpressionArgument[_T]) ColumnElement[_T] [source]¶
-
Return a negation of the given clause, i.e.
NOT(clause)
.The
~
operator is also overloaded on all_expression.ColumnElement
subclasses to produce the same result.
- chainalysis.data_solutions_table.data_solutions_table.or_(*clauses)[source]¶
-
Produce a conjunction of expressions joined by
OR
.E.g.:
from sqlalchemy import or_ stmt = select(users_table).where( or_( users_table.c.name == 'wendy', users_table.c.name == 'jack' ) )
The
or_()
conjunction is also available using the Python|
operator (though note that compound expressions need to be parenthesized in order to function with Python operator precedence behavior):stmt = select(users_table).where( (users_table.c.name == 'wendy') | (users_table.c.name == 'jack') )
The
or_()
construct must be given at least one positional argument in order to be valid; aor_()
construct with no arguments is ambiguous. To produce an “empty” or dynamically generatedor_()
expression, from a given list of expressions, a “default” element of_sql.false()
(or justFalse
) should be specified:from sqlalchemy import false or_criteria = or_(false(), *expressions)
The above expression will compile to SQL as the expression
false
or0 = 1
, depending on backend, if no other expressions are present. If expressions are present, then the_sql.false()
value is ignored as it does not affect the outcome of an OR expression which has other elements.Deprecated since version 1.4: The
or_()
element now requires that at least one argument is passed; creating theor_()
construct with no arguments is deprecated, and will emit a deprecation warning while continuing to produce a blank SQL string.See also
- chainalysis.data_solutions_table.data_solutions_table.outerjoin(left: _FromClauseArgument, right: _FromClauseArgument, onclause: _OnClauseArgument | None = None, full: bool = False) Join [source]¶
-
Return an
OUTER JOIN
clause element.The returned object is an instance of
_expression.Join
.Similar functionality is also available via the
_expression.FromClause.outerjoin()
method on any_expression.FromClause
.- Parameters:
-
-
left – The left side of the join.
-
right – The right side of the join.
-
onclause – Optional criterion for the
ON
clause, is derived from foreign key relationships established between left and right otherwise.
-
To chain joins together, use the
_expression.FromClause.join()
or_expression.FromClause.outerjoin()
methods on the resulting_expression.Join
object.
- chainalysis.data_solutions_table.data_solutions_table.union(*selects: _SelectStatementForCompoundArgument) CompoundSelect [source]¶
-
Return a
UNION
of multiple selectables.The returned object is an instance of
_expression.CompoundSelect
.A similar
union()
method is available on all_expression.FromClause
subclasses.- Parameters:
-
-
*selects – a list of
_expression.Select
instances. -
**kwargs – available keyword arguments are the same as those of
with_columns()
.
-
- chainalysis.data_solutions_table.data_solutions_table.union_all(*selects: _SelectStatementForCompoundArgument) CompoundSelect [source]¶
-
Return a
UNION ALL
of multiple selectables.The returned object is an instance of
_expression.CompoundSelect
.A similar
union_all()
method is available on all_expression.FromClause
subclasses.- Parameters:
-
*selects – a list of
_expression.Select
instances.
chainalysis.data_solutions_table.transactional_table module¶
- class chainalysis.data_solutions_table.transactional_table.TransactionalTable(api_key: str, chain_table_name: str)[source]¶
-
Bases:
Select
The TransactionalTable class implements the Select base class for querying a chain-specific table within the Data Solutions system.
It provides the structure for constructing and executing SQL queries using Common Table Expressions.
- execute(options: dict = {}) Transactional [source]¶
-
Execute the query and return a Transactional object.
- Parameters:
-
options (dict) – The options for the query.
- Returns:
-
Transactional object.
- Return type:
- get_table(chain, table) None [source]¶
-
Return a SQLAlchemy Table object for the given chain and table name.
- Parameters:
-
-
chain (str) – The chain name.
-
table (str) – The table name.
-
- Returns:
-
A SQLAlchemy Table object.
- Return type:
-
Table
- Raises:
-
ValueException – If the chain or table does not exist in the database.