Prepared statements holder. More...

#include <Schema.hpp>

Collaboration diagram for data::cassandra::Schema< SettingsProviderType >::Statements:

[legend]

Public Member Functions
	Statements (SettingsProviderType const &settingsProvider, Handle const &handle)
	Construct a new Statements object.

Public Attributes
PreparedStatement	insertObject

PreparedStatement	insertTransaction

PreparedStatement	insertLedgerTransaction

PreparedStatement	insertSuccessor

PreparedStatement	insertDiff

PreparedStatement	insertAccountTx

PreparedStatement	insertNFT

PreparedStatement	insertIssuerNFT

PreparedStatement	insertNFTURI

PreparedStatement	insertNFTTx

PreparedStatement	insertMPTHolder

PreparedStatement	insertLedgerHeader

PreparedStatement	insertLedgerHash

PreparedStatement	updateLedgerRange

PreparedStatement	deleteLedgerRange

PreparedStatement	insertMigratorStatus

PreparedStatement	selectSuccessor

PreparedStatement	selectDiff

PreparedStatement	selectObject

PreparedStatement	selectTransaction

PreparedStatement	selectAllTransactionHashesInLedger

PreparedStatement	selectLedgerPageKeys

PreparedStatement	selectLedgerPage

PreparedStatement	getToken

PreparedStatement	selectAccountTx

PreparedStatement	selectAccountFromBegining

PreparedStatement	selectAccountFromToken

PreparedStatement	selectAccountTxForward

PreparedStatement	selectNFT

PreparedStatement	selectNFTURI

PreparedStatement	selectNFTTx

PreparedStatement	selectNFTTxForward

PreparedStatement	selectNFTIDsByIssuer

PreparedStatement	selectNFTIDsByIssuerTaxon

PreparedStatement	selectMPTHolders

PreparedStatement	selectLedgerByHash

PreparedStatement	selectLedgerBySeq

PreparedStatement	selectLatestLedger

PreparedStatement	selectLedgerRange

PreparedStatement	selectMigratorStatus

Detailed Description

template<SomeSettingsProvider SettingsProviderType>
class data::cassandra::Schema< SettingsProviderType >::Statements

Prepared statements holder.

Constructor & Destructor Documentation

◆ Statements()

template<SomeSettingsProvider SettingsProviderType>

data::cassandra::Schema< SettingsProviderType >::Statements::Statements	(	SettingsProviderType const &	settingsProvider,
		Handle const &	handle )

inline

Construct a new Statements object.

Parameters

settingsProvider	The settings provider
handle	The handle to the DB

Member Data Documentation

◆ deleteLedgerRange

template<SomeSettingsProvider SettingsProviderType>

PreparedStatement data::cassandra::Schema< SettingsProviderType >::Statements::deleteLedgerRange

Initial value:

= [this]() {
            return handle_.get().prepare(fmt::format(
                R"(
                UPDATE {} 
                   SET sequence = ?
                 WHERE is_latest = False
                )",
                qualifiedTableName(settingsProvider_.get(), "ledger_range")
            ));
        }()

◆ getToken

template<SomeSettingsProvider SettingsProviderType>

PreparedStatement data::cassandra::Schema< SettingsProviderType >::Statements::getToken

Initial value:

= [this]() {
            return handle_.get().prepare(fmt::format(
                R"(
                SELECT TOKEN(key) 
                  FROM {}               
                 WHERE key = ?               
                 LIMIT 1
                )",
                qualifiedTableName(settingsProvider_.get(), "objects")
            ));
        }()

◆ insertAccountTx

template<SomeSettingsProvider SettingsProviderType>

PreparedStatement data::cassandra::Schema< SettingsProviderType >::Statements::insertAccountTx

Initial value:

= [this]() {
            return handle_.get().prepare(fmt::format(
                R"(
                INSERT INTO {} 
                       (account, seq_idx, hash)
                VALUES (?, ?, ?)
                )",
                qualifiedTableName(settingsProvider_.get(), "account_tx")
            ));
        }()

◆ insertDiff

template<SomeSettingsProvider SettingsProviderType>

