Struct xpcom::interfaces::mozIStorageAsyncStatement

#[repr(C)]
pub struct mozIStorageAsyncStatement { /* fields omitted */ }

interface mozIStorageAsyncStatement : mozIStorageBaseStatement

/**
 * An asynchronous SQL statement.  This differs from mozIStorageStatement by
 * only being usable for asynchronous execution.  (mozIStorageStatement can
 * be used for both synchronous and asynchronous purposes.)  This specialization
 * for asynchronous operation allows us to avoid needing to acquire
 * synchronization primitives also used by the asynchronous execution thread.
 * In contrast, mozIStorageStatement may need to acquire the primitives and
 * consequently can cause the main thread to lock for extended intervals while
 * the asynchronous thread performs some long-running operation.
 */

Methods

impl mozIStorageAsyncStatement

pub fn coerce<T: mozIStorageAsyncStatementCoerce>(&self) -> &T

Cast this mozIStorageAsyncStatement to one of its base interfaces.

Methods from Deref<Target = mozIStorageBaseStatement>

pub fn coerce<T: mozIStorageBaseStatementCoerce>(&self) -> &T

Cast this mozIStorageBaseStatement to one of its base interfaces.

pub const MOZ_STORAGE_STATEMENT_INVALID: i64

pub const MOZ_STORAGE_STATEMENT_READY: i64

pub const MOZ_STORAGE_STATEMENT_EXECUTING: i64

pub unsafe fn Finalize(&self) -> nsresult

/**
   * Finalizes a statement so you can successfully close a database connection.
   * Once a statement has been finalized it can no longer be used for any
   * purpose.
   *
   * Statements are implicitly finalized when their reference counts hits zero.
   * If you are a native (C++) caller this is accomplished by setting all of
   * your nsCOMPtr instances to be NULL.  If you are operating from JavaScript
   * code then you cannot rely on this behavior because of the involvement of
   * garbage collection.
   *
   * When finalizing an asynchronous statement you do not need to worry about
   * whether the statement has actually been executed by the asynchronous
   * thread; you just need to call finalize after your last call to executeAsync
   * involving the statement.  However, you do need to use asyncClose instead of
   * close on the connection if any statements have been used asynchronously.
   */

void finalize ();

pub unsafe fn BindParameters(
    &self,
    aParameters: *const mozIStorageBindingParamsArray
) -> nsresult

/**
   * Binds the array of parameters to the statement.  When executeAsync is
   * called, all the parameters in aParameters are bound and then executed.
   *
   * @param aParameters
   *        The array of parameters to bind to the statement upon execution.
   *
   * @note This is only works on statements being used asynchronously.
   */

void bindParameters (in mozIStorageBindingParamsArray aParameters);

pub unsafe fn NewBindingParamsArray(
    &self,
    _retval: *mut *const mozIStorageBindingParamsArray
) -> nsresult

/**
   * Creates a new mozIStorageBindingParamsArray that can be used to bind
   * multiple sets of data to a statement with bindParameters.
   *
   * @return a mozIStorageBindingParamsArray that multiple sets of parameters
   *         can be bound to.
   *
   * @note This is only useful for statements being used asynchronously.
   */

mozIStorageBindingParamsArray newBindingParamsArray ();

pub unsafe fn ExecuteAsync(
    &self,
    aCallback: *const mozIStorageStatementCallback,
    _retval: *mut *const mozIStoragePendingStatement
) -> nsresult

/**
   * Execute a query asynchronously using any currently bound parameters.  This
   * statement can be reused immediately, and reset does not need to be called.
   *
   * @note If you have any custom defined functions, they must be re-entrant
   *       since they can be called on multiple threads.
   *
   * @param aCallback [optional]
   *        The callback object that will be notified of progress, errors, and
   *        completion.
   * @return an object that can be used to cancel the statements execution.
   */

mozIStoragePendingStatement executeAsync ([optional] in mozIStorageStatementCallback aCallback);

pub unsafe fn GetState(&self, aState: *mut int32_t) -> nsresult

/**
   * Find out whether the statement is usable (has not been finalized).
   */

readonly attribute long state;

pub unsafe fn EscapeStringForLIKE(
    &self,
    aValue: &nsAString,
    aEscapeChar: int16_t,
    _retval: &mut nsAString
) -> nsresult

/**
   * Escape a string for SQL LIKE search.
   *
   * @note Consumers will have to use same escape char when doing statements
   *       such as:   ...LIKE '?1' ESCAPE '/'...
   *
   * @param aValue
   *        The string to escape for SQL LIKE.
   * @param aEscapeChar
   *        The escape character.
   * @return an AString of an escaped version of aValue
   *         (%, _ and the escape char are escaped with the escape char)
   *         For example, we will convert "foo/bar_baz%20cheese"
   *         into "foo//bar/_baz/%20cheese" (if the escape char is '/').
   */

AString escapeStringForLIKE (in AString aValue, in wchar aEscapeChar);

Trait Implementations

impl XpCom for mozIStorageAsyncStatement

const IID: nsIID

IID: nsIID = nsID(1390711664, 15150, 18983, [163, 252, 121, 226, 10, 212, 5, 107])

fn query_interface<T: XpCom>(&self) -> Option<RefPtr<T>>

Perform a QueryInterface call on this object, attempting to dynamically cast it to the requested interface type. Returns Some(RefPtr) if the cast succeeded, and None otherwise.

impl RefCounted for mozIStorageAsyncStatement

unsafe fn addref(&self)

Increment the reference count.

unsafe fn release(&self)

Decrement the reference count, potentially freeing backing memory.

impl Deref for mozIStorageAsyncStatement

type Target = mozIStorageBaseStatement

The resulting type after dereferencing.

fn deref(&self) -> &mozIStorageBaseStatement

Dereferences the value.