CrossClj
full-text documentation search

Project count:
9764

Last update
May 26, 2018

How to be listed

Artifact list

Clojurescript

Feedback

RECENT
    Less more depended upon.
    Full-text search for function, var, namespace, project documentation and descriptions for Clojure open-source projects.
    Query syntax supports boolean modifiers (+word, -word), wildcards (* and ?, except for the first character of a word), and phrases ("word1 word2").
    To search for identifiers, use the name search.
    Found 847 results in 146 projects. Show the first 500.
    grafter 0.11.2
    Tools for the hard graft of linked data processing
    grafter.rdf.protocols/rollbackSourceDoc + Usages
    Rollback a transaction

    grafter 0.11.2
    Tools for the hard graft of linked data processing
    grafter.rdf.protocols/commitSourceDoc + Usages
    Commit a transaction

    grafter 0.11.2
    Tools for the hard graft of linked data processing
    grafter.rdf.protocols/beginSourceDoc + Usages
    Start a transaction

    grafter 0.11.2
    Tools for the hard graft of linked data processing
    grafter.rdf.repository/rollback~RepositoryConnection~ITransactableSourceDoc + Usages
    Rollback a transaction

    grafter 0.11.2
    Tools for the hard graft of linked data processing
    grafter.rdf.repository/commit~RepositoryConnection~ITransactableSourceDoc + Usages
    Commit a transaction

    grafter 0.11.2
    Tools for the hard graft of linked data processing
    grafter.rdf.repository/begin~RepositoryConnection~ITransactableSourceDoc + Usages
    Start a transaction

    grafter 0.11.2
    Tools for the hard graft of linked data processing
    grafter.rdf.repository/rollback~Repository~ITransactableSourceDoc + Usages
    Rollback a transaction

    grafter 0.11.2
    Tools for the hard graft of linked data processing
    grafter.rdf.repository/commit~Repository~ITransactableSourceDoc + Usages
    Commit a transaction

    grafter 0.11.2
    Tools for the hard graft of linked data processing
    grafter.rdf.repository/begin~Repository~ITransactableSourceDoc + Usages
    Start a transaction

    postgres.async 0.8.0
    Asynchronous PostgreSQL Clojure client
    postgres.async/begin!SourceDoc + Usages
    Begins a transaction.

    fulcro 2.5.5
    A library for building full-stack SPA webapps in Clojure and Clojurescript
    fulcro.ui.forms/transact!SourceDoc + Usages
    Execute a transaction!

    derive 0.2.1
    Clojurescript library to support efficient computation of up to date values derived
    derive.nativestore/*transaction* (cljs)SourceDoc + Usages
    Inside a transaction?

    untangled 1.0.0-beta1
    A library for building full-stack SPA webapps in Clojure and Clojurescript
    untangled.ui.forms/transact!SourceDoc + Usages
    Execute a transaction!

    untangled-components 1.0.0
    Untangled Components is a library of pre-built CSS and active components for use
    untangled.ui.forms/transact!SourceDoc + Usages
    Execute a transaction!

    nativestore 0.2.2
    A client-side, in-memory, indexed data store.
    nativestore.core/*transaction* (cljs)SourceDoc + Usages
    Inside a transaction?

    nativestore 0.2.2
    A client-side, in-memory, indexed data store.
    nativestore.core/*transaction* (cljs)SourceDoc + Usages
    Inside a transaction?

    untangled-ui 1.0.0-alpha5
    Untangled Components is a library of pre-built CSS and active components for use
    untangled.ui.forms/transact!SourceDoc + Usages
    Execute a transaction!

    shiroko 0.1.0
    Clojure Data Prevalence Library
    shiroko.core/ingestSourceDoc + Usages
    Update the transaction counter and execute a transaction.

    Returns the parent transaction of the transaction argument,
      or nil if given the top-level transaction.

    data 0.1.2
    Helpful utilities for PostgreSQL and Redis
    dragonmark.data/post-transaction*SourceDoc + Usages
    Execute the function after the transaction if we're in a transaction

    toucan 1.1.7
    Functionality for defining your application's models and querying the database.
    toucan.db/*transaction-connection*SourceDoc + Usages
    Transaction connection to the application DB. Used internally by `transaction`.

    jepsen.mongodb 0.1.1
    FIXME: write description
    jepsen.mongodb.transfer/p4-applied-txnSourceDoc + Usages
    Mark the transaction as successfully applied. Returns the transaction.

    jepsen.mongodb 0.1.1
    FIXME: write description
    jepsen.mongodb.transfer/p3-apply-txnSourceDoc + Usages
    Applies the given transaction to both accounts. Returns the transaction.

    dynohub 1.1.0
    Clojure DynamoDB client with or without Transaction layer
    ozjongwon.dynotx/insert-and-return-tx-itemSourceDoc + Usages
    Insert a new transaction item with txid into transaction table

    squee 0.0.1
    A fresh JDBC library
    squee.impl.protocols/begin!SourceDoc + Usages
    Starts a transaction, returning something that encompasses a connection and transaction

    Starts a transaction, returning something that encompasses a connection and transaction

    Starts a transaction, returning something that encompasses a connection and transaction

    Starts a transaction, returning something that encompasses a connection and transaction

    Execute a PreparedStatement, optionally in a transaction.

    Transaction isolation levels.

    langohr 5.0.0
    An idiomatic Clojure client for RabbitMQ that embraces the AMQP 0.9.1 model. Built
    langohr.tx/rollbackSourceDoc + Usages
    Rolls current transaction back

    langohr 5.0.0
    An idiomatic Clojure client for RabbitMQ that embraces the AMQP 0.9.1 model. Built
    langohr.tx/commitSourceDoc + Usages
    Commits current transaction

    korma 0.5.0-RC1
    Tasty SQL for Clojure
    korma.db/rollbackSourceDoc + Usages
    Tell this current transaction to rollback.

    postgres.async 0.8.0
    Asynchronous PostgreSQL Clojure client
    postgres.async/rollback!SourceDoc + Usages
    Rollbacks an active transaction.

    postgres.async 0.8.0
    Asynchronous PostgreSQL Clojure client
    postgres.async/commit!SourceDoc + Usages
    Commits an active transaction.

    datumbazo 0.13.21
    Clojure Database Kung-Foo
    datumbazo.driver.core/rollbackSourceDoc + Usages
    Rollback the current `db` transaction.

    datumbazo 0.13.21
    Clojure Database Kung-Foo
    datumbazo.driver.core/commitSourceDoc + Usages
    Commit the current `db` transaction.

    datumbazo 0.13.21
    Clojure Database Kung-Foo
    datumbazo.driver.core/beginSourceDoc + Usages
    Begin a new `db` transaction.

    celtuce-core 0.3.1
    An idiomatic Clojure Redis client wrapping the Java client Lettuce
    celtuce.commands/multiSourceDoc + Usages
    Mark the start of a transaction block

    celtuce-core 0.3.1
    An idiomatic Clojure Redis client wrapping the Java client Lettuce
    celtuce.impl.server/multi~RedisCommands~TransactionalCommandsSourceDoc + Usages
    Mark the start of a transaction block

    clojure.jdbc 0.4.0
    clojure.jdbc is a library for low level, jdbc-based database access.
    jdbc.constants/isolation-levelsSourceDoc + Usages
    Transaction isolation levels

    clojure.jdbc 0.4.0
    clojure.jdbc is a library for low level, jdbc-based database access.
    jdbc.transaction/commit!~$~ITransactionStrategySourceDoc + Usages
    Commits a transaction. Returns nil.

    clojure.jdbc 0.4.0
    clojure.jdbc is a library for low level, jdbc-based database access.
    jdbc.transaction/rollback!~$~ITransactionStrategySourceDoc + Usages
    Rollbacks a transaction. Returns nil.

    clojure.jdbc 0.4.0
    clojure.jdbc is a library for low level, jdbc-based database access.
    jdbc.transaction/*default-tx-strategy*SourceDoc + Usages
    Default transaction strategy implementation.

    clojure.jdbc 0.4.0
    clojure.jdbc is a library for low level, jdbc-based database access.
    jdbc.transaction/commit!SourceDoc + Usages
    Commits a transaction. Returns nil.

    clojure.jdbc 0.4.0
    clojure.jdbc is a library for low level, jdbc-based database access.
    jdbc.transaction/rollback!SourceDoc + Usages
    Rollbacks a transaction. Returns nil.

    retro 0.7.1
    A protocol for revisioned transactions in Clojure.
    retro.core/txn-rollback!SourceDoc + Usages
    Roll back the current transaction.

    retro 0.7.1
    A protocol for revisioned transactions in Clojure.
    retro.core/txn-commit!SourceDoc + Usages
    Commit the current transaction.

    retro 0.7.1
    A protocol for revisioned transactions in Clojure.
    retro.core/txn-begin!SourceDoc + Usages
    Begin a new transaction.

    Mark the start of a transaction block

    moebius 0.5.5.0
    A system to process and enrich and correlate events in realtime
    moebius.kv/tx-log~InMemoryKVstore~Tx-LogSourceDoc + Usages
    Return the current Transaction log

    moebius 0.5.5.0
    A system to process and enrich and correlate events in realtime
    moebius.kv/tx-logSourceDoc + Usages
    Return the current Transaction log

    moebius 0.5.5.0
    A system to process and enrich and correlate events in realtime
    moebius.kv/Tx-LogSourceDoc + Usages
    A transaction log protocol

    korma-enhanced 0.3.1
    Tasty SQL for Clojure
    korma.db/rollbackSourceDoc + Usages
    Tell this current transaction to rollback.

    immutant-xa 1.1.4
    The Immutant xa module.
    immutant.xa.transaction/currentSourceDoc + Usages
    Return the active transaction

    Generates an unique transaction id

    postgres-gateway 1.12.1
    ClanHR postgres-gateway
    clanhr.postgres-gateway.config/rollback-transaction!SourceDoc + Usages
    Rolls back the transaction on the context

    postgres-gateway 1.12.1
    ClanHR postgres-gateway
    clanhr.postgres-gateway.config/commit-transaction!SourceDoc + Usages
    Commits the transaction on the context

    postgres-gateway 1.12.1
    ClanHR postgres-gateway
    clanhr.postgres-gateway.config/with-transaction!SourceDoc + Usages
    Returns a context in a transaction

    Same as `clojure.java.jdbc/with-db-transaction`

    tgkorma 0.4.3
    Tasty SQL for Clojure
    korma.db/rollbackSourceDoc + Usages
    Tell this current transaction to rollback.

    data 0.1.2
    Helpful utilities for PostgreSQL and Redis
    dragonmark.data/post-transactionSourceDoc + Usages
    Execute the code post-transaction

    ceterumnet-korma 0.3.1-RC2
    Tasty SQL for Clojure - ceterumnet fork
    korma.db/rollbackSourceDoc + Usages
    Tell this current transaction to rollback.

    entity-txn 0.1.0
    CRUD Transactions
    entitytxn.protocols/TxnEventsSourceDoc + Usages
    Link transaction events to implementations

    Add an instance to the current transaction. If the 

    eisen 0.1.0
    A Language for Programmable Applications
    blancas.eisen.clojure/trans-transexSourceDoc + Usages
    Translates a transaction statement.

    social-wallet-api 0.9.3.1
    Freecoin web API for wallet operations
    social-wallet-api.schema/DBTransactionSourceDoc + Usages
    Transaction schema validator

    cljain 0.6.0-beta1
    Enjoy JAIN-SIP in Clojure's way.
    cljain.sip.core/new-dialog!SourceDoc + Usages
    Create a dialog for the given transaction.

    bitcljoin 0.4.5
    BitCoin library for Clojure
    bitcoin.core/wallet-tx->mapSourceDoc + Usages
    Turns a Wallets Transaction into a map

    bitcljoin 0.4.5
    BitCoin library for Clojure
    bitcoin.core/tx->mapSourceDoc + Usages
    Turns a Transaction into a map

    bitcljoin 0.4.5
    BitCoin library for Clojure
    bitcoin.core/to-addressesSourceDoc + Usages
    Get the from addresses for a transaction

    bitcljoin 0.4.5
    BitCoin library for Clojure
    bitcoin.core/from-addressesSourceDoc + Usages
    Get the from addresses for a transaction

    bitcljoin 0.4.5
    BitCoin library for Clojure
    bitcoin.core/input-addressesSourceDoc + Usages
    Get the from addresses for a transaction

    Run statements in transaction

    neo4j-component 0.1.1
    Component for Neo4J
    com.edocu.help.db.neo4j/<transaction-runSourceDoc + Usages
    Run statements in transaction

    crustacean 0.1.5
    CRU operations & migrations for datomic
    crustacean.migrations/tx-markersSourceDoc + Usages
    Transaction for an entity's txMarkers

    clj.jdbc 0.1.1
    Alternative implementation of jdbc wrapper for clojure. For this momment, the official
    jdbc.transaction/commit!~DefaultTransactionStrategy~ITransactionStrategySourceDoc + Usages
    Commits a transaction. Returns nil.

    clj.jdbc 0.1.1
    Alternative implementation of jdbc wrapper for clojure. For this momment, the official
    jdbc.transaction/rollback!~DefaultTransactionStrategy~ITransactionStrategySourceDoc + Usages
    Rollbacks a transaction. Returns nil.

    clj.jdbc 0.1.1
    Alternative implementation of jdbc wrapper for clojure. For this momment, the official
    jdbc.transaction/commit!SourceDoc + Usages
    Commits a transaction. Returns nil.

    clj.jdbc 0.1.1
    Alternative implementation of jdbc wrapper for clojure. For this momment, the official
    jdbc.transaction/rollback!SourceDoc + Usages
    Rollbacks a transaction. Returns nil.

    clj.jdbc 0.1.1
    Alternative implementation of jdbc wrapper for clojure. For this momment, the official
    jdbc.constants/isolation-levelsSourceDoc + Usages
    Transaction isolation levels

    jepsen.mongodb 0.1.1
    FIXME: write description
    jepsen.mongodb.transfer/p6-finish-txnSourceDoc + Usages
    Marks the transaction as complete.

    datomic-tools 0.1.4
    Mysema Datomic tools
    mysema.datomic.core/ent-timestampSourceDoc + Usages
    The timestamp of the entity transaction

    datsync 0.0.1-alpha3
    Datomic <-> DataScript syncing/replication utilities
    dat.sync.server/apply-remote-tx!SourceDoc + Usages
    Takes a client transaction and transacts it

    refdb 0.7.0-alpha.6
    File-backed ref-based "database"
    refdb.core/write-transaction!SourceDoc + Usages
    Writes a `transaction` to durable storage.

    naga 0.1.0
    Forward Chaining Rule Engine
    naga.storage.datomic.core/txSourceDoc + Usages
    Determines the transaction ID for a database

    naga 0.1.0
    Forward Chaining Rule Engine
    naga.store/commit-txSourceDoc + Usages
    Commits a transaction, if supported

    naga 0.1.0
    Forward Chaining Rule Engine
    naga.store/start-txSourceDoc + Usages
    Starts a transaction, if supported

    fountain-jdbc 0.2
    Fountain-JDBC is a Clojure wrapper for Spring-JDBC component of the Spring framework.
    org.bituf.fountain.transaction/rollbackSourceDoc + Usages
    Rollback given/current transaction.

    fountain-jdbc 0.2
    Fountain-JDBC is a Clojure wrapper for Spring-JDBC component of the Spring framework.
    org.bituf.fountain.transaction/commitSourceDoc + Usages
    Commit given/current transaction.

    fountain-jdbc 0.2
    Fountain-JDBC is a Clojure wrapper for Spring-JDBC component of the Spring framework.
    org.bituf.fountain.transaction/*txn-status*SourceDoc + Usages
    TransactionStatus object for the current transaction.

    clj-gae-ds 0.3.1
    a datastore library on Google App Engine for Clojure
    am.ik.clj-gae-ds.core/*transaction*SourceDoc + Usages
    The current datastore transaction.

    datomic-replication 0.1.0
    Datomic Replication
    datomic-replication.core/replicate-txSourceDoc + Usages
    Sends the transaction to the connection.

    Transaction isolation levels.

    Rollback current transaction

    Commit current transaction

    Rollback current transaction

    Commit current transaction

    asphalt 0.6.7
    A Clojure library for JDBC access
    asphalt.transaction/tp-requires-newSourceDoc + Usages
    Create nested transaction if a transaction exists, create an independent transaction (using a new
      connection) otherwise.
      Options:
        :isolation - transaction isolation

    Rollback current transaction

    Commit current transaction

    Rollback current transaction

    Commit current transaction

    Rollback current transaction

    Commit current transaction

    Rollback current transaction

    Commit current transaction

    Rollback current transaction

    Commit current transaction

    asphalt 0.6.7
    A Clojure library for JDBC access
    asphalt.type/rollback-txnSourceDoc + Usages
    Rollback current transaction

    asphalt 0.6.7
    A Clojure library for JDBC access
    asphalt.type/commit-txnSourceDoc + Usages
    Commit current transaction

    atomic 0.3.1
    A thin wrapper on Datomic
    atomic.transaction/datom->transactionSourceDoc + Usages
    Return the transaction for the current datom

    plinth 0.0.4
    Simple backend in Clojure
    plinth.db/transact!SourceDoc + Usages
    Run the SQLFragments in a transaction

    opentransact 0.0.1
    Library for paying with and creating OpenTransact assets.
    opentransact.assets.memory/history~MemoryAsset~HistoricalAssetSourceDoc + Usages
    Return transaction history

    opentransact 0.0.1
    Library for paying with and creating OpenTransact assets.
    opentransact.assets.memory/history~MemoryAsset~HistoricalAssetSourceDoc + Usages
    Return transaction history

    opentransact 0.0.1
    Library for paying with and creating OpenTransact assets.
    opentransact.assets.memory/find-transaction~MemoryAsset~HistoricalAssetSourceDoc + Usages
    Find a transaction by it's id

    opentransact 0.0.1
    Library for paying with and creating OpenTransact assets.
    opentransact.client/history~RemoteAsset~HistoricalAssetSourceDoc + Usages
    Return transaction history

    opentransact 0.0.1
    Library for paying with and creating OpenTransact assets.
    opentransact.client/history~RemoteAsset~HistoricalAssetSourceDoc + Usages
    Return transaction history

    opentransact 0.0.1
    Library for paying with and creating OpenTransact assets.
    opentransact.client/find-transaction~RemoteAsset~HistoricalAssetSourceDoc + Usages
    Find a transaction by it's id

    opentransact 0.0.1
    Library for paying with and creating OpenTransact assets.
    opentransact.core/find-transactionSourceDoc + Usages
    Find a transaction by it's id

    opentransact 0.0.1
    Library for paying with and creating OpenTransact assets.
    opentransact.core/historySourceDoc + Usages
    Return transaction history

    transactions 2.1.10
    Provides support for distributed (XA) transactions.
    immutant.transactions.scope/not-supportedSourceDoc + Usages
    JEE NotSupported - suspend current transaction, if any, and run
      body without a transaction

    immutant-transactions 3.0.0-alpha1
    Provides support for distributed (XA) transactions.
    immutant.transactions.scope/not-supportedSourceDoc + Usages
    JEE NotSupported - suspend current transaction, if any, and run
      body without a transaction

    clj-btc 0.11.2
    Clojure bindings for the original (C++) Bitcoin Client
    clj-btc.core/getrawtransactionSourceDoc + Usages
    (version 0.7) Returns raw transaction representation for given
      transaction id.

    immutant-xa 1.1.4
    The Immutant xa module.
    immutant.xa.transaction/not-supportedSourceDoc + Usages
    JEE NotSupported - suspend current transaction, if any, and run body without a transaction

    pe-apptxn-core 0.0.2
    A Clojure library encapsulating the data model and data access functions of the
    pe-apptxn-core.core/apptxnlogs-for-apptxnidSourceDoc + Usages
    Returns the set of application transaction logs for the given application
      transaction entity ID.

    pe-apptxn-core 0.0.2
    A Clojure library encapsulating the data model and data access functions of the
    pe-apptxn-core.core/apptxnlogs-for-apptxnidSourceDoc + Usages
    Returns the set of application transaction logs for the given application
      transaction entity ID.

    data 0.1.2
    Helpful utilities for PostgreSQL and Redis
    dragonmark.data/build-transaction-middlewareSourceDoc + Usages
    Builds ring middleware that wraps the current request
      in a transaction if it's not already in a transaction

    entity-txn 0.1.0
    CRUD Transactions
    entitytxn.core/setup-and-validateSourceDoc + Usages
    Initialise a new transaction environment.
      args is a map allowing defaults to be overridden in this
      transaction.

    views-honeysql 0.1.4
    HoneySQL view implementation for views
    views.honeysql.core/with-view-transactionSourceDoc + Usages
    Like with-db-transaction, but sends view hints at end of transaction.

    jepsen.mongodb 0.1.1
    FIXME: write description
    jepsen.mongodb.transfer/p2-begin-txnSourceDoc + Usages
    Updates the given transaction from initial to pending. Returns the
      transaction.

    metabase 0.1.0
    Metabase Community Edition
    metabase.db/*transaction-connection*SourceDoc + Usages
    Transaction connection to the *Metabase* backing DB connection pool. Used internally by `transaction`.

    datsync 0.0.1-alpha3
    Datomic <-> DataScript syncing/replication utilities
    dat.sync.client/tx-metadataSourceDoc + Usages
    Given a tx-report, return transaction representing metadata about the transaction

    codax 1.2.0
    Codax is an idiomatic transactional embedded database for clojure
    codax.prefix/clear-prefixSourceDoc + Usages
    Clears the prefix of the transaction. This is the
      default state of a new transaction object.

    dynohub 1.1.0
    Clojure DynamoDB client with or without Transaction layer
    ozjongwon.dynotx/make-transactionSourceDoc + Usages
    Make a new transaction. Transaction = tx-item + fully-applied-request-versions

    atomic 0.3.1
    A thin wrapper on Datomic
    atomic.transaction/rollbackSourceDoc + Usages
    Reassert retracted datoms and retract asserted datoms in a transaction,
      effectively "undoing" the transaction.

    clojure 1.10.0-alpha4
    Core language
    clojure.core/alterSourceDoc + Usages
    Must be called in a transaction. Sets the in-transaction-value of
      ref to:
    
      (apply fun in-transaction-value-of-ref args)
    
      and returns the in-transaction-value of ref.

    Whether this migration should run in a transaction.

    Whether this migration should run in a transaction.

    migratus 1.0.6
    MIGRATE ALL THE THINGS!
    migratus.protocols/tx?SourceDoc + Usages
    Whether this migration should run in a transaction.

    celtuce-core 0.3.1
    An idiomatic Clojure Redis client wrapping the Java client Lettuce
    celtuce.commands/mwatchSourceDoc + Usages
    Watch keys to determine execution of a transaction

    celtuce-core 0.3.1
    An idiomatic Clojure Redis client wrapping the Java client Lettuce
    celtuce.commands/watchSourceDoc + Usages
    Watch key to determine execution of a transaction

    celtuce-core 0.3.1
    An idiomatic Clojure Redis client wrapping the Java client Lettuce
    celtuce.impl.server/mwatch~RedisCommands~TransactionalCommandsSourceDoc + Usages
    Watch keys to determine execution of a transaction

    celtuce-core 0.3.1
    An idiomatic Clojure Redis client wrapping the Java client Lettuce
    celtuce.impl.server/watch~RedisCommands~TransactionalCommandsSourceDoc + Usages
    Watch key to determine execution of a transaction

    clojure.jdbc 0.4.0
    clojure.jdbc is a library for low level, jdbc-based database access.
    jdbc.transaction/begin!~$~ITransactionStrategySourceDoc + Usages
    Starts a transaction and return a connection instance.

    clojure.jdbc 0.4.0
    clojure.jdbc is a library for low level, jdbc-based database access.
    jdbc.transaction/begin!SourceDoc + Usages
    Starts a transaction and return a connection instance.

    biodb 0.2.4
    FIXME: write description
    biodb.core/with-transactionSourceDoc + Usages
    Perform multiple operations within a transaction.

    sjdbc 0.1.5
    Very simple JDBC library allows you to write simple SQL as is and send to jdbc,
    sjdbc.core/no-transactionSourceDoc + Usages
    same as exec but with :transaction? set to false

    clj-pg 0.0.3
    Collection of helpers to work with pg from clj
    clj-pg.honey/execute!SourceDoc + Usages
    execute honey SQL out of transaction

    pseudoace 0.5.7
    WormBase database migration library and CLI.
    pseudoace.ts-import/latest-transaction-dateSourceDoc + Usages
    Returns the `date-time` of the latest transaction.

    Watch keys to determine execution of a transaction

    Watch key to determine execution of a transaction

    cljs-iota 1.0.1
    ClojureScript API for IOTA JavaScript API
    cljs-iota.utils/transaction-object (cljs)SourceDoc + Usages
    Converts the trytes of a transaction into its transaction object.
    
      iota - IOTA client instance
      trytes: string 2673-trytes of a transaction
    
      Returns transaction map.

    immutant-xa 1.1.4
    The Immutant xa module.
    immutant.xa.transaction/enlistSourceDoc + Usages
    Enlist XA resources in the current transaction

    bcbio.run 0.0.5
    Idempotent, transactional runs of external command line programs.
    bcbio.run.itx/with-tx-fileSourceDoc + Usages
    Handle a single file in a transaction directory.

    redis 0.2.2
    Redis support for Judgr
    judgr.redis.db/with-transactionSourceDoc + Usages
    Runs body inside a Redis transaction.

    gelfino-client 0.8.1
    A Gelf logging client including a timbre adapter
    gelfino.timbre/append-tidSourceDoc + Usages
    Appends transaction id number if exists

    entity-txn 0.1.0
    CRUD Transactions
    entitytxn.core/abortSourceDoc + Usages
    Abort the transaction. Transaction state is discarded and any :on-abort function
      is called. Further use of the transaction is not permitted.
    
      abort is called if the transaction body incurs an exception.

    entity-txn 0.1.0
    CRUD Transactions
    entitytxn.core/get-actionSourceDoc + Usages
    Get the action for the given transaction and identity

    bitcljoin 0.4.5
    BitCoin library for Clojure
    bitcoin.core/for-me?SourceDoc + Usages
    Does this transaction belong to our wallet?

    bitcljoin 0.4.5
    BitCoin library for Clojure
    bitcoin.core/senderSourceDoc + Usages
    Returns address of first input of transaction

    jepsen.tendermint 0.1.0
    Jepsen tests for the Tendermint Byzantine consensus system
    jepsen.tendermint.client/txSourceDoc + Usages
    Construct a merkleeyes transaction byte buffer

    jepsen.tendermint 0.1.0
    Jepsen tests for the Tendermint Byzantine consensus system
    jepsen.tendermint.client/tx-typeSourceDoc + Usages
    Returns the byte for a transaction type keyword

    clj.jdbc 0.1.1
    Alternative implementation of jdbc wrapper for clojure. For this momment, the official
    jdbc.transaction/begin!~DefaultTransactionStrategy~ITransactionStrategySourceDoc + Usages
    Starts a transaction and return a connection instance

    clj.jdbc 0.1.1
    Alternative implementation of jdbc wrapper for clojure. For this momment, the official
    jdbc.transaction/begin!SourceDoc + Usages
    Starts a transaction and return a connection instance

    supermodel 0.1.0
    Powertools for extending an information model
    supermodel.datomic/assertSourceDoc + Usages
    Generates transaction data asserting an entity.

    dunaj-lite 0.7.0
    Dunaj lite - An alternative core API for Clojure.
    dunaj.state.ref/-alter~Ref~IRefSourceDoc + Usages
    Must be called in a transaction. Sets the in-transaction-value of
        `_this_` to: `(apply _f_ in-transaction-value-of-ref _args_)`
        and returns the in-transaction-value of `_this_`.

    neo4j-clj 1.1.0
    Clojure bindings for Neo4j using the Java driver
    joplin.neo4j.database/with-connectionSourceDoc + Usages
    Wraps expr in Neo4j connection & transaction.

    suricatta 0.2.2
    High level sql toolkit for clojure (backed by jooq library)
    suricatta.core/atomic-applySourceDoc + Usages
    Execute a function in one transaction
      or subtransaction.

    clj-sophia 0.4.4
    A Clojure driver for Sophia DB. Sophia is RAM-Disk hybrid storage
    com.brunobonacci.sophia/with-transactionSourceDoc + Usages
    bindings => [name init ...]
      Evaluates body in a transaction. At the end of the block
      the transaction is committed. If an exception occur before
      the transaction is rolled back.

    asphalt 0.6.7
    A Clojure library for JDBC access
    asphalt.transaction/tp-requiredSourceDoc + Usages
    Use current transaction if it exists, create new transaction otherwise.
      Options:
        :isolation - the transaction isolation level

    asphalt 0.6.7
    A Clojure library for JDBC access
    asphalt.transaction/tp-nestedSourceDoc + Usages
    Start nested transaction if a transaction exists, behave like tp-required otherwise.
      Options:
        :isolation - transaction isolation

    asphalt 0.6.7
    A Clojure library for JDBC access
    asphalt.transaction/tp-requiredSourceDoc + Usages
    Use current transaction if it exists, create new transaction otherwise.
      Options:
        :isolation - the transaction isolation level

    entity-sql 0.1.1
    SQL persistence for use with entity-core
    entity.sql.hug/with-transactionSourceDoc + Usages
    Runs the body in a jdbc transaction using conn as the transaction connection.
       The isolation level and readonly status of the transaction may also be specified.
       (with-transaction [conn {:isolation level :read-only? true}]
         ... )
       See clojure.java.jdbc/db-transaction* for more details on the transaction
       options.

    datumbazo 0.13.21
    Clojure Database Kung-Foo
    datumbazo.driver.core/with-transaction*SourceDoc + Usages
    Start a new `db` transaction call `f` with `db` as argument and
      commit the transaction. If `f` throws any exception the transaction
      gets rolled back.

    bitcljoin 0.4.5
    BitCoin library for Clojure
    bitcoin.core/on-tx-broadcast-to-addressSourceDoc + Usages
    calls f with the peer and transaction if transaction is received to the given wallet.
       This is called before the transaction is included in a block. Use it for SatoshiDice like applications

    bitcljoin 0.4.5
    BitCoin library for Clojure
    bitcoin.core/on-tx-broadcast-to-walletSourceDoc + Usages
    calls f with the peer and transaction if transaction is received to the given wallet.
       This is called before the transaction is included in a block. Use it for SatoshiDice like applications

    teporingo 2.1.31
    Teporingo: Rabbit Client Library
    teporingo.redis.client/transaction*SourceDoc + Usages
    Creates a new transaction (See Jedis.pipelined) on the current connection and executes f in the transaction (wrapped with multi and exec).  Returns the sequence of results of executing the transaction.

    potemkin 0.4.5
    Some useful facades.
    potemkin.utils/try*SourceDoc + Usages
    A variant of try that is fully transparent to transaction retry exceptions

    Map transaction isolation constants to our keywords.

    Marks the outermost transaction such that it will not rollback when complete

    lein-ancient 0.6.15
    Check your Projects for outdated Dependencies.
    ancient.potemkin.v0v4v4.potemkin.utils/try*SourceDoc + Usages
    A variant of try that is fully transparent to transaction retry exceptions

    carmine 2.18.1
    Clojure Redis client & message queue
    taoensso.carmine/atomic*SourceDoc + Usages
    Alpha - subject to change. Low-level transaction util.

    korma 0.5.0-RC1
    Tasty SQL for Clojure
    korma.db/is-rollback?SourceDoc + Usages
    Returns true if the current transaction will be rolled back

    web 2.1.10
    Serve web requests using Ring handlers, Servlets, or Undertow HttpHandlers.
    from.potemkin.utils/try*SourceDoc + Usages
    A variant of try that is fully transparent to transaction retry exceptions

    neocons 3.2.0
    Neocons is a feature rich idiomatic Clojure client for the Neo4J REST API. It also
    clojurewerkz.neocons.rest.transaction/begin-txSourceDoc + Usages
    Starts a transaction without any cypher statements and returns it.

    neocons 3.2.0
    Neocons is a feature rich idiomatic Clojure client for the Neo4J REST API. It also
    clojurewerkz.neocons.rest.transaction/statementSourceDoc + Usages
    Populates a Cypher statement to be sent as part of a transaction.

    yetibot.core 1.0.0
    Core yetibot utilities, extracted for shared use among yetibot and
    yetibot.core.models.history/historySourceDoc + Usages
    retrieve all history and sort it by transaction instant

    pe-datomic-utils 0.0.18
    A Clojure library of helper functions when working with Datomic.
    pe-datomic-utils.core/txn-timeSourceDoc + Usages
    Returns the transaction time (instance) of the given entity e.

    fulcro 2.5.5
    A library for building full-stack SPA webapps in Clojure and Clojurescript
    fulcro.history/compressible-tx?SourceDoc + Usages
    Returns true if the given transaction is marked as compressible.

    fulcro 2.5.5
    A library for building full-stack SPA webapps in Clojure and Clojurescript
    fulcro.client.mutations/abort-idsSourceDoc + Usages
    Returns a set of abort IDs from the given transaction.

    retro 0.7.1
    A protocol for revisioned transactions in Clojure.
    retro.core/txn-wrap~Object~WrappedTransactionalSourceDoc + Usages
    Wrap the given thunk in a transaction, returning a new thunk.

    retro 0.7.1
    A protocol for revisioned transactions in Clojure.
    retro.core/txn-wrapSourceDoc + Usages
    Wrap the given thunk in a transaction, returning a new thunk.

    core.typed.infer 0.5.2
    Runtime type inference algorithm for core.typed and clojure.spec.
    clojure.core.typed.dep.potemkin.utils/try*SourceDoc + Usages
    A variant of try that is fully transparent to transaction retry exceptions

    datomic-type-extensions 2018-04-18
    A Clojure library that wraps some Datomic API functions to add type extensions.
    datomic-type-extensions.api/t->txSourceDoc + Usages
    Return the transaction id associated with a t value.

    datomic-type-extensions 2018-04-18
    A Clojure library that wraps some Datomic API functions to add type extensions.
    datomic-type-extensions.api/tx->tSourceDoc + Usages
    Return the t value associated with a transaction id.

    clj-btc 0.11.2
    Clojure bindings for the original (C++) Bitcoin Client
    clj-btc.core/gettxoutSourceDoc + Usages
    Returns details about an unspent transaction output (UTXO)

    modelo 0.1.0
    Relational database abstraction for Clojure
    modelo.db.none/transaction*~NoDb~IDatabaseSourceDoc + Usages
    Calls body-fn within the scope of a database transaction

    modelo 0.1.0
    Relational database abstraction for Clojure
    modelo.db.sql/transaction*~SqlDb~IDatabaseSourceDoc + Usages
    Calls body-fn within the scope of a database transaction

    modelo 0.1.0
    Relational database abstraction for Clojure
    modelo.db/transaction*SourceDoc + Usages
    Calls body-fn within the scope of a database transaction

    cljs-iota 1.0.1
    ClojureScript API for IOTA JavaScript API
    cljs-iota.api/broadcast-bundle (cljs)SourceDoc + Usages
    Takes a tail transaction hash as input, gets the bundle associated with the
      transaction and then rebroadcasts the entire bundle.
    
      Arguments:
      transaction - String Transaction hash, has to be tail
      callback - fn Optional callback

    Generates transaction data to create a fixed clock.

    korma-enhanced 0.3.1
    Tasty SQL for Clojure
    korma.db/is-rollback?SourceDoc + Usages
    Returns true if the current transaction will be rolled back

    korma-enhanced 0.3.1
    Tasty SQL for Clojure
    korma.db/transactionSourceDoc + Usages
    Execute all queries within the body in a single transaction.

    immutant-xa 1.1.4
    The Immutant xa module.
    immutant.xa.transaction/neverSourceDoc + Usages
    JEE Never - throws an exception if there's an active transaction

    immutant-xa 1.1.4
    The Immutant xa module.
    immutant.xa.transaction/after-completionSourceDoc + Usages
    Register a callback to fire when the current transaction is complete

    immutant-xa 1.1.4
    The Immutant xa module.
    immutant.xa.transaction/active?SourceDoc + Usages
    Returns true if currently running within a transaction

    immutant-web 3.0.0-alpha1
    Serve web requests using Ring handlers, Servlets, or Undertow HttpHandlers.
    from.potemkin.utils/try*SourceDoc + Usages
    A variant of try that is fully transparent to transaction retry exceptions

    bcbio.run 0.0.5
    Idempotent, transactional runs of external command line programs.
    bcbio.run.itx/safe-copySourceDoc + Usages
    Perform a safe copy inside a transaction directory.

    bcbio.run 0.0.5
    Idempotent, transactional runs of external command line programs.
    bcbio.run.itx/rename-tx-filesSourceDoc + Usages
    Rename generated transaction files into expected file location.

    postgres-gateway 1.12.1
    ClanHR postgres-gateway
    clanhr.postgres-gateway.core/bulk-save-models!SourceDoc + Usages
    Saves a collection for models.
      TODO: fully async and in a transaction

    pe-apptxn-core 0.0.2
    A Clojure library encapsulating the data model and data access functions of the
    pe-apptxn-core.core/save-apptxnlog-txnSourceDoc + Usages
    Returns a transaction vector.  If the given application transaction ID is
       found in the database, the transaction vector returned consists of a map for
       the creation of the application transaction event log, as well as a map for
       associating the new event log with the found transaction entity.
    
       If the given application transaction ID is NOT found, the transaction vector
       returned consists of a map for the creation of the transaction entity, as
       well as a map for the creation of the event log and a map for associating the
       new event log with the transaction.

    pe-apptxn-core 0.0.2
    A Clojure library encapsulating the data model and data access functions of the
    pe-apptxn-core.core/find-apptxn-by-idSourceDoc + Usages
    Returns the application transaction instance with the given id.

    pe-apptxn-core 0.0.2
    A Clojure library encapsulating the data model and data access functions of the
    pe-apptxn-core.core/save-apptxnlog-txnSourceDoc + Usages
    Returns a transaction vector.  If the given application transaction ID is
       found in the database, the transaction vector returned consists of a map for
       the creation of the application transaction event log, as well as a map for
       associating the new event log with the found transaction entity.
    
       If the given application transaction ID is NOT found, the transaction vector
       returned consists of a map for the creation of the transaction entity, as
       well as a map for the creation of the event log and a map for associating the
       new event log with the transaction.

    azql 0.2.0
    DSL for SQL generation
    azql.core/transaction*SourceDoc + Usages
    Evaluates func in scope of transaction on open database connection.

    tgkorma 0.4.3
    Tasty SQL for Clojure
    korma.db/is-rollback?SourceDoc + Usages
    Returns true if the current transaction will be rolled back

    ceterumnet-korma 0.3.1-RC2
    Tasty SQL for Clojure - ceterumnet fork
    korma.db/is-rollback?SourceDoc + Usages
    Returns true if the current transaction will be rolled back

    ceterumnet-korma 0.3.1-RC2
    Tasty SQL for Clojure - ceterumnet fork
    korma.db/transactionSourceDoc + Usages
    Execute all queries within the body in a single transaction.

    An existing, manged instance is being deleted in the
        transaction.

    entity-txn 0.1.0
    CRUD Transactions
    entitytxn.core/clear-txnSourceDoc + Usages
    Removes all participants and actions from the current transaction

    entity-txn 0.1.0
    CRUD Transactions
    entitytxn.core/get-txn-instanceSourceDoc + Usages
    Get the in-transaction value for the given instance or id
      from the current or specified transaction.
      Returns the transaction value (which, for mutate operations
      is a map of :old-val and :new-val values) or nil if the
      instance is not participating in the transaction.

    Throws if a transaction is not currently running. Returns true otherwise.

    An existing, manged instance is being deleted in the
        transaction.

    pani 0.0.3
    Convenience library for using Firebase with Clojure and Clojurescript
    pani.cljs.core/transact! (cljs)SourceDoc + Usages
    Use the firebase transaction mechanism to update a value atomically

    pani 0.0.3
    Convenience library for using Firebase with Clojure and Clojurescript
    pani.clojure.core/transact!SourceDoc + Usages
    Use the firebase transaction mechanism to update a value atomically

    cantata 0.1.17
    SQL and database abstraction
    cantata.core/with-rollbackSourceDoc + Usages
    Begins a transaction that is immediately set to roll back on completion

    cantata 0.1.17
    SQL and database abstraction
    cantata.core/unset-rollback!SourceDoc + Usages
    Signals that the current transaction should NOT roll back on completion

    cantata 0.1.17
    SQL and database abstraction
    cantata.core/rollback!SourceDoc + Usages
    Signals that the current transaction should roll back on completion

    pedestal.vase 0.9.3
    Vase: Pedestal API Container
    com.cognitect.vase.actions/transact-actionSourceDoc + Usages
    Returns a Pedestal interceptor that executes a Datomic transaction
      on entry.

    bitcljoin 0.4.5
    BitCoin library for Clojure
    bitcoin.core/on-coins-receivedSourceDoc + Usages
    calls f with the transaction prev balance and new balance

    jepsen.tendermint 0.1.0
    Jepsen tests for the Tendermint Byzantine consensus system
    jepsen.tendermint.client/tx-typesSourceDoc + Usages
    A map of transaction type keywords to their magic bytes.

    titanium 1.0.6
    Titanium a powerful Clojure graph library build on top of Aurelius Titan
    clojurewerkz.titanium.graph/new-transactionSourceDoc + Usages
    Creates a new transaction based on the given graph object.

    stardog-clj 5.0.0-RC1
    Stardog-clj: Clojure bindings for Stardog
    stardog.core/with-transactionSourceDoc + Usages
    (with-transaction [connection...] body)
      Executes the body with a transaction on each of the connections. At completion of the body
      the transaction is committed. If the body fails due to exception, the transaction is rolled back.
      This macro intentionally restricts connections to be symbols, to encourage them to be
      bindings in with-open.

    toucan 1.1.7
    Functionality for defining your application's models and querying the database.
    toucan.db/transactionSourceDoc + Usages
    Execute all queries within the body in a single transaction.

    rawat 0.3.3
    FIXME: write description
    rawat.core/schemas->txSourceDoc + Usages
    Builds a Datomic transaction from a collection of prismatic schemas.

    jepsen.mongodb 0.1.1
    FIXME: write description
    jepsen.mongodb.transfer/partial-readSourceDoc + Usages
    Reads the state of all accounts without a transaction in progress.

    jepsen.mongodb 0.1.1
    FIXME: write description
    jepsen.mongodb.transfer/p1-find-txnSourceDoc + Usages
    Finds a single transaction ID in the INITIAL state.

    metabase 0.1.0
    Metabase Community Edition
    metabase.db/transactionSourceDoc + Usages
    Execute all queries within the body in a single transaction.

    cli 0.1.22
    Antistock Command Line Interface
    antistock.broker/charge-transactionSourceDoc + Usages
    Subtract the broker's transaction fee from `portfolio`.

    codax 1.2.0
    Codax is an idiomatic transactional embedded database for clojure
    codax.core/seek-range!SourceDoc + Usages
    Wraps a `seek-range` call in a read transaction for convenience.

    codax 1.2.0
    Codax is an idiomatic transactional embedded database for clojure
    codax.core/seek-to!SourceDoc + Usages
    Wraps a `seek-to` call in a read transaction for convenience.

    codax 1.2.0
    Codax is an idiomatic transactional embedded database for clojure
    codax.core/seek-from!SourceDoc + Usages
    Wraps a `seek-from` call in a read transaction for convenience.

    codax 1.2.0
    Codax is an idiomatic transactional embedded database for clojure
    codax.core/seek-prefix!SourceDoc + Usages
    Wraps a `seek-prefix` call in a read transaction for convenience.

    codax 1.2.0
    Codax is an idiomatic transactional embedded database for clojure
    codax.core/seek-at!SourceDoc + Usages
    Wraps a `seek-at` call in a read transaction for convenience.

    codax 1.2.0
    Codax is an idiomatic transactional embedded database for clojure
    codax.core/with-read-transactionSourceDoc + Usages
    Creates a read transaction object and assigns it to `tx-symbol`.
      This transaction object can be passed to the non-modifying transaction functions.
      Behavior when passed to a modifying transaction function is undefined.
      The final value will be the result of evaluating the `body`.

    codax 1.2.0
    Codax is an idiomatic transactional embedded database for clojure
    codax.core/dissoc-atSourceDoc + Usages
    Deletes all values at the supplied path.
    
      The value will be deleted from the datastore when the transaction is committed, (which
      (occurs  after the `body` of a `with-write-transaction` form).
    
      The path will be prefixed with the transaction `prefix` (if the transaction has one,
      by default, it does not).

    codax 1.2.0
    Codax is an idiomatic transactional embedded database for clojure
    codax.prefix/extend-prefixSourceDoc + Usages
    Conjoins the current transaction prefix with `prefix-extentension`.

    shiroko 0.1.0
    Clojure Data Prevalence Library
    shiroko.core/apply-transactionSourceDoc + Usages
    Persist and apply a transaction, returning a channel that will contain the result. 

    replikativ 0.2.4
    An open, scalable and distributive infrastructure for a data-driven community of
    replikativ.realize/trans-applySourceDoc + Usages
    Apply a transaction to the value due to the eval-fn interpreter.

    consul-clojure 0.7.1
    A Consul client for Clojure applications.
    consul.txn/kv-check-sessionSourceDoc + Usages
    Fails the transaction if key is not currently locked by session.

    datomish 0.3.6
    A persistent, embedded knowledge base inspired by Datomic and DataScript.
    datomish.transact/history~Connection~IConnectionSourceDoc + Usages
    Get the full transaction history DB associated with this connection.

    datomish 0.3.6
    A persistent, embedded knowledge base inspired by Datomic and DataScript.
    datomish.transact/historySourceDoc + Usages
    Get the full transaction history DB associated with this connection.

    qseq 0.6.3
    qseq: a lazy sequence for simply and efficiently consuming Korma
    qseq.core/transactionSourceDoc + Usages
    run some forms inside a transaction with the given transactor

    sunog 0.0.4
    Convenience library for using Firebase with Clojure and Clojurescript
    sunog.clojure.core/swap!SourceDoc + Usages
    Use the firebase transaction mechanism to update a value atomically

    dynohub 1.1.0
    Clojure DynamoDB client with or without Transaction layer
    ozjongwon.dynotx/+requests+SourceDoc + Usages
    list of items participating in the transaction with unique IDs

    Execute (worker connection txn-context) in a transaction

    Execute (worker connection txn-context) in a transaction

    Execute (worker connection txn-context) in a transaction

    Execute (worker connection txn-context) in a transaction

    Execute (worker connection txn-context) in a transaction

    Execute (worker connection txn-context) in a transaction

    Execute (worker connection txn-context) in a transaction

    asphalt 0.6.7
    A Clojure library for JDBC access
    asphalt.type/execute-txnSourceDoc + Usages
    Execute (worker connection txn-context) in a transaction

    archimedes 3.0.0.1
    Clojure wrapper for Tinkerpop Blueprints
    clojurewerkz.archimedes.graph/new-transactionSourceDoc + Usages
    Creates a new transaction based on the given graph object.

    suricatta 0.2.2
    High level sql toolkit for clojure (backed by jooq library)
    suricatta.core/atomicSourceDoc + Usages
    Convenience macro for execute a computation
      in a transaction or subtransaction.

    datumbazo 0.13.21
    Clojure Database Kung-Foo
    datumbazo.driver.core/with-transactionSourceDoc + Usages
    Start a new `db` transaction, bind `db` to `db-sym` and evaluate
      `body` within the transaction.

    datomic-type-extensions 2018-04-18
    A Clojure library that wraps some Datomic API functions to add type extensions.
    datomic-type-extensions.api/as-ofSourceDoc + Usages
    Returns the value of the database as of some point t, inclusive.
       t can be a transaction number, transaction ID, or Date.

    clj-sophia 0.4.4
    A Clojure driver for Sophia DB. Sophia is RAM-Disk hybrid storage
    com.brunobonacci.sophia/delete-key!SourceDoc + Usages
    It deletes a key. like `set-value!` if a transaction is
      passed the change will only be visible when the transaction
      is committed. It returns `nil`.

    entity-txn 0.1.0
    CRUD Transactions
    entitytxn.protocols/create-entitySourceDoc + Usages
    A new, as yet unmanaged domain instance is being created in the
        transaction. Returns the instance to be created when the transaction
        commits.

    entity-txn 0.1.0
    CRUD Transactions
    entitytxn.core/managed?SourceDoc + Usages
    Return whether an instance is managed and therefore able
      to participate in a transaction for mutate/delete. An
      instance that is unmanaged can be marked for creation in the
      transaction.

    A new, as yet unmanaged domain instance is being created in the
        transaction. Returns the instance to be created when the transaction
        commits.

    alchemist 0.1.1
    Database migrations for datomic
    alchemist.util/relativize-temp-idsSourceDoc + Usages
    Replaces temp ids in a transaction with values based on
    there position in the transaction. Ids that are referenced multiple times will have
    the same relative id

    toucan 1.1.7
    Functionality for defining your application's models and querying the database.
    toucan.db/do-in-transactionSourceDoc + Usages
    Execute F inside a DB transaction. Prefer macro form `transaction` to using this directly.

    jepsen.mongodb 0.1.1
    FIXME: write description
    jepsen.mongodb.transfer/p5-clear-pendingSourceDoc + Usages
    Clear the given transaction from the relevant account pending txn lists.
      Returns the transaction.

    teporingo 2.1.31
    Teporingo: Rabbit Client Library
    teporingo.redis.client/transactionSourceDoc + Usages
    Creates a new transaction (See Jedis.pipelined) on the current connection and executes body in the transaction (wrapped with multi and exec).

    metabase 0.1.0
    Metabase Community Edition
    metabase.db/do-in-transactionSourceDoc + Usages
    Execute F inside a DB transaction. Prefer macro form `transaction` to using this directly.

    codax 1.2.0
    Codax is an idiomatic transactional embedded database for clojure
    codax.prefix/push-extend-prefixSourceDoc + Usages
    Stores the current transaction prefix in the prefix stack, then
      sets the transaction prefix to that prefix conjoined with supplied
      `prefix-extension`

    codax 1.2.0
    Codax is an idiomatic transactional embedded database for clojure
    codax.prefix/push-prefixSourceDoc + Usages
    Stores the current transaction prefix in the prefix stack, then
      sets the supplied `prefix` as the active transaction prefix.

    naga 0.1.0
    Forward Chaining Rule Engine
    naga.storage.datomic.core/init!SourceDoc + Usages
    Inputs: [connection]
    
      Initializes storage, and returns the result of any transaction. Returns nil if no transaction was needed.

    dunaj-lite 0.7.0
    Dunaj lite - An alternative core API for Clojure.
    dunaj.state.ref/-ensure~Ref~IRefSourceDoc + Usages
    Must be called in a transaction. Protects `_this_` from
        modification by other transactions. Returns the
        in-transaction-value of `_this_`.

    datomic-cljs 0.0.1-alpha-1
    Datomic REST client for ClojureScript
    datomic-cljs.api/since (cljs)SourceDoc + Usages
    Returns the value of the database since some point t, exclusive.
       t can be a transaction number, transaction ID, or inst.

    datomic-cljs 0.0.1-alpha-1
    Datomic REST client for ClojureScript
    datomic-cljs.api/as-of (cljs)SourceDoc + Usages
    Returns the value of the database as of some point t, inclusive.
       t can be a transaction number, transaction ID, or inst.

    suricatta 0.2.2
    High level sql toolkit for clojure (backed by jooq library)
    suricatta.core/set-rollback!SourceDoc + Usages
    Mark current transaction for rollback.
    
      This function is not safe and it not aborts
      the execution of current function, it only
      marks the current transaction for rollback.

    clota 0.1.1
    Clota - IOTA Library Implemented in Clojure
    clota.client/attach-to-tangleSourceDoc + Usages
    @param { String } host 
       @param { Map } :trunk-transaction :branch-transaction :min-weight-magnitude :trytes)

    spec-tacular 0.6.3
    First-class data specifications for Clojure and Datomic.
    spark.spec-tacular.datomic.deprecated/commit-sp-transactions!SourceDoc + Usages
    if :transaction-log is specified in conn-ctx (a regular sp object),
      we attach its attributes to the transaction.

    spec-tacular 0.6.3
    First-class data specifications for Clojure and Datomic.
    spark.spec-tacular.datomic/commit-transactions!SourceDoc + Usages
    if :transaction-log is specified in conn-ctx (a regular sp object),
       we attach its attributes to the transaction.

    clj-btc 0.11.2
    Clojure bindings for the original (C++) Bitcoin Client
    clj-btc.core/gettransactionSourceDoc + Usages
    Returns an object about the given transaction containing:
       "amount": total amount of the transaction,
       "confirmations": number of confirmations of the transaction,
       "txid": the transaction ID,
       "time": time associated with the transaction.,
       "details" - An array of objects containing: "account", "address",
            "category", "amount", "fee"

    cljs-iota 1.0.1
    ClojureScript API for IOTA JavaScript API
    cljs-iota.api/get-transactions-objects (cljs)SourceDoc + Usages
    Wrapper function for `get-trytes` and the Utility function
      `transaction-objects.` This function basically returns the entire transaction
      objects for a list of transaction hashes.
    
      Arguments:
      iota - IOTA client instance
      hashes - List of transaction hashes
      callback - Callback with error and result
    
      Returns list of all the transaction objects from the corresponding hashes.

    cljs-iota 1.0.1
    ClojureScript API for IOTA JavaScript API
    cljs-iota.utils/transaction-trytes (cljs)SourceDoc + Usages
    Converts a valid transaction object into trytes. Please refer to
      https://domschiener.gitbooks.io/iota-guide/content/chapter1/transactions-and-bundles.html
      for more information what a valid transaction object looks like.
    
      Arguments:
      iota - IOTA client instance
      transaction-object: Object valid transaction object
    
      Returns converted trytes of transaction.

    dunaj-lite 0.7.0
    Dunaj lite - An alternative core API for Clojure.
    dunaj.state.ref/-commute~Ref~IRefSourceDoc + Usages
    Must be called in a transaction. Sets the in-transaction-value
        of `_this_` to: `(apply _f_ in-transaction-value-of-ref _args_)`
        and returns the in-transaction-value of `_this_`.
        At the commit point of the transaction, sets the value of
        `_this_` to be:
        `(apply _f_ most-recently-committed-value-of-ref _args_)`

    clojure.jdbc 0.4.0
    clojure.jdbc is a library for low level, jdbc-based database access.
    jdbc.transaction/call-in-transactionSourceDoc + Usages
    Wrap function in one transaction.
      This function accepts as a parameter a transaction strategy. If no one
      is specified, `DefaultTransactionStrategy` is used.
    
      With `DefaultTransactionStrategy`, if current connection is already in
      transaction, it uses truly nested transactions for properly handle it.
      The availability of this feature depends on database support for it.
    
      Example:
    
      (with-connection dbspec conn
        (call-in-transaction conn (fn [conn] (execute! conn 'DROP TABLE foo;'))))
    
      For more idiomatic code, you should use `with-transaction` macro.
    
      Depending on transaction strategy you are using, this function can accept
      additional parameters. The default transaction strategy exposes two additional
      parameters:
    
      - `:isolation-level` - set isolation level for this transaction
      - `:read-only` - set current transaction to read only
      

    clj.jdbc 0.1.1
    Alternative implementation of jdbc wrapper for clojure. For this momment, the official
    jdbc.transaction/call-in-transactionSourceDoc + Usages
    Wrap function in one transaction.
    
    This function accepts as a parameter a transaction strategy. If no one
    is specified, ``DefaultTransactionStrategy`` is used.
    
    With `DefaultTransactionStrategy`, if current connection is already in
    transaction, it uses truly nested transactions for properly handle it.
    The availability of this feature depends on database support for it.
    
    Example:
    
    (with-connection dbspec conn
      (call-in-transaction conn (fn [conn] (execute! conn 'DROP TABLE foo;'))))
    
    For more idiomatic code, you should use `with-transaction` macro.
    
    Depending on transaction strategy you are using, this function can accept
    additional parameters. The default transaction strategy exposes two additional
    parameters:
    
    - `:isolation-level` - set isolation level for this transaction
    - `:read-only` - set current transaction to read only
    

    hoplon-elem-lib 0.2.0
    Tiny element library for Hoplon.
    javelin.core/dosync* (cljs)SourceDoc + Usages
    Calls the thunk with no arguments within a transaction. Propagation of
      updates to formula cells is deferred until the transaction is complete.
      Input cells *will* update during the transaction. Transactions may be
      nested.
    
      See also: the javelin.core/dosync macro.

    entity-txn 0.1.0
    CRUD Transactions
    entitytxn.core/createSourceDoc + Usages
    Initialise the instance via TxnEvents.create-entity and join the result into the
      transaction for creation. If the instance is already managed or its identity is already
      joined in this or a parent transaction, this is an error.
      Returns the value being created in the transaction.

    entity-txn 0.1.0
    CRUD Transactions
    entitytxn.core/mark-managedSourceDoc + Usages
    If the given instance is not already marked for mutate and therefore
      already in the transaction, mark the given instance as managed and therefore
      eligible to participate in a transaction for mutate/delete. If already being
      mutated in this or a parent transaction return the current value.

    clj.jdbc 0.1.1
    Alternative implementation of jdbc wrapper for clojure. For this momment, the official
    jdbc.transaction/with-transactionSourceDoc + Usages
    Creates a context that evaluates in transaction (or nested transaction).
    
      This is a more idiomatic way to execute some database operations in
      atomic way.
    
      Example:
    
        (with-transaction conn
          (execute! conn 'DROP TABLE foo;')
          (execute! conn 'DROP TABLE bar;'))

    codax 1.2.0
    Codax is an idiomatic transactional embedded database for clojure
    codax.core/with-write-transactionSourceDoc + Usages
    Creates a write transaction object and assigns it to the `tx-symbol`.
      This transaction object can be passed to any of the transaction functions.
      The `body` must evaluate to this object so it can be committed.

    codax 1.2.0
    Codax is an idiomatic transactional embedded database for clojure
    codax.core/get-atSourceDoc + Usages
    Returns the map or other value at the supplied `path`. If it has been modified within
      the current transaction, it will evaluate to the modified value
    
      `path` will be prefixed with the transaction `prefix` (if the transaction has one,
      by default, it does not).

    simbase 0.0.0
    A clojure document similarity server
    simbase.carmine/atomicallySourceDoc + Usages
    Executes all Redis commands in body as a single transaction and returns
      server response vector or an empty vector if transaction failed.
    
      Body may contain a (discard) call to abort transaction.

    hoplon-drift 0.3.0
    Drift in Hoplon.
    javelin.core/dosync* (cljs)SourceDoc + Usages
    Calls the thunk with no arguments within a transaction. Propagation of
      updates to formula cells is deferred until the transaction is complete.
      Input cells *will* update during the transaction. Transactions may be
      nested.
    
      See also: the javelin.core/dosync macro.

    clojure-contrib 1.2.0
    Clojure user contributions library.
    clojure.contrib.sql/is-rollback-onlySourceDoc + Usages
    Returns true if the outermost transaction will rollback rather than
      commit when complete

    clojure-contrib 1.2.0
    Clojure user contributions library.
    clojure.contrib.sql/set-rollback-onlySourceDoc + Usages
    Marks the outermost transaction such that it will rollback rather than
      commit when complete

    clojure 1.10.0-alpha4
    Core language
    clojure.core/syncSourceDoc + Usages
    transaction-flags => TBD, pass nil for now
    
      Runs the exprs (in an implicit do) in a transaction that encompasses
      exprs and any nested calls.  Starts a transaction if none is already
      running on this thread. Any uncaught exception will abort the
      transaction and flow out of sync. The exprs may be run more than
      once, but any effects on Refs will be atomic.

    clojure 1.10.0-alpha4
    Core language
    clojure.core/ref-setSourceDoc + Usages
    Must be called in a transaction. Sets the value of ref.
      Returns val.

    Returns true if the outermost transaction will rollback rather than
      commit when complete

    Marks the outermost transaction such that it will rollback rather than
      commit when complete

    grafter 0.11.2
    Tools for the hard graft of linked data processing
    grafter.rdf.repository/with-transactionSourceDoc + Usages
    Wraps the given forms in a transaction on the supplied repository.
      Exceptions are rolled back on failure.

    datomico 0.2.0
    Use datomic with intention revealing names
    datomico.core/build-seed-dataSourceDoc + Usages
    Given a keyword namespace and a vector of data, prepares seed data for a transaction.

    neocons 3.2.0
    Neocons is a feature rich idiomatic Clojure client for the Neo4J REST API. It also
    clojurewerkz.neocons.rest.transaction/executeSourceDoc + Usages
    Executes cypher statements in an existing transaction and returns the new transaction record along
      with the cypher results. If no cypher statements are give, the effect is to keep the transaction alive
      (prevent it from timing out).
    
      For more information, see http://docs.neo4j.org/chunked/milestone/rest-api-transactional.html#rest-api-execute-statements-in-an-open-transaction

    neocons 3.2.0
    Neocons is a feature rich idiomatic Clojure client for the Neo4J REST API. It also
    clojurewerkz.neocons.rest.transaction/beginSourceDoc + Usages
    Starts a transaction with the given cypher statements and returns a transaction record along with
      the result of the cypher statements. 0-arity function call starts a transaction without any cypher statements.
    
      For more information, see http://docs.neo4j.org/chunked/milestone/rest-api-transactional.html#rest-api-begin-a-transaction

    transactions 2.1.10
    Provides support for distributed (XA) transactions.
    immutant.transactions.scope/neverSourceDoc + Usages
    JEE Never - throws an exception if there's an active transaction,
      otherwise runs body

    transactions 2.1.10
    Provides support for distributed (XA) transactions.
    immutant.transactions.scope/supportsSourceDoc + Usages
    JEE Supports - run body regardless of current transaction
      state (unpredictable)

    transactions 2.1.10
    Provides support for distributed (XA) transactions.
    immutant.transactions.scope/requires-newSourceDoc + Usages
    JEE RequiresNew - suspend current transaction, if any, and execute
      body in a new one

    retro 0.7.1
    A protocol for revisioned transactions in Clojure.
    retro.core/dotxnSourceDoc + Usages
    Open a transaction around each focus object, then evaluate body, then close the transactions.

    retro 0.7.1
    A protocol for revisioned transactions in Clojure.
    retro.core/wrap-transactionSourceDoc + Usages
    Takes a function and returns a new function wrapped in a transaction on the given object.

    datomic-type-extensions 2018-04-18
    A Clojure library that wraps some Datomic API functions to add type extensions.
    datomic-type-extensions.api/basis-tSourceDoc + Usages
    Returns the t of the most recent transaction reachable via this db value.

    immutant-transactions 3.0.0-alpha1
    Provides support for distributed (XA) transactions.
    immutant.transactions.scope/neverSourceDoc + Usages
    JEE Never - throws an exception if there's an active transaction,
      otherwise runs body

    immutant-transactions 3.0.0-alpha1
    Provides support for distributed (XA) transactions.
    immutant.transactions.scope/supportsSourceDoc + Usages
    JEE Supports - run body regardless of current transaction
      state (unpredictable)

    immutant-transactions 3.0.0-alpha1
    Provides support for distributed (XA) transactions.
    immutant.transactions.scope/requires-newSourceDoc + Usages
    JEE RequiresNew - suspend current transaction, if any, and execute
      body in a new one

    clj-btc 0.11.2
    Clojure bindings for the original (C++) Bitcoin Client
    clj-btc.core/listunspentSourceDoc + Usages
    (version 0.7) Returns array of unspent transaction inputs in the wallet.

    clj-btc 0.11.2
    Clojure bindings for the original (C++) Bitcoin Client
    clj-btc.core/gettxoutsetinfoSourceDoc + Usages
    Returns statistics about the unspent transaction output (UTXO) set

    clj-btc 0.11.2
    Clojure bindings for the original (C++) Bitcoin Client
    clj-btc.core/getrawmempoolSourceDoc + Usages
    (version 0.7) Returns all transaction ids in memory pool

    clj-btc 0.11.2
    Clojure bindings for the original (C++) Bitcoin Client
    clj-btc.core/decoderawtransactionSourceDoc + Usages
    (version 0.7) Produces a human-readable JSON object for a raw transaction.

    pseudoace 0.5.7
    WormBase database migration library and CLI.
    pseudoace.acedump/tx->tsSourceDoc + Usages
    Generate an ACeDB-style timestamp string from a pseudoace transaction entity map.

    modelo 0.1.0
    Relational database abstraction for Clojure
    modelo.db.none/rollback~NoDb~IDatabaseSourceDoc + Usages
    Signals that the current transaction should be rolled back upon
         completion

    modelo 0.1.0
    Relational database abstraction for Clojure
    modelo.db.sql/rollback~SqlDb~IDatabaseSourceDoc + Usages
    Signals that the current transaction should be rolled back upon
         completion

    modelo 0.1.0
    Relational database abstraction for Clojure
    modelo.db/rollbackSourceDoc + Usages
    Signals that the current transaction should be rolled back upon
         completion

    cljs-iota 1.0.1
    ClojureScript API for IOTA JavaScript API
    cljs-iota.api/replay-bundle (cljs)SourceDoc + Usages
    Takes a tail transaction hash as input, gets the bundle associated with the
      transaction and then replays the bundle by attaching it to the tangle.
    
      Arguments:
      transaction: String Transaction hash, has to be tail
      depth: int depth
      min-weight-magnitude: int minimun weight magnitude
      callback: fn Optional callback 

    cljs-iota 1.0.1
    ClojureScript API for IOTA JavaScript API
    cljs-iota.api/get-trytes (cljs)SourceDoc + Usages
    Returns the raw transaction data (trytes) of a specific transaction. These
      trytes can then be easily converted into the actual transaction object. See
      utility functions for more details.
    
      Arguments:
      iota - IOTA client instance
      hashes -List of transaction hashes of which you want to get trytes from.
      callback - Callback with error and result

    immutant-xa 1.1.4
    The Immutant xa module.
    immutant.xa.transaction/mandatorySourceDoc + Usages
    JEE Mandatory - throws an exception unless there's an active transaction

    immutant-xa 1.1.4
    The Immutant xa module.
    immutant.xa.transaction/supportsSourceDoc + Usages
    JEE Supports - run body regardless of current transaction state (unpredictable)

    immutant-xa 1.1.4
    The Immutant xa module.
    immutant.xa.transaction/requires-newSourceDoc + Usages
    JEE RequiresNew - suspend current transaction, if any, and wrap body in a new one

    immutant-xa 1.1.4
    The Immutant xa module.
    immutant.xa.transaction/set-rollback-onlySourceDoc + Usages
    Modify the current transaction such that the only possible outcome is a roll back

    bcbio.run 0.0.5
    Idempotent, transactional runs of external command line programs.
    bcbio.run.itx/with-tx-filesSourceDoc + Usages
    Perform action with files, keeping need-tx files in a transaction.

    bcbio.run 0.0.5
    Idempotent, transactional runs of external command line programs.
    bcbio.run.itx/safe-tx-filesSourceDoc + Usages
    Update file-info with need-tx files in a safe transaction directory.

    postgres-gateway 1.12.1
    ClanHR postgres-gateway
    clanhr.postgres-gateway.config/transaction-run!SourceDoc + Usages
    Runs the given fn in a transaction. Expects f to return a channel
      with a result

    asosio.utils 0.0.4
    The Asosio Utils is a collection of utilities that makes development of clojure
    asosio.utils.db/with-txSourceDoc + Usages
    Open a DB connection and wrap 'body' as an
      atomic action (a transaction).

    clj-sophia 0.4.4
    A Clojure driver for Sophia DB. Sophia is RAM-Disk hybrid storage
    com.brunobonacci.sophia/commit-resultSourceDoc + Usages
    If the transaction fails, and the silent flag is false
       an exception is raised, otherwise the status is returned.

    cloth 0.3.1
    Clojure(Script) tools for Ethereum
    cloth.core/when-minedSourceDoc + Usages
    Given a transaction hash it polls every 5 seconds to see if it's mined

    cloth 0.3.1
    Clojure(Script) tools for Ethereum
    cloth.core/when-minedSourceDoc + Usages
    Given a transaction hash it polls every 5 seconds to see if it's mined

    entity-txn 0.1.0
    CRUD Transactions
    entitytxn.core/participating-asSourceDoc + Usages
    Determine whether the given instance (or instance identity)
      is participating in the current or specified transaction. Depending
      on the action given, the return value is
          :create/delete - the value in the transaction
          :mutate - the current value in the transaction
          :joined - whichever of the above applies
          false when participating but not with the specified action
          nil when not present in the transaction at all

    eisen 0.1.0
    A Language for Programmable Applications
    blancas.eisen.clojure/transexSourceDoc + Usages
    Parses a transaction statement.
    
       ( 'locking' | 'io' | 'sync' | 'dosync' )
       [expr ( ';' expr )*] 'end'

    cantata 0.1.17
    SQL and database abstraction
    cantata.core/rollback?SourceDoc + Usages
    Returns true if the current transaction is set to roll back on completion

    datomisc 0.1.3
    The Datomic utility functions I'm tired having to write.
    datomisc.statement/remove-commandsSourceDoc + Usages
    Given a collection of transaction statements, removes :db/add or :db/remove
      if present.

    fafnir 1.0.3
    A library for building complex transactions for datomic
    fafnir.core/update-allSourceDoc + Usages
    Takes a set of datoms and adds them to the list of datoms to be asserted in the transaction

    titanium 1.0.6
    Titanium a powerful Clojure graph library build on top of Aurelius Titan
    clojurewerkz.titanium.elements/removed?SourceDoc + Usages
    Returns true if entity has been deleted in the current transaction,
       false otherwise

    titanium 1.0.6
    Titanium a powerful Clojure graph library build on top of Aurelius Titan
    clojurewerkz.titanium.graph/rollbackSourceDoc + Usages
    Stops the current transaction and rolls back any changes made.

    stardog-clj 5.0.0-RC1
    Stardog-clj: Clojure bindings for Stardog
    stardog.core/transactSourceDoc + Usages
    (transact pool (something con ..))
      Executes a function over a connection pool and transaction

    kamal 0.7.3
    An application that provides routing based on external sources and OSM data
    hiposfer.kamal.network.generators/waysSourceDoc + Usages
    returns a sequence of way objects ready to be used in a Datascript transaction

    clj-record 1.1.4
    A pseudo-port of ActiveRecord to the Clojure programming language
    clj-record.core/transactionSourceDoc + Usages
    Runs body in a single DB transaction, first ensuring there's a connection.

    Disable auto-commit for this transaction, and make the transaction `rollback-only`, which means when the transaction finishes `.rollback` will be called instead of `.commit`.
       Furthermore, execute F in a try-finally block; in the `finally`, manually call `.rollback` just to be extra-double-sure JDBC any changes made by the transaction aren't committed.

    stripe-clj 0.3.5
    Schemafied Stripe bindings for Clojure.
    stripe.balance/FeeDetailsSourceDoc + Usages
    Details about this particular Stripe fee in the Balance Transaction
      fee breakdown list.

    datsync 0.0.1-alpha3
    Datomic <-> DataScript syncing/replication utilities
    dat.sync.client/normalized-tx-map-formSourceDoc + Usages
    Takes a transaction map form and translates it into a collection of list forms

    codax 1.2.0
    Codax is an idiomatic transactional embedded database for clojure
    codax.core/seek-prefix-range!SourceDoc + Usages
    Wraps a `seek-prefix-range` call in a read transaction for convenience.

    codax 1.2.0
    Codax is an idiomatic transactional embedded database for clojure
    codax.core/update-atSourceDoc + Usages
    Runs a function on the current map or value at the supplied path and `assoc-at`s the result.
    
      The values will be changed in the datastore when the transaction is committed
      (occurs  after the `body` of a `with-write-transaction` form).
    
      All paths will be prefixed with the transaction `prefix` (if the transaction has one,
      by default, it does not).

    codax 1.2.0
    Codax is an idiomatic transactional embedded database for clojure
    codax.core/assoc-atSourceDoc + Usages
    Associates a path with a value or object, overwriting the current value (and all nested
      values)
    
      The values will be changed in the datastore when the transaction is committed
      (occurs  after the `body` of a `with-write-transaction` form).
    
      All paths will be prefixed with the transaction `prefix` (if the transaction has one,
      by default, it does not).

    cleancr 1.0-beta3
    Finds and optionally removes carriage return characters from your project text files
    clojure.contrib.sql/is-rollback-onlySourceDoc + Usages
    Returns true if the outermost transaction will rollback rather than
      commit when complete

    cleancr 1.0-beta3
    Finds and optionally removes carriage return characters from your project text files
    clojure.contrib.sql/set-rollback-onlySourceDoc + Usages
    Marks the outermost transaction such that it will rollback rather than
      commit when complete

    fileape 1.1.0
    Write data to files split by topic and rolled over on size or a timeout, files can
    fileape.io/check-roll!SourceDoc + Usages
    helper function that calls reducer-roll-if in a transaction and alters the ref (:state ctx)

    platt 0.0.1
    Clojure interface to the java port of leveldb
    platt.core/transactSourceDoc + Usages
    Sets up a transaction, either all writes in this block succeed or all fail.

    Runs the given fn in a transaction. Is expected that fn returns a channel
      with a result

    asosio-utils 0.0.1
    The Asosio Utils is a collection of utilities that makes development of clojure
    asosio_utils.db/with-txSourceDoc + Usages
    Open a DB connection and wrap 'body' as an
      atomic action (a transaction).

    consul-clojure 0.7.1
    A Consul client for Clojure applications.
    consul.txn/kv-check-indexSourceDoc + Usages
    Fails the transaction if key does not have a modify index equal to
      supplied index.

    datomish 0.3.6
    A persistent, embedded knowledge base inspired by Datomic and DataScript.
    datomish.transact/<transact!SourceDoc + Usages
    Submits a transaction to the database for writing.
    
      Returns a pair-chan resolving to `[result error]`.

    qseq 0.6.3
    qseq: a lazy sequence for simply and efficiently consuming Korma
    qseq.core/jdbc-only-transactorSourceDoc + Usages
    construct a transactor, which runs a transaction on a connection from db

    datomic-simple 0.1.0
    Use datomic with less cognitive overhead
    datomic-simple.core/build-seed-dataSourceDoc + Usages
    Given a keyword namespace and a vector of data, prepares seed data for a transaction.

    clj-r53 1.0.3
    simple clojure bindings for Amazon's Route 53 DNS service
    clj-r53.client/create-A-nameSourceDoc + Usages
    Returns the XML to create a new A name record. For use inside (with-r53-transaction)

    dynohub 1.1.0
    Clojure DynamoDB client with or without Transaction layer
    ozjongwon.dynotx/+applied+SourceDoc + Usages
    indicating whether the transaction has performed the write to the item yet.

    dunaj-lite 0.7.0
    Dunaj lite - An alternative core API for Clojure.
    dunaj.state.ref/-reset~Ref~IRefSourceDoc + Usages
    Must be called in a transaction. Sets the value of `_this_`.
        Returns `_val_`.

    Internal, do not extend. Only extenders should be java.sql.Connection
       and things in the transaction namespace.

    eventful 0.1.0-alpha3
    Event Store client library
    eventful.core/tx-idSourceDoc + Usages
    Gets id of a transaction tx returned by the tx-start or tx-cont fns.

    persister 1.0.1
    Simple Persistence for Clojure
    persister.core/init-dbSourceDoc + Usages
    Make sure to call it before any apply-transaction* call

    asphalt 0.6.7
    A Clojure library for JDBC access
    asphalt.transaction/with-transactionSourceDoc + Usages
    Setup a transaction and evaluate the body of code in specified transaction context, binding `txn-connection-source`
      (symbol or destructuring form) to a transactional connection source (asphalt.type.TxnConnectionSource instance) made
      from specified connection source. Restore old transaction context upon exit on best effort basis.
      See: invoke-with-transaction

    asphalt 0.6.7
    A Clojure library for JDBC access
    asphalt.transaction/tp-neverSourceDoc + Usages
    Throw exception if a transaction exists, execute non-transactionally otherwise. Isolation is ignored.

    asphalt 0.6.7
    A Clojure library for JDBC access
    asphalt.transaction/tp-mandatorySourceDoc + Usages
    Use current transaction, throw exception if unavailable. Isolation is ignored.

    Deletes entity along with all relations, wraps operation in transaction

    Updates entity and all given relations, wraps operation in transaction

    Inserts new entity and all given relations, wraps operation in transaction

    archimedes 3.0.0.1
    Clojure wrapper for Tinkerpop Blueprints
    clojurewerkz.archimedes.graph/rollbackSourceDoc + Usages
    Stops the current transaction and rolls back any changes made.

    korma 0.5.0-RC1
    Tasty SQL for Clojure
    korma.db/transactionSourceDoc + Usages
    Execute all queries within the body in a single transaction.
      Optionally takes as a first argument a map to specify the :isolation and :read-only? properties of the transaction.

    neocons 3.2.0
    Neocons is a feature rich idiomatic Clojure client for the Neo4J REST API. It also
    clojurewerkz.neocons.rest.transaction/with-transactionSourceDoc + Usages
    A basic macro which gives a fine grained control of working in a transaction without manually
      committing or checking for exceptions.
    
      If commit-on-success? is true, then the given transaction is committed on success. Else the user
      is responsible for manually committing/rolling back the transaction. At any stage if there is an
      error, the transaction is rolled back if necessary.
    
      A simple example is given below:
    
      (let [transaction (tx/begin-tx connection)]
      (tx/with-transaction
      connection
      transaction
      true
      (let [[_ result] (tx/execute connection transaction [(tx/statement "CREATE (n) RETURN ID(n)")])]
      (println result))))

    neocons 3.2.0
    Neocons is a feature rich idiomatic Clojure client for the Neo4J REST API. It also
    clojurewerkz.neocons.rest.transaction/rollbackSourceDoc + Usages
    Rolls back an existing transaction.
    
      For more information, see http://docs.neo4j.org/chunked/milestone/rest-api-transactional.html#rest-api-rollback-an-open-transaction

    re-db 0.1.14
    in-memory javascript key-value store inspired by Datomic and DataScript
    re-db.core/notify-listeners (cljs)SourceDoc + Usages
    Notify listeners for supported patterns matched by datoms in transaction.
    
      Listeners are called with the complete :tx-report. A listener is called at most once per transaction.

    clojure.jdbc 0.4.0
    clojure.jdbc is a library for low level, jdbc-based database access.
    jdbc.transaction/with-transaction-strategySourceDoc + Usages
    Set some transaction strategy connection in the current context scope.
      This method not uses thread-local dynamic variables and connection
      preserves a transaction strategy throught threads.

    clojure.jdbc 0.4.0
    clojure.jdbc is a library for low level, jdbc-based database access.
    jdbc.transaction/is-rollback-set?SourceDoc + Usages
    Check if a current connection in one transaction
      is marked for rollback.
    
      This should be used in one transaction, in other case this
      function always return false.

    untangled-datomic 0.4.12
    Datomic plugin for Untangled webapps
    untangled.datomic.schema/entities-in-txSourceDoc + Usages
    Returns a set of entity IDs that were modified in the given transaction.
    
      Parameters:
      `tx-result` : The result of the transaction that was run (e.g. @(d/transact ...))
      

    clj-sophia 0.4.4
    A Clojure driver for Sophia DB. Sophia is RAM-Disk hybrid storage
    com.brunobonacci.sophia/set-value!SourceDoc + Usages
    Set the given value to the database. If a transaction is passed as
      `sophia` the value will be set only if the transaction is
      successfully committed.
      It returns the value which for set in.
      

    gelfino-client 0.8.1
    A Gelf logging client including a timbre adapter
    gelfino.timbre/set-tidSourceDoc + Usages
    Sets tid (transaction id) for current logs,
        this id is later used in search to track a logical transaction (in graylog2 or kibana) of a series of logs.
       

    tgkorma 0.4.3
    Tasty SQL for Clojure
    korma.db/transactionSourceDoc + Usages
    Execute all queries within the body in a single transaction.
      Optionally takes as a first argument a map to specify the :isolation and :read-only? properties of the transaction.

    titanium 1.0.6
    Titanium a powerful Clojure graph library build on top of Aurelius Titan
    clojurewerkz.titanium.graph/with-transactionSourceDoc + Usages
    Evaluates body in the context of a transaction on the specified graph, which must
       support transactions.  The binding provides the graph for the transaction and the
       name to which the transactional graph is bound for evaluation of the body.
       (with-transaction [tx graph]
         (vertex/create! tx)
         ...)
       If the graph supports threaded transactions, the binding may also specify that the
       body be executed in a threaded transaction.
       (with-transaction [tx graph :threaded? true]
          (vertex/create! tx)
          ...)
       Note that `commit` and `rollback` should not be called explicitly inside
       `with-transaction`. If you want to force a rollback, you must throw an
       exception or specify rollback in the `with-transaction` call:
       (with-transaction [tx graph :rollback? true]
          (vertex/create! tx)
          ...)

    clj.jdbc 0.1.1
    Alternative implementation of jdbc wrapper for clojure. For this momment, the official
    jdbc.transaction/with-transaction-strategySourceDoc + Usages
    Set some transaction strategy connection in the current context
      scope.
    
      This method not uses thread-local dynamic variables and
      connection preserves a transaction strategy throught threads.

    clj.jdbc 0.1.1
    Alternative implementation of jdbc wrapper for clojure. For this momment, the official
    jdbc.transaction/is-rollback-set?SourceDoc + Usages
    Check if a current connection in one transaction
      is marked for rollback.
    
      This should be used in one transaction, in other case this
      function always return false.
      

    Must be called in a transaction. Protects a part of the ref from 
        modification by other transactions.  Returns the in-transaction-value of
        this part of the ref (that is (deref-in aref ks)).

    Must be called in a transaction. Protects a part of the ref from 
        modification by other transactions.  Returns the in-transaction-value of
        this part of the ref (that is (deref-in aref ks)).

    megaref 0.2.0
    FIXME: write description
    net.cgrand.megaref/ensure-inSourceDoc + Usages
    Must be called in a transaction. Protects a part of the ref from 
        modification by other transactions.  Returns the in-transaction-value of
        this part of the ref (that is (deref-in aref ks)).

    codax 1.2.0
    Codax is an idiomatic transactional embedded database for clojure
    codax.core/seek-atSourceDoc + Usages
    Provides key-value pairs ordered by key of the map at the provided `path`.
    
      `path` will be prefixed with the transaction `prefix` (if the transaction has one,
      by default, it does not).

    fulcro-datomic 2.0.0-alpha1
    Datomic plugin for Fulcro webapps
    fulcro.datomic.schema/entities-in-txSourceDoc + Usages
    Returns a set of entity IDs that were modified in the given transaction.
    
      Parameters:
      `tx-result` : The result of the transaction that was run (e.g. @(d/transact ...))
      

    luminus-db 0.1.1
    Luminus database connection management library
    luminus-db.core/with-transactionSourceDoc + Usages
    runs the body in a transaction where t-conn is the name of the transaction connection
       the body will be evaluated within a binding where conn is set to the transactional
       connection

    consul-clojure 0.7.1
    A Consul client for Clojure applications.
    consul.txn/kv-getSourceDoc + Usages
    Gets the key during the transaction. This fails the transaction if
      the key doesn't exist. The key may not be present in the results if
      ACLs do not permit it to be read.

    consul-clojure 0.7.1
    A Consul client for Clojure applications.
    consul.txn/kv-unlockSourceDoc + Usages
    Gets the key during the transaction. This fails the transaction if
      the key doesn't exist. The key may not be present in the results if
      ACLs do not permit it to be read.

    clj-orient 0.5.0
    Wrapper for the OrientDB Native APIs. It supports version 1.1 of the APIs.
    clj-orient.core/with-txSourceDoc + Usages
    Runs the following forms inside a transaction.
    If an exception arrises, the transaction will fail inmediately and do an automatic rollback.
    The exception will be rethrown so the programmer can catch it.

    archimedes 3.0.0.1
    Clojure wrapper for Tinkerpop Blueprints
    clojurewerkz.archimedes.graph/with-transactionSourceDoc + Usages
    Evaluates body in the context of a transaction on the specified graph, which must
       support transactions.  The binding provides the graph for the transaction and the
       name to which the transactional graph is bound for evaluation of the body.
    
       (with-transaction [tx graph]
         (vertex/create! tx)
         ...)
    
       If the graph supports threaded transactions, the binding may also specify that the
       body be executed in a threaded transaction.
    
       (with-transaction [tx graph :threaded? true]
          (vertex/create! tx)
          ...)
    
       Note that `commit` and `rollback` should not be called explicitly inside
       `with-transaction`. If you want to force a rollback, you must throw an
       exception or specify rollback in the `with-transaction` call:
    
       (with-transaction [tx graph :rollback? true]
          (vertex/create! tx)
          ...)

    Evaluates body in the context of a transaction on the specified database connection.
      The binding provides the database connection for the transaction and the name to which
      that is bound for evaluation of the body. The binding may also specify the isolation
      level for the transaction, via the :isolation option and/or set the transaction to
      readonly via the :read-only? option.
      (with-db-transaction [t-con db-spec {:isolation level :read-only? true}]
        ... t-con ...)
      See db-transaction* for more details.

    cljs-iota 1.0.1
    ClojureScript API for IOTA JavaScript API
    cljs-iota.api/get-bundle (cljs)SourceDoc + Usages
    This function returns the bundle which is associated with a transaction.
      Input has to be a tail transaction (i.e. current-index = 0). If there are
      conflicting bundles (because of a replay for example) it will return multiple
      bundles. It also does important validation checking (signatures, sum, order)
      to ensure that the correct bundle is returned.
    
      Arguments:
      transaction - String Transaction hash, has to be tail
      callback - fn Optional callback
    
      Returns a collection of the corresponding bundle of a tail transaction. The
      bundle itself consists of individual transaction objects

    clj-sophia 0.4.4
    A Clojure driver for Sophia DB. Sophia is RAM-Disk hybrid storage
    com.brunobonacci.sophia.native/sp_commitSourceDoc + Usages
    sp_commit - commit a multi-statement transaction
    
      DESCRIPTION:
    
      sp_commit(transaction): commit a transaction
    
      The sp_commit() function is used to apply changes of a
      multi-statement transaction. All modifications that were made during
      the transaction are written to the log file in a single batch.
    
      If commit failed, transaction modifications are discarded.
    
      For additional information take a look at Transactions and Deadlock
      sections.
    
      RETURN VALUE:
    
      On success, sp_commit() returns 0. On error, it returns -1. On
      rollback 1 is returned, 2 on lock.
      

    metosin-common 0.4.1
    Random collection of various namespaces used in multiple Metosin projects.
    metosin.jdbc/with-db-transactionSourceDoc + Usages
    Evaluates body in the context of a transaction on the specified database connection.
      The binding provides the database connection for the transaction and the name to which
      that is bound for evaluation of the body. The binding may also specify the isolation
      level for the transaction, via the :isolation option and/or set the transaction to
      readonly via the :read-only? option.
      (with-db-transaction [t-con db-spec {:isolation level :read-only? true}]
        ... t-con ...)
      See db-transaction* for more details.

    cljs-iota 1.0.1
    ClojureScript API for IOTA JavaScript API
    cljs-iota.api/attach-to-tangle (cljs)SourceDoc + Usages
    Attaches the specified transactions (trytes) to the Tangle by doing Proof of
      Work. You need to supply branch-transaction as well as
      trunk-transaction (basically the tips which you're going to validate and
      reference with this transaction) - both of which you'll get through the
      `get-transactions-to-approve` API call.
    
      The returned value is a different set of tryte values which you can input into
      `broadcast-transactions` and `store-transactions`. The returned tryte value,
      the last 243 trytes basically consist of the: trunk-transaction +
      branch-transaction + nonce. These are valid trytes which are then accepted by
      the network.
    
      Arguments:
      iota - IOTA client instance
      trunk-transaction - Trunk transaction to approve.
      branch-transaction - Branch transaction to approve.
      min-weight-magnitude - Proof of Work intensity. Minimum value is `18`.
      trytes - List of trytes (raw transaction data) to attach to the tangle.
      callback - Callback with error and result.

    clj-sophia 0.4.4
    A Clojure driver for Sophia DB. Sophia is RAM-Disk hybrid storage
    com.brunobonacci.sophia.native/sp_beginSourceDoc + Usages
    sp_begin - start a multi-statement transaction
    
      DESCRIPTION:
    
      sp_begin(env): create a transaction
    
      During transaction, all updates are not written to the database
      files until a sp_commit() is called. All updates that were made
      during transaction are available through sp_get() or by using
      cursor.
    
      The sp_destroy() function is used to discard changes of a
      multi-statement transaction. All modifications that were made during
      the transaction are not written to the log file.
    
      No nested transactions are supported.
    
      For additional information take a look at Transactions and Deadlock
      sections.
    
      RETURN VALUE:
    
      On success, sp_begin() returns transaction object handle. On error,
      it returns NULL.
      

    clojure 1.10.0-alpha4
    Core language
    clojure.core/commuteSourceDoc + Usages
    Must be called in a transaction. Sets the in-transaction-value of
      ref to:
    
      (apply fun in-transaction-value-of-ref args)
    
      and returns the in-transaction-value of ref.
    
      At the commit point of the transaction, sets the value of ref to be:
    
      (apply fun most-recently-committed-value-of-ref args)
    
      Thus fun should be commutative, or, failing that, you must accept
      last-one-in-wins behavior.  commute allows for more concurrency than
      ref-set.

    conman 0.7.8
    a database connection management library
    conman.core/with-transactionSourceDoc + Usages
    Runs the body in a transaction where t-conn is the name of the transaction connection.
       The body will be evaluated within a binding where conn is set to the transactional
       connection. The isolation level and readonly status of the transaction may also be specified.
       (with-transaction [conn {:isolation level :read-only? true}]
         ... t-conn ...)
       See clojure.java.jdbc/db-transaction* for more details on the semantics of the :isolation and
       :read-only? options.

    transactions 2.1.10
    Provides support for distributed (XA) transactions.
    immutant.transactions/transactionSourceDoc + Usages
    Execute body within current transaction, if any, otherwise start a
      new transaction, execute body, and either commit or rollback all
      actions on XA components contained therein atomically. Any exception
      tossed within the body will cause the transaction to rollback.
      Otherwise, the transaction is committed and the value of the last
      expression in the body is returned. This is effectively an alias for
      the [[immutant.transactions.scope/required]] transaction scope.

    clojure.jdbc 0.4.0
    clojure.jdbc is a library for low level, jdbc-based database access.
    jdbc.transaction/with-transactionSourceDoc + Usages
    Creates a context that evaluates in transaction (or nested transaction).
      This is a more idiomatic way to execute some database operations in
      atomic way.
    
      Example:
    
      (with-transaction conn
        (execute! conn 'DROP TABLE foo;')
        (execute! conn 'DROP TABLE bar;'))
    
      Also, you can pass additional options to transaction:
    
      (with-transaction conn {:read-only true}
        (execute! conn 'DROP TABLE foo;')
        (execute! conn 'DROP TABLE bar;'))
      

    datomic-type-extensions 2018-04-18
    A Clojure library that wraps some Datomic API functions to add type extensions.
    datomic-type-extensions.api/tx-rangeSourceDoc + Usages
    Returns a range of transactions in log, starting at start,
    or from beginning if start is nil, and ending before end, or through
    end of log if end is nil. start and end can be can be a transaction
    number, transaction ID, Date or nil.
    
    Each transaction is a map with the following keys:
     :t - the T point of the transaction
     :data -  a Collection of the Datoms asserted/retracted by the transaction

    immutant-transactions 3.0.0-alpha1
    Provides support for distributed (XA) transactions.
    immutant.transactions/transactionSourceDoc + Usages
    Execute body within current transaction, if any, otherwise start a
      new transaction, execute body, and either commit or rollback all
      actions on XA components contained therein atomically. Any exception
      tossed within the body will cause the transaction to rollback.
      Otherwise, the transaction is committed and the value of the last
      expression in the body is returned. This is effectively an alias for
      the [[immutant.transactions.scope/required]] transaction scope.

    megaref 0.2.0
    FIXME: write description
    net.cgrand.megaref/commute-inSourceDoc + Usages
    Must be called in a transaction. Sets the in-transaction-value of aref to:
    
      (apply update-in in-transaction-value-of-ref ks f args)
    
      and returns the in-transaction-value of the commuted part (not the whole
      aref value). 
    
      At the commit point of the transaction, sets the value of ref to be:
    
      (apply update-in most-recently-committed-value-of-ref ks f args)
    
      Thus f should be commutative, or, failing that, you must accept
      last-one-in-wins behavior.  commute-in allows for more concurrency than
      alter-in.

    clojure 1.10.0-alpha4
    Core language
    clojure.core/dosyncSourceDoc + Usages
    Runs the exprs (in an implicit do) in a transaction that encompasses
      exprs and any nested calls.  Starts a transaction if none is already
      running on this thread. Any uncaught exception will abort the
      transaction and flow out of dosync. The exprs may be run more than
      once, but any effects on Refs will be atomic.

    Executes SQL commands on the specified database connection. Wraps the commands
      in a transaction if transaction? is true. transaction? can be omitted and it
      defaults to true. Accepts a single SQL command (string) or a vector of them.
      Uses executeBatch. This may affect what SQL you can run via db-do-commands.

    neocons 3.2.0
    Neocons is a feature rich idiomatic Clojure client for the Neo4J REST API. It also
    clojurewerkz.neocons.rest.transaction/commitSourceDoc + Usages
    Commits an existing transaction with optional cypher statements which are applied
      before the transaction is committed. It returns the result of the cypher statements.
    
      For more information, see http://docs.neo4j.org/chunked/milestone/rest-api-transactional.html#rest-api-commit-an-open-transaction

    clojure.jdbc 0.4.0
    clojure.jdbc is a library for low level, jdbc-based database access.
    jdbc.transaction/set-rollback!SourceDoc + Usages
    Mark a current connection for rollback.
    
      It ensures that on the end of the current transaction
      instead of commit changes, rollback them.
    
      This function should be used inside of a transaction
      block, otherwise this function does nothing.
    
      Example:
    
      (with-transaction conn
        (make-some-queries-without-changes conn)
        (set-rollback! conn))
      

    immutant-xa 1.1.4
    The Immutant xa module.
    immutant.xa/transactionSourceDoc + Usages
    Execute body within the current transaction, if available,
       otherwise invoke body within a new transaction.
    
      This is really just a convenient alias for
      immutant.xa.transaction/required, which is the default behavior for
      transactions in standard JEE containers. See the macros in
      immutant.xa.transaction for finer-grained transactional control
      corresponding to all the analogous attributes of the JEE @Transaction
      annotation.

    views.honeysql 0.2
    HoneySQL view implementation for views
    views.honeysql.core/with-view-transactionSourceDoc + Usages
    Works exactly like clojure.java.jdbc/with-db-transaction. Use this instead to wrap
       vexec! calls which need to be run in a transaction. Holds all view system hints
       generated by any vexec! calls within the transaction until the end, at which point
       they are all sent to the view system.

    entity-txn 0.1.0
    CRUD Transactions
    entitytxn.core/mergeSourceDoc + Usages
    As for clojure.core/merge, however if the target map is managed
      track its state in the transaction. If the map is notmanaged the
      transaction state is unaffected.
    
      The :merge function in the transaction settings is used to perform
      the map operation. Consider using typeops/assoc to maintain value types
      and a fixed key set.

    entity-txn 0.1.0
    CRUD Transactions
    entitytxn.core/assocSourceDoc + Usages
    As for clojure.core/assoc, however if the target map is managed
      track its mutation in the transaction. If the map is not
      managed the transaction state is unaffected.
    
      The :assoc function in the transaction settings is used to perform
      the map operation. Consider using typeops/assoc to maintain value types
      and a fixed key set.

    views.sql 0.1
    Plain SQL view implementation for views
    views.sql.core/with-view-transactionSourceDoc + Usages
    Works exactly like clojure.java.jdbc/with-db-transaction. Use this instead to wrap
       vexec! calls which need to be run in a transaction. Holds all view system hints
       generated by any vexec! calls within the transaction until the end, at which point
       they are all sent to the view system.

    clj.jdbc 0.1.1
    Alternative implementation of jdbc wrapper for clojure. For this momment, the official
    jdbc.transaction/set-rollback!SourceDoc + Usages
    Mark a current connection for rollback.
    
      It ensures that on the end of the current transaction
      instead of commit changes, rollback them.
    
      This function should be used inside of a transaction
      block, otherwise this function does nothing.
    
      Example:
    
        (with-transaction conn
          (make-some-queries-without-changes conn)
          (set-rollback! conn))

    topoged-hibernate 1.0.0
    Hibernate library for Clojure
    topoged.hibernate/with-sessionSourceDoc + Usages
    Execute body in the context of a hibernate trasnascton.
     The session and tx parameters are set with the hibernate session and
    a transaction.  The transaction is commited unless an Exception is
    thrown in body.  If there is an unhandled exception thrown in body,
    the transaction will be rolled back.  The session is also closed
    regardless of any exceptions

    metosin-common 0.4.1
    Random collection of various namespaces used in multiple Metosin projects.
    metosin.jdbc/db-do-commandsSourceDoc + Usages
    Executes SQL commands on the specified database connection. Wraps the commands
      in a transaction if transaction? is true. transaction? can be omitted and it
      defaults to true. Accepts a single SQL command (string) or a vector of them.
      Uses executeBatch. This may affect what SQL you can run via db-do-commands.

    datomish 0.3.6
    A persistent, embedded knowledge base inspired by Datomic and DataScript.
    datomish.db/in-transaction!~DB~IDBSourceDoc + Usages
    Evaluate the given `chan-fn` in an exclusive transaction. If it returns non-nil,
        commit the transaction; otherwise, rollback the transaction.
    
        `chan-fn` should be a function of no arguments returning a pair-chan.
    
        Returns a pair-chan resolving to the same pair as the pair-chan returned by `chan-fn`.

    datomish 0.3.6
    A persistent, embedded knowledge base inspired by Datomic and DataScript.
    datomish.db/in-transaction!SourceDoc + Usages
    Evaluate the given `chan-fn` in an exclusive transaction. If it returns non-nil,
        commit the transaction; otherwise, rollback the transaction.
    
        `chan-fn` should be a function of no arguments returning a pair-chan.
    
        Returns a pair-chan resolving to the same pair as the pair-chan returned by `chan-fn`.

    clj-hl7-fhir 0.3.1
    HL7 FHIR JSON client
    clj-hl7-fhir.core/transactionSourceDoc + Usages
    creates/updates/deletes resources specified in a bundle. if the entire transaction
       succeeded, then a bundle is returned containing changed resources. some servers
       may also return an additional OperationOutcome resource with additional information
       about the transaction. throws an exception if an error response was received.
    
       reference:
       http://hl7.org/implement/standards/fhir/http.html#transaction

    cljs-iota 1.0.1
    ClojureScript API for IOTA JavaScript API
    cljs-iota.api/reattachable? (cljs)SourceDoc + Usages
    This API function helps you to determine whether you should replay a
      transaction or make a completely new transaction with a different seed. What
      this function does, is it takes an input address (i.e. from a spent
      transaction) as input and then checks whether any transactions with a value
      transferred are confirmed. If yes, it means that this input address has
      already been successfully used in a different transaction and as such you
      should no longer replay the transaction.
    
      Arguments:
      iota - IOTA client instance
      input-address: string | collection address used as input in a transaction.
                     Either string or array.
      callback: fn callback function
    
      Returns true or false (if you provided an array, it's an array of bools)

    megaref 0.2.0
    FIXME: write description
    net.cgrand.megaref/alter-inSourceDoc + Usages
    Must be called in a transaction. Sets the in-transaction-value of aref to:
    
      (apply update-in in-transaction-value-of-ref ks f args)
    
      and returns the in-transaction-value of the altered part (not the whole
      aref value).
    
      At the commit point of the transaction, sets the value of ref to be:
    
      (assoc-in most-recently-committed-value-of-ref ks 
        (get-in in-transaction-value-of-ref ks)) 
    
      while maintaining the guarantee that concurrent transactions didn't change
      (get-in value-of-ref ks).
      Thus alter-in offers the alter semantics at the path level rather than at the
      ref level.
      Two concurrent alter-in can commute when their paths are not prefix from one
      another.

    clojure 1.10.0-alpha4
    Core language
    clojure.core/ensureSourceDoc + Usages
    Must be called in a transaction. Protects the ref from modification
      by other transactions.  Returns the in-transaction-value of
      ref. Allows for more concurrency than (ref-set ref @ref)

    transactions 2.1.10
    Provides support for distributed (XA) transactions.
    immutant.transactions.jdbc/factorySourceDoc + Usages
    May be passed via the :factory option to a `clojure.java.jdbc` spec
      that turns operations illegal during an XA
      transaction (commit/rollback/setAutoCommit) into no-ops so that JDBC
      resources manipulated via `clojure.java.jdbc` may participate in a
      distributed transaction

    fulcro 2.5.5
    A library for building full-stack SPA webapps in Clojure and Clojurescript
    fulcro.client.mutations/progressive-update-transactionSourceDoc + Usages
    Given a remote transaction containing one or more remote mutations, returns a local transaction of zero or
      more mutations that should be run to provide a progress update. The `progress` argument will be added to
      each resulting mutation in parameters as `:fulcro.client.network/progress`.

    immutant-transactions 3.0.0-alpha1
    Provides support for distributed (XA) transactions.
    immutant.transactions.jdbc/factorySourceDoc + Usages
    May be passed via the :factory option to a `clojure.java.jdbc` spec
      that turns operations illegal during an XA
      transaction (commit/rollback/setAutoCommit) into no-ops so that JDBC
      resources manipulated via `clojure.java.jdbc` may participate in a
      distributed transaction

    clj-btc 0.11.2
    Clojure bindings for the original (C++) Bitcoin Client
    clj-btc.core/signrawtransactionSourceDoc + Usages
    (version 0.7) Adds signatures to a raw transaction and returns the
      resulting raw transaction.
      txinfo is of the form [{:txid "txid", :vout n,
                              :scriptPubKey "hex"}].
      Exact case is important, pay attention to scriptPubKey.

    cljs-iota 1.0.1
    ClojureScript API for IOTA JavaScript API
    cljs-iota.api/promotable? (cljs)SourceDoc + Usages
    Checks if tail transaction is promotable by calling `check-consistency` API
      call.
    
      Arguments:
      iota - IOTA client instance
      tail - string tail transaction hash
    
      Returns a core.async channel that receives true or false

    entity-txn 0.1.0
    CRUD Transactions
    entitytxn.protocols/mutate-entitySourceDoc + Usages
    An existing instance is being mutated. This event occurs during
        the commit phase and notifies the domain so that it may validate,
        veto by an exception or make further domain changes in the transaction.
        Returns the current in-transaction value.

    entity-txn 0.1.0
    CRUD Transactions
    entitytxn.core/deleteSourceDoc + Usages
    Join the given value into the transaction for deletion. If the
      value is not managed or already scheduled for deletion this is an error.
      If the value has been previously created it is removed from the transaction.
      When successful calls TxnEvents.destroy-entity and returns true. Throws
      otherwise.

    An existing instance is being mutated. This event occurs during
        the commit phase and notifies the domain so that it may validate,
        veto by an exception or make further domain changes in the transaction.
        Returns the current in-transaction value.

    cantata 0.1.17
    SQL and database abstraction
    cantata.core/with-transactionSourceDoc + Usages
    A light wrapper around clojure.java.jdbc/with-db-transaction.
    
      Begins a transaction, binding the connection-bearing db-spec to a given
      symbol. If given a single symbol as the binding, creates a shadowing binding
      with the same name.

    uruk 0.3.11
    Clojure wrapper of MarkLogic XML Content Connector For Java (XCC/J)
    uruk.core/rollbackSourceDoc + Usages
    Rollback a multi-statement transaction to reset any un-committed
      transactions that have already occured in that transaction; for
      example, delete any created items, restore any deleted items, revert
      back any edits, etc.

    codax 1.2.0
    Codax is an idiomatic transactional embedded database for clojure
    codax.core/seek-rangeSourceDoc + Usages
    Provides key-value pairs ordered by key of the map at the provided `path`
      for all keys >= `start-val` and <= `end-val`.
    
      `path` will be prefixed with the transaction `prefix` (if the transaction has one,
      by default, it does not).

    codax 1.2.0
    Codax is an idiomatic transactional embedded database for clojure
    codax.core/seek-toSourceDoc + Usages
    Provides key-value pairs ordered by key of the map at the provided `path`
      for all keys <= `end-val`.
    
      `path` will be prefixed with the transaction `prefix` (if the transaction has one,
      by default, it does not).

    codax 1.2.0
    Codax is an idiomatic transactional embedded database for clojure
    codax.core/seek-fromSourceDoc + Usages
    Provides key-value pairs ordered by key of the map at the provided `path`
      for all keys >= `start-val`.
    
      `path` will be prefixed with the transaction `prefix` (if the transaction has one,
      by default, it does not).

    consul-clojure 0.7.1
    A Consul client for Clojure applications.
    consul.txn/kv-get-treeSourceDoc + Usages
    Gets all keys with a prefix of key during the transaction. This does
      not fail the transaction if the key doesn't exist. Not all keys may be
      present in the results if ACLs do not permit them to be read.

    generations 0.3.0
    Migrations for Datomic schema
    ilshad.generations/installSourceDoc + Usages
    Generation is a plain transaction request, i.e. list of lists
       or list of maps with transaction data. This function takes
       sequence of generations and database connection and installs
       all the generations which are not installed yet.

    clj-gae-ds 0.3.1
    a datastore library on Google App Engine for Clojure
    am.ik.clj-gae-ds.core/with-transactionSourceDoc + Usages
    create transaction block. when use "ds-put", "ds-get", "ds-delete" in this block, 
       automatically transaction begins and is committed after all processes normally finished or is rollbacked if failed.

    asphalt 0.6.7
    A Clojure library for JDBC access
    asphalt.transaction/wrap-transaction-optionsSourceDoc + Usages
    Wrap a fn accepting connection-source as first argument with transaction options. Return the wrapped fn that accepts
      connection-source as first argument, but internally invokes f with transactional connection-source as first argument.
      See: invoke-with-transaction

    spec-tacular 0.6.3
    First-class data specifications for Clojure and Datomic.
    spark.spec-tacular.datomic/ConnCtxSourceDoc + Usages
    A connection context.  The only mandatory field is the `:conn`,
      which provides the actual connection to the database.
    
      Other option fields include:
    
      * `:transaction-log`, any object which can be converted to Datomic
        transaction data

    clojure-contrib 1.2.0
    Clojure user contributions library.
    clojure.contrib.logging/*allow-direct-logging*SourceDoc + Usages
    A boolean indicating whether direct logging (as opposed to via an agent) is
      allowed when not operating from within a transaction. Defaults to true.

    clojure-contrib 1.2.0
    Clojure user contributions library.
    clojure.contrib.logging/*logging-agent*SourceDoc + Usages
    The default agent used for performing logging durng a transaction or when
      direct logging is disabled.

    clojure-contrib 1.2.0
    Clojure user contributions library.
    clojure.contrib.sql.internal/transaction*SourceDoc + Usages
    Evaluates func as a transaction on the open database connection. Any
      nested transactions are absorbed into the outermost transaction. By
      default, all database updates are committed together as a group after
      evaluating the outermost body, or rolled back on any uncaught
      exception. If rollback is set within scope of the outermost transaction,
      the entire transaction will be rolled back rather than committed when
      complete.

    clojure-contrib 1.2.0
    Clojure user contributions library.
    clojure.contrib.sql/transactionSourceDoc + Usages
    Evaluates body as a transaction on the open database connection. Any
      nested transactions are absorbed into the outermost transaction. By
      default, all database updates are committed together as a group after
      evaluating the outermost body, or rolled back on any uncaught
      exception. If set-rollback-only is called within scope of the outermost
      transaction, the entire transaction will be rolled back rather than
      committed when complete.

    grafter 0.11.2
    Tools for the hard graft of linked data processing
    grafter.rdf.protocols/ITransactableSourceDoc + Usages
    Low level protocol for transactions support.  Most users probably
      want to use grafter.rdf.sesame/with-transaction

    pe-datomic-utils 0.0.18
    A Clojure library of helper functions when working with Datomic.
    pe-datomic-utils.core/transact-schema-filesSourceDoc + Usages
    Transacts the set of schema files using conn.  Each schema file is assumed to
      be on the classpath, and contains a single transaction.

    transactions 2.1.10
    Provides support for distributed (XA) transactions.
    immutant.transactions.scope/mandatorySourceDoc + Usages
    JEE Mandatory - throws an exception unless there's an active
      transaction in which body will be run

    transactions 2.1.10
    Provides support for distributed (XA) transactions.
    immutant.transactions.scope/requiredSourceDoc + Usages
    JEE Required - execute within current transaction, if any,
      otherwise run body in a new one

    transactions 2.1.10
    Provides support for distributed (XA) transactions.
    immutant.transactions/enlistSourceDoc + Usages
    Enlist a valid XAResource as a participant in the current
      transaction. Not required for Immutant resources, i.e. messaging and
      caching, as they will be enlisted automatically.

    transactions 2.1.10
    Provides support for distributed (XA) transactions.
    immutant.transactions/set-rollback-onlySourceDoc + Usages
    Modify the current transaction such that the only possible outcome
      is a rollback; useful when rollback is desired but an exception is
      not

    clojure.jdbc 0.4.0
    clojure.jdbc is a library for low level, jdbc-based database access.
    jdbc.transaction/unset-rollback!SourceDoc + Usages
    Revert flag setted by `set-rollback!` function.
      This function should be used inside of a transaction
      block, otherwise this function does nothing.

    fulcro 2.5.5
    A library for building full-stack SPA webapps in Clojure and Clojurescript
    fulcro.ui.forms/parse-txSourceDoc + Usages
    Given a tx-type and data, transforms it into a db transaction.
         OR TODO: Should this be add-tx, set-tx, etc...

    fulcro 2.5.5
    A library for building full-stack SPA webapps in Clojure and Clojurescript
    fulcro.client.impl.data-fetch/is-deferred-transaction?SourceDoc + Usages
    Returns true if the outgoing query is just a placeholder indicator for a deferred transaction in the load queue.

    immutant-transactions 3.0.0-alpha1
    Provides support for distributed (XA) transactions.
    immutant.transactions.scope/mandatorySourceDoc + Usages
    JEE Mandatory - throws an exception unless there's an active
      transaction in which body will be run

    immutant-transactions 3.0.0-alpha1
    Provides support for distributed (XA) transactions.
    immutant.transactions.scope/requiredSourceDoc + Usages
    JEE Required - execute within current transaction, if any,
      otherwise run body in a new one

    immutant-transactions 3.0.0-alpha1
    Provides support for distributed (XA) transactions.
    immutant.transactions/enlistSourceDoc + Usages
    Enlist a valid XAResource as a participant in the current
      transaction. Not required for Immutant resources, i.e. messaging and
      caching, as they will be enlisted automatically.

    immutant-transactions 3.0.0-alpha1
    Provides support for distributed (XA) transactions.
    immutant.transactions/set-rollback-onlySourceDoc + Usages
    Modify the current transaction such that the only possible outcome
      is a rollback; useful when rollback is desired but an exception is
      not

    clj-btc 0.11.2
    Clojure bindings for the original (C++) Bitcoin Client
    clj-btc.core/sendtoaddressSourceDoc + Usages
    <amount> is a real and is rounded to 8 decimal places. Returns the
      transaction ID <txid> if successful.

    clj-btc 0.11.2
    Clojure bindings for the original (C++) Bitcoin Client
    clj-btc.core/sendrawtransactionSourceDoc + Usages
    (version 0.7) Submits raw transaction (serialized, hex-encoded) to
      local node and network.

    clj-btc 0.11.2
    Clojure bindings for the original (C++) Bitcoin Client
    clj-btc.core/createrawtransactionSourceDoc + Usages
    (version 0.7) Creates a raw transaction spending given inputs:
       [{"txid": txid "vout": n}...] {address:amount...}.

    untangled 1.0.0-beta1
    A library for building full-stack SPA webapps in Clojure and Clojurescript
    untangled.ui.forms/parse-txSourceDoc + Usages
    Given a tx-type and data, transforms it into a db transaction.
         OR TODO: Should this be add-tx, set-tx, etc...

    milena 0.4.0-alpha3
    Clojure client for Kafka
    milena.produce/trx-commitSourceDoc + Usages
    Commits the ongoing transaction.
    
       A transaction succeeds only if every step succeeds.
    
       If any record commit hit an irrecoverable error, this function will rethrow that exception and the transaction
       will not be committed. 
    
    
       @ producer
         Kafka producer.
    
       => `producer`
    
    
       Throws
    
         java.lang
        
           IllegalStateException
             When no 'transactional.id' has been configured.
    
         org.apache.kafka.common.errors
    
           ProducerFencedException
             When another producer with the same transaction id is already active.
      
           UnsupportedVersionException
             When the broker does not support transactions.
    
           AuthorizationException
             When the 'transactional.id' is not authorized.
    
           KafkaException
             Any other unrecoverable error.

    modelo 0.1.0
    Relational database abstraction for Clojure
    modelo.core/transactionSourceDoc + Usages
    Causes any queries or statements within the enclosed scope to happen
      within a database transaction.

    safe-append 0.2
    simple journaling for file appends
    com.gotlisp.safe-append/f2mjSourceDoc + Usages
    Provides the 44-byte name of the master journal file for files to
    be modified in a multi-file transaction.

    immutant-xa 1.1.4
    The Immutant xa module.
    immutant.xa.transaction/requiredSourceDoc + Usages
    JEE Required - execute within current transaction, if any, otherwise wrap body in a new one

    gelfino-client 0.8.1
    A Gelf logging client including a timbre adapter
    gelfino.timbre/tidSourceDoc + Usages
    A transaction id that can be used to trace back a logical log flow in central logging 
                 systems like Kibana/Graylog2

    utrecht 0.3.0
    Just enough rope to wrangle a jdbc
    irresponsible.utrecht/rollback~Connection~ConnSourceDoc + Usages
    Rolls back the given transaction, optionally to the named savepoint
         args: [conn] [conn name]

    utrecht 0.3.0
    Just enough rope to wrangle a jdbc
    irresponsible.utrecht/rollbackSourceDoc + Usages
    Rolls back the given transaction, optionally to the named savepoint
         args: [conn] [conn name]

    wile 0.0.0-3
    A few simple wrapper functions for datomic.
    wile.core/intercept-transactSourceDoc + Usages
    Transactions to connection will be intercepted by intercepters.  Intercepters
      must return a valid transaction data structure.

    entity-txn 0.1.0
    CRUD Transactions
    entitytxn.core/in-creation?SourceDoc + Usages
    Return the instance if the given instance (or identity) is marked for
      creation in the current or any parent transaction. Falsy otherwise.

    entity-txn 0.1.0
    CRUD Transactions
    entitytxn.core/in-deletion?SourceDoc + Usages
    Return the instance, as truthy true if the given instance (or identity) is
      marked for deletion in the current or any parent transaction. Falsy otherwise.

    Throw if the given instance has a different id from the original. Returns
      the transaction id otherwise

    entity-txn 0.1.0
    CRUD Transactions
    entitytxn.core/joined?SourceDoc + Usages
    Return true if the given instance (or identity) is joined in some way in
      the current or any parent transaction.

    entity-txn 0.1.0
    CRUD Transactions
    entitytxn.core/remove-participantSourceDoc + Usages
    Remove a participant from this transaction. Note - the only
      transitions this is required for is create -> delete
      and delete -> create -> delete.

    entity-txn 0.1.0
    CRUD Transactions
    entitytxn.core/unlock-allSourceDoc + Usages
    Release all locks held by the current transaction. Locks are
      released in the reverse order in which they were initially taken
      out.

    entity-txn 0.1.0
    CRUD Transactions
    entitytxn.lock/waiting!SourceDoc + Usages
    Add the given promise to any already waiting on the
      specified value. Must be called from within a transaction.

    jdbc-clj 0.0.1
    basic jdbc crud and utility functions
    jdbc.crud/create!SourceDoc + Usages
    Inserts a record in the database with fields from map m
       and returns a new map of the created record. This operates
       on the database within a transaction.

    datomisc 0.1.3
    The Datomic utility functions I'm tired having to write.
    datomisc.statement/prepend-commandsSourceDoc + Usages
    Takes a command (one of :db/add or :db/remove) and a collection of datomic
       transaction statements, and returns the statements with the command added.

    datomisc 0.1.3
    The Datomic utility functions I'm tired having to write.
    datomisc.statement/prepend-commandSourceDoc + Usages
    Takes a command (one of :db/add or :db/remove) and a datomic transaction
       statement, and returns the statement with the command added.

    curd 0.1.4
    Easy and sweet crud without hassle
    curd.core/in-transactionSourceDoc + Usages
    Wraps java.jdbc's with-db-transcation macro. The first input is binding, providing database connection for the
      transaction and the name to which that is bound for evaluation of the body. The binding may also specify
      the isolation level for the transaction, via the :isolation option and/or set the transaction to
      readonly via the :read-only? option.
    
      (in-transaction [conn db {:read-only? true}]
        (....body....))

    curd 0.1.4
    Easy and sweet crud without hassle
    curd.core/delete!SourceDoc + Usages
    Wrapper for java.jdbc's delete! function.
      Inputs are db's spec or transaction, table and sql query
      with parameters.

    curd 0.1.4
    Easy and sweet crud without hassle
    curd.core/execute!SourceDoc + Usages
    Wrapper for java.jdbc's execute! function.
      Input connection can be either db's spec or transaction

    cljain 0.6.0-beta1
    Enjoy JAIN-SIP in Clojure's way.
    cljain.sip.core/new-client-transcation!SourceDoc + Usages
    Before an application can send a new request it must first request
      a new client transaction to handle that Request.

    cljain 0.6.0-beta1
    Enjoy JAIN-SIP in Clojure's way.
    cljain.sip.core/new-server-transaction!SourceDoc + Usages
    An application has the responsibility of deciding to respond to a Request
      that does not match an existing server transaction.

    alchemist 0.1.1
    Database migrations for datomic
    alchemist.util/hash-transactionSourceDoc + Usages
    Returns the hash of the transaction with temp-ids replaced
    with relative values so the results are consistent.

    titanium 1.0.6
    Titanium a powerful Clojure graph library build on top of Aurelius Titan
    clojurewerkz.titanium.elements/modified?SourceDoc + Usages
    Returns true if entity has been loaded and modified in the current transaction,
       false otherwise

    titanium 1.0.6
    Titanium a powerful Clojure graph library build on top of Aurelius Titan
    clojurewerkz.titanium.elements/loaded?SourceDoc + Usages
    Returns true if entity has been loaded and not yet modified in the current transaction,
       false otherwise

    stardog-clj 5.0.0-RC1
    Stardog-clj: Clojure bindings for Stardog
    stardog.core/with-connection-txSourceDoc + Usages
    (with-connection-tx binding-forms body)
       Establishes a connection and a transaction to execute the body within.

    kamal 0.7.3
    An application that provides routing based on external sources and OSM data
    hiposfer.kamal.services.routing.core/cache-stop-successorsSourceDoc + Usages
    computes the next-stops for each stop and returns a transaction
      that will cache those results inside the :stop entities