PreparedStatement data::cassandra::Schema< SettingsProviderType >::Statements::insertDiff

Initial value:

= [this]() {
            return handle_.get().prepare(fmt::format(
                R"(
                INSERT INTO {} 
                       (seq, key)
                VALUES (?, ?)
                )",
                qualifiedTableName(settingsProvider_.get(), "diff")
            ));
        }()

◆ insertIssuerNFT

template<SomeSettingsProvider SettingsProviderType>

PreparedStatement data::cassandra::Schema< SettingsProviderType >::Statements::insertIssuerNFT

Initial value:

= [this]() {
            return handle_.get().prepare(fmt::format(
                R"(
                INSERT INTO {} 
                       (issuer, taxon, token_id)
                VALUES (?, ?, ?)
                )",
                qualifiedTableName(settingsProvider_.get(), "issuer_nf_tokens_v2")
            ));
        }()

◆ insertLedgerHash

template<SomeSettingsProvider SettingsProviderType>

PreparedStatement data::cassandra::Schema< SettingsProviderType >::Statements::insertLedgerHash

Initial value:

= [this]() {
            return handle_.get().prepare(fmt::format(
                R"(
                INSERT INTO {} 
                       (hash, sequence)
                VALUES (?, ?)
                )",
                qualifiedTableName(settingsProvider_.get(), "ledger_hashes")
            ));
        }()

◆ insertLedgerHeader

template<SomeSettingsProvider SettingsProviderType>

PreparedStatement data::cassandra::Schema< SettingsProviderType >::Statements::insertLedgerHeader

Initial value:

= [this]() {
            return handle_.get().prepare(fmt::format(
                R"(
                INSERT INTO {} 
                       (sequence, header)
                VALUES (?, ?)
                )",
                qualifiedTableName(settingsProvider_.get(), "ledgers")
            ));
        }()

◆ insertLedgerTransaction

template<SomeSettingsProvider SettingsProviderType>

PreparedStatement data::cassandra::Schema< SettingsProviderType >::Statements::insertLedgerTransaction

Initial value:

= [this]() {
            return handle_.get().prepare(fmt::format(
                R"(
                INSERT INTO {} 
                       (ledger_sequence, hash)
                VALUES (?, ?)
                )",
                qualifiedTableName(settingsProvider_.get(), "ledger_transactions")
            ));
        }()

◆ insertMigratorStatus

template<SomeSettingsProvider SettingsProviderType>

PreparedStatement data::cassandra::Schema< SettingsProviderType >::Statements::insertMigratorStatus

Initial value:

= [this]() {
            return handle_.get().prepare(fmt::format(
                R"(
                INSERT INTO {}
                       (migrator_name, status)
                VALUES (?, ?)
                )",
                qualifiedTableName(settingsProvider_.get(), "migrator_status")
            ));
        }()

◆ insertMPTHolder

template<SomeSettingsProvider SettingsProviderType>

PreparedStatement data::cassandra::Schema< SettingsProviderType >::Statements::insertMPTHolder

Initial value:

= [this]() {
            return handle_.get().prepare(fmt::format(
                R"(
                INSERT INTO {} 
                       (mpt_id, holder)
                VALUES (?, ?)
                )",
                qualifiedTableName(settingsProvider_.get(), "mp_token_holders")
            ));
        }()

◆ insertNFT

template<SomeSettingsProvider SettingsProviderType>

PreparedStatement data::cassandra::Schema< SettingsProviderType >::Statements::insertNFT

Initial value:

= [this]() {
            return handle_.get().prepare(fmt::format(
                R"(
                INSERT INTO {} 
                       (token_id, sequence, owner, is_burned)
                VALUES (?, ?, ?, ?)
                )",
                qualifiedTableName(settingsProvider_.get(), "nf_tokens")
            ));
        }()

◆ insertNFTTx

template<SomeSettingsProvider SettingsProviderType>

PreparedStatement data::cassandra::Schema< SettingsProviderType >::Statements::insertNFTTx

Initial value:

= [this]() {
            return handle_.get().prepare(fmt::format(
                R"(
                INSERT INTO {} 
                       (token_id, seq_idx, hash)
                VALUES (?, ?, ?)
                )",
                qualifiedTableName(settingsProvider_.get(), "nf_token_transactions")
            ));
        }()

◆ insertNFTURI

template<SomeSettingsProvider SettingsProviderType>

PreparedStatement data::cassandra::Schema< SettingsProviderType >::Statements::insertNFTURI

Initial value:

= [this]() {
            return handle_.get().prepare(fmt::format(
                R"(
                INSERT INTO {} 
                       (token_id, sequence, uri)
                VALUES (?, ?, ?)
                )",
                qualifiedTableName(settingsProvider_.get(), "nf_token_uris")
            ));
        }()

◆ insertObject

template<SomeSettingsProvider SettingsProviderType>

PreparedStatement data::cassandra::Schema< SettingsProviderType >::Statements::insertObject

Initial value:

= [this]() {
            return handle_.get().prepare(fmt::format(
                R"(
                INSERT INTO {} 
                       (key, sequence, object)
                VALUES (?, ?, ?)
                )",
                qualifiedTableName(settingsProvider_.get(), "objects")
            ));
        }()

◆ insertSuccessor

template<SomeSettingsProvider SettingsProviderType>

PreparedStatement data::cassandra::Schema< SettingsProviderType >::Statements::insertSuccessor

Initial value:

= [this]() {
            return handle_.get().prepare(fmt::format(
                R"(
                INSERT INTO {} 
                       (key, seq, next)
                VALUES (?, ?, ?)
                )",
                qualifiedTableName(settingsProvider_.get(), "successor")
            ));
        }()

◆ insertTransaction

template<SomeSettingsProvider SettingsProviderType>

PreparedStatement data::cassandra::Schema< SettingsProviderType >::Statements::insertTransaction

Initial value:

= [this]() {
            return handle_.get().prepare(fmt::format(
                R"(
                INSERT INTO {} 
                       (hash, ledger_sequence, date, transaction, metadata)
                VALUES (?, ?, ?, ?, ?)
                )",
                qualifiedTableName(settingsProvider_.get(), "transactions")
            ));
        }()

◆ selectAccountFromBegining

template<SomeSettingsProvider SettingsProviderType>

PreparedStatement data::cassandra::Schema< SettingsProviderType >::Statements::selectAccountFromBegining

Initial value:

= [this]() {
            return handle_.get().prepare(fmt::format(
                R"(
                SELECT account 
                  FROM {}               
                 WHERE token(account) > 0
                   PER PARTITION LIMIT 1 
                 LIMIT ?
                )",
                qualifiedTableName(settingsProvider_.get(), "account_tx")
            ));
        }()

◆ selectAccountFromToken

template<SomeSettingsProvider SettingsProviderType>

PreparedStatement data::cassandra::Schema< SettingsProviderType >::Statements::selectAccountFromToken

Initial value:

= [this]() {
            return handle_.get().prepare(fmt::format(
                R"(
                SELECT account 
                  FROM {}               
                 WHERE token(account) > token(?)
                   PER PARTITION LIMIT 1 
                 LIMIT ?
                )",
                qualifiedTableName(settingsProvider_.get(), "account_tx")
            ));
        }()

◆ selectAccountTx

template<SomeSettingsProvider SettingsProviderType>

PreparedStatement data::cassandra::Schema< SettingsProviderType >::Statements::selectAccountTx

Initial value:

= [this]() {
            return handle_.get().prepare(fmt::format(
                R"(
                SELECT hash, seq_idx 
                  FROM {}               
                 WHERE account = ?
                   AND seq_idx < ?
                 LIMIT ?
                )",
                qualifiedTableName(settingsProvider_.get(), "account_tx")
            ));
        }()

◆ selectAccountTxForward

template<SomeSettingsProvider SettingsProviderType>

PreparedStatement data::cassandra::Schema< SettingsProviderType >::Statements::selectAccountTxForward

Initial value:

= [this]() {
            return handle_.get().prepare(fmt::format(
                R"(
                SELECT hash, seq_idx 
                  FROM {}               
                 WHERE account = ?
                   AND seq_idx > ?
              ORDER BY seq_idx ASC 
                 LIMIT ?
                )",
                qualifiedTableName(settingsProvider_.get(), "account_tx")
            ));
        }()

◆ selectAllTransactionHashesInLedger

template<SomeSettingsProvider SettingsProviderType>

PreparedStatement data::cassandra::Schema< SettingsProviderType >::Statements::selectAllTransactionHashesInLedger

Initial value:

= [this]() {
            return handle_.get().prepare(fmt::format(
                R"(
                SELECT hash 
                  FROM {}               
                 WHERE ledger_sequence = ?               
                )",
                qualifiedTableName(settingsProvider_.get(), "ledger_transactions")
            ));
        }()

◆ selectDiff

template<SomeSettingsProvider SettingsProviderType>

PreparedStatement data::cassandra::Schema< SettingsProviderType >::Statements::selectDiff

Initial value:

= [this]() {
            return handle_.get().prepare(fmt::format(
                R"(
                SELECT key 
                  FROM {}
                 WHERE seq = ?
                )",
                qualifiedTableName(settingsProvider_.get(), "diff")
            ));
        }()

◆ selectLatestLedger

template<SomeSettingsProvider SettingsProviderType>

PreparedStatement data::cassandra::Schema< SettingsProviderType >::Statements::selectLatestLedger

Initial value:

= [this]() {
            return handle_.get().prepare(fmt::format(
                R"(
                SELECT sequence
                  FROM {}    
                 WHERE is_latest = True
                )",
                qualifiedTableName(settingsProvider_.get(), "ledger_range")
            ));
        }()

◆ selectLedgerByHash

template<SomeSettingsProvider SettingsProviderType>

PreparedStatement data::cassandra::Schema< SettingsProviderType >::Statements::selectLedgerByHash

Initial value:

= [this]() {
            return handle_.get().prepare(fmt::format(
                R"(
                SELECT sequence
                  FROM {}
                 WHERE hash = ?     
                 LIMIT 1
                )",
                qualifiedTableName(settingsProvider_.get(), "ledger_hashes")
            ));
        }()

◆ selectLedgerBySeq

template<SomeSettingsProvider SettingsProviderType>

PreparedStatement data::cassandra::Schema< SettingsProviderType >::Statements::selectLedgerBySeq

Initial value:

= [this]() {
            return handle_.get().prepare(fmt::format(
                R"(
                SELECT header
                  FROM {}
                 WHERE sequence = ?
                )",
                qualifiedTableName(settingsProvider_.get(), "ledgers")
            ));
        }()

◆ selectLedgerPage

template<SomeSettingsProvider SettingsProviderType>

PreparedStatement data::cassandra::Schema< SettingsProviderType >::Statements::selectLedgerPage

Initial value:

= [this]() {
            return handle_.get().prepare(fmt::format(
                R"(
                SELECT object, key
                  FROM {}
                 WHERE TOKEN(key) >= ?
                   AND sequence <= ?
         PER PARTITION LIMIT 1
                 LIMIT ?
                 ALLOW FILTERING
                )",
                qualifiedTableName(settingsProvider_.get(), "objects")
            ));
        }()

◆ selectLedgerPageKeys

template<SomeSettingsProvider SettingsProviderType>

PreparedStatement data::cassandra::Schema< SettingsProviderType >::Statements::selectLedgerPageKeys

Initial value:

= [this]() {
            return handle_.get().prepare(fmt::format(
                R"(
                SELECT key 
                  FROM {}               
                 WHERE TOKEN(key) >= ?
                   AND sequence <= ?
         PER PARTITION LIMIT 1 
                 LIMIT ?
                 ALLOW FILTERING
                )",
                qualifiedTableName(settingsProvider_.get(), "objects")
            ));
        }()

◆ selectLedgerRange

template<SomeSettingsProvider SettingsProviderType>

PreparedStatement data::cassandra::Schema< SettingsProviderType >::Statements::selectLedgerRange

Initial value:

= [this]() {
            return handle_.get().prepare(fmt::format(
                R"(
                SELECT sequence
                  FROM {}
                 WHERE is_latest in (True, False)
                )",
                qualifiedTableName(settingsProvider_.get(), "ledger_range")
            ));
        }()

◆ selectMigratorStatus

template<SomeSettingsProvider SettingsProviderType>

PreparedStatement data::cassandra::Schema< SettingsProviderType >::Statements::selectMigratorStatus

Initial value:

= [this]() {
            return handle_.get().prepare(fmt::format(
                R"(
                SELECT status
                  FROM {}
                 WHERE migrator_name = ?
                )",
                qualifiedTableName(settingsProvider_.get(), "migrator_status")
            ));
        }()

◆ selectMPTHolders

template<SomeSettingsProvider SettingsProviderType>

PreparedStatement data::cassandra::Schema< SettingsProviderType >::Statements::selectMPTHolders

Initial value:

= [this]() {
            return handle_.get().prepare(fmt::format(
                R"(
                SELECT holder
                  FROM {}    
                 WHERE mpt_id = ?
                   AND holder > ?
              ORDER BY holder ASC
                 LIMIT ?
                )",
                qualifiedTableName(settingsProvider_.get(), "mp_token_holders")
            ));
        }()

◆ selectNFT

template<SomeSettingsProvider SettingsProviderType>

PreparedStatement data::cassandra::Schema< SettingsProviderType >::Statements::selectNFT

Initial value:

= [this]() {
            return handle_.get().prepare(fmt::format(
                R"(
                SELECT sequence, owner, is_burned
                  FROM {}    
                 WHERE token_id = ?
                   AND sequence <= ?
              ORDER BY sequence DESC
                 LIMIT 1
                )",
                qualifiedTableName(settingsProvider_.get(), "nf_tokens")
            ));
        }()

◆ selectNFTIDsByIssuer

template<SomeSettingsProvider SettingsProviderType>

PreparedStatement data::cassandra::Schema< SettingsProviderType >::Statements::selectNFTIDsByIssuer

Initial value:

= [this]() {
            return handle_.get().prepare(fmt::format(
                R"(
                SELECT token_id
                  FROM {}    
                 WHERE issuer = ?
                   AND (taxon, token_id) > ?
              ORDER BY taxon ASC, token_id ASC
                 LIMIT ?
                )",
                qualifiedTableName(settingsProvider_.get(), "issuer_nf_tokens_v2")
            ));
        }()

◆ selectNFTIDsByIssuerTaxon

template<SomeSettingsProvider SettingsProviderType>

PreparedStatement data::cassandra::Schema< SettingsProviderType >::Statements::selectNFTIDsByIssuerTaxon

Initial value:

= [this]() {
            return handle_.get().prepare(fmt::format(
                R"(
                SELECT token_id
                  FROM {}    
                 WHERE issuer = ?
                   AND taxon = ?
                   AND token_id > ?
              ORDER BY taxon ASC, token_id ASC
                 LIMIT ?
                )",
                qualifiedTableName(settingsProvider_.get(), "issuer_nf_tokens_v2")
            ));
        }()

◆ selectNFTTx

template<SomeSettingsProvider SettingsProviderType>

PreparedStatement data::cassandra::Schema< SettingsProviderType >::Statements::selectNFTTx

Initial value:

= [this]() {
            return handle_.get().prepare(fmt::format(
                R"(
                SELECT hash, seq_idx
                  FROM {}    
                 WHERE token_id = ?
                   AND seq_idx < ?
              ORDER BY seq_idx DESC
                 LIMIT ?
                )",
                qualifiedTableName(settingsProvider_.get(), "nf_token_transactions")
            ));
        }()

◆ selectNFTTxForward

template<SomeSettingsProvider SettingsProviderType>

PreparedStatement data::cassandra::Schema< SettingsProviderType >::Statements::selectNFTTxForward

Initial value:

= [this]() {
            return handle_.get().prepare(fmt::format(
                R"(
                SELECT hash, seq_idx
                  FROM {}    
                 WHERE token_id = ?
                   AND seq_idx >= ?
              ORDER BY seq_idx ASC
                 LIMIT ?
                )",
                qualifiedTableName(settingsProvider_.get(), "nf_token_transactions")
            ));
        }()

◆ selectNFTURI

template<SomeSettingsProvider SettingsProviderType>

PreparedStatement data::cassandra::Schema< SettingsProviderType >::Statements::selectNFTURI

Initial value:

= [this]() {
            return handle_.get().prepare(fmt::format(
                R"(
                SELECT uri
                  FROM {}    
                 WHERE token_id = ?
                   AND sequence <= ?
              ORDER BY sequence DESC
                 LIMIT 1
                )",
                qualifiedTableName(settingsProvider_.get(), "nf_token_uris")
            ));
        }()

◆ selectObject

template<SomeSettingsProvider SettingsProviderType>

PreparedStatement data::cassandra::Schema< SettingsProviderType >::Statements::selectObject

Initial value:

= [this]() {
            return handle_.get().prepare(fmt::format(
                R"(
                SELECT object, sequence 
                  FROM {}               
                 WHERE key = ?
                   AND sequence <= ?
              ORDER BY sequence DESC 
                 LIMIT 1
                )",
                qualifiedTableName(settingsProvider_.get(), "objects")
            ));
        }()

◆ selectSuccessor

template<SomeSettingsProvider SettingsProviderType>

PreparedStatement data::cassandra::Schema< SettingsProviderType >::Statements::selectSuccessor

Initial value:

= [this]() {
            return handle_.get().prepare(fmt::format(
                R"(
                SELECT next 
                  FROM {}               
                 WHERE key = ?
                   AND seq <= ?
              ORDER BY seq DESC 
                 LIMIT 1
                )",
                qualifiedTableName(settingsProvider_.get(), "successor")
            ));
        }()

◆ selectTransaction

template<SomeSettingsProvider SettingsProviderType>

PreparedStatement data::cassandra::Schema< SettingsProviderType >::Statements::selectTransaction

Initial value:

= [this]() {
            return handle_.get().prepare(fmt::format(
                R"(
                SELECT transaction, metadata, ledger_sequence, date 
                  FROM {}
                 WHERE hash = ?
                )",
                qualifiedTableName(settingsProvider_.get(), "transactions")
            ));
        }()

◆ updateLedgerRange

template<SomeSettingsProvider SettingsProviderType>

PreparedStatement data::cassandra::Schema< SettingsProviderType >::Statements::updateLedgerRange

Initial value:

= [this]() {
            return handle_.get().prepare(fmt::format(
                R"(
                UPDATE {} 
                   SET sequence = ?
                 WHERE is_latest = ? 
                    IF sequence IN (?, null)
                )",
                qualifiedTableName(settingsProvider_.get(), "ledger_range")
            ));
        }()

The documentation for this class was generated from the following file:

/__w/clio/clio/src/data/cassandra/Schema.hpp

Public Member Functions

Public Attributes

Detailed Description

Constructor & Destructor Documentation

◆ Statements()

Member Data Documentation

◆ deleteLedgerRange

◆ getToken

◆ insertAccountTx

◆ insertDiff

◆ insertIssuerNFT

◆ insertLedgerHash

◆ insertLedgerHeader

◆ insertLedgerTransaction

◆ insertMigratorStatus

◆ insertMPTHolder

◆ insertNFT

◆ insertNFTTx

◆ insertNFTURI

◆ insertObject

◆ insertSuccessor

◆ insertTransaction

◆ selectAccountFromBegining

◆ selectAccountFromToken

◆ selectAccountTx

◆ selectAccountTxForward

◆ selectAllTransactionHashesInLedger

◆ selectDiff

◆ selectLatestLedger

◆ selectLedgerByHash

◆ selectLedgerBySeq

◆ selectLedgerPage

◆ selectLedgerPageKeys

◆ selectLedgerRange

◆ selectMigratorStatus

◆ selectMPTHolders

◆ selectNFT

◆ selectNFTIDsByIssuer

◆ selectNFTIDsByIssuerTaxon

◆ selectNFTTx

◆ selectNFTTxForward

◆ selectNFTURI

◆ selectObject

◆ selectSuccessor

◆ selectTransaction

◆ updateLedgerRange