Struct xpcom::interfaces::mozIStorageBaseStatement

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

interface mozIStorageBaseStatement : mozIStorageBindingParams

/**
 * The base interface for both pure asynchronous storage statements
 * (mozIStorageAsyncStatement) and 'classic' storage statements
 * (mozIStorageStatement) that can be used for both synchronous and asynchronous
 * purposes.
 */

Methods

impl mozIStorageBaseStatement

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

Cast this mozIStorageBaseStatement to one of its base interfaces.

impl mozIStorageBaseStatement

pub const MOZ_STORAGE_STATEMENT_INVALID: i64

MOZ_STORAGE_STATEMENT_INVALID: i64 = 0

/**
   * The statement is not usable, either because it failed to initialize or
   * was explicitly finalized.
   */

pub const MOZ_STORAGE_STATEMENT_READY: i64

MOZ_STORAGE_STATEMENT_READY: i64 = 1

/**
   * The statement is usable.
   */

pub const MOZ_STORAGE_STATEMENT_EXECUTING: i64

MOZ_STORAGE_STATEMENT_EXECUTING: i64 = 2

/**
   * Indicates that the statement is executing and the row getters may be used.
   *
   * @note This is only relevant for mozIStorageStatement instances being used
   *       in a synchronous fashion.
   */

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);

Methods from Deref<Target = mozIStorageBindingParams>

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

Cast this mozIStorageBindingParams to one of its base interfaces.

pub unsafe fn BindByName(
    &self,
    aName: &nsACString,
    aValue: *const nsIVariant
) -> nsresult

/**
   * Binds aValue to the parameter with the name aName.
   *
   * @param aName
   *        The name of the parameter to bind aValue to.
   * @param aValue
   *        The value to bind.
   */

void bindByName (in AUTF8String aName, in nsIVariant aValue);

pub unsafe fn BindUTF8StringByName(
    &self,
    aName: &nsACString,
    aValue: &nsACString
) -> nsresult

[noscript] void bindUTF8StringByName (in AUTF8String aName, in AUTF8String aValue);

pub unsafe fn BindStringByName(
    &self,
    aName: &nsACString,
    aValue: &nsAString
) -> nsresult

[noscript] void bindStringByName (in AUTF8String aName, in AString aValue);

pub unsafe fn BindDoubleByName(
    &self,
    aName: &nsACString,
    aValue: c_double
) -> nsresult

[noscript] void bindDoubleByName (in AUTF8String aName, in double aValue);

pub unsafe fn BindInt32ByName(
    &self,
    aName: &nsACString,
    aValue: int32_t
) -> nsresult

[noscript] void bindInt32ByName (in AUTF8String aName, in long aValue);

pub unsafe fn BindInt64ByName(
    &self,
    aName: &nsACString,
    aValue: int64_t
) -> nsresult

[noscript] void bindInt64ByName (in AUTF8String aName, in long long aValue);

pub unsafe fn BindNullByName(&self, aName: &nsACString) -> nsresult

[noscript] void bindNullByName (in AUTF8String aName);

pub unsafe fn BindBlobByName(
    &self,
    aName: &nsACString,
    aValue: *const uint8_t,
    aValueSize: uint32_t
) -> nsresult

void bindBlobByName (in AUTF8String aName, [array, size_is (aValueSize), const] in octet aValue, in unsigned long aValueSize);

pub unsafe fn BindStringAsBlobByName(
    &self,
    aName: &nsACString,
    aValue: &nsAString
) -> nsresult

void bindStringAsBlobByName (in AUTF8String aName, in AString aValue);

pub unsafe fn BindUTF8StringAsBlobByName(
    &self,
    aName: &nsACString,
    aValue: &nsACString
) -> nsresult

void bindUTF8StringAsBlobByName (in AUTF8String aName, in AUTF8String aValue);

pub unsafe fn BindAdoptedBlobByName(
    &self,
    aName: &nsACString,
    aValue: *mut uint8_t,
    aValueSize: uint32_t
) -> nsresult

[noscript] void bindAdoptedBlobByName (in AUTF8String aName, [array, size_is (aValueSize)] in octet aValue, in unsigned long aValueSize);

pub unsafe fn BindByIndex(
    &self,
    aIndex: uint32_t,
    aValue: *const nsIVariant
) -> nsresult

/**
    * Binds aValue to the parameter with the index aIndex.
    *
    * @param aIndex
    *        The zero-based index of the parameter to bind aValue to.
    * @param aValue
    *        The value to bind.
    */

void bindByIndex (in unsigned long aIndex, in nsIVariant aValue);

pub unsafe fn BindUTF8StringByIndex(
    &self,
    aIndex: uint32_t,
    aValue: &nsACString
) -> nsresult

[noscript] void bindUTF8StringByIndex (in unsigned long aIndex, in AUTF8String aValue);

pub unsafe fn BindStringByIndex(
    &self,
    aIndex: uint32_t,
    aValue: &nsAString
) -> nsresult

[noscript] void bindStringByIndex (in unsigned long aIndex, in AString aValue);

pub unsafe fn BindDoubleByIndex(
    &self,
    aIndex: uint32_t,
    aValue: c_double
) -> nsresult

[noscript] void bindDoubleByIndex (in unsigned long aIndex, in double aValue);

pub unsafe fn BindInt32ByIndex(
    &self,
    aIndex: uint32_t,
    aValue: int32_t
) -> nsresult

[noscript] void bindInt32ByIndex (in unsigned long aIndex, in long aValue);

pub unsafe fn BindInt64ByIndex(
    &self,
    aIndex: uint32_t,
    aValue: int64_t
) -> nsresult

[noscript] void bindInt64ByIndex (in unsigned long aIndex, in long long aValue);

pub unsafe fn BindNullByIndex(&self, aIndex: uint32_t) -> nsresult

[noscript] void bindNullByIndex (in unsigned long aIndex);

pub unsafe fn BindBlobByIndex(
    &self,
    aIndex: uint32_t,
    aValue: *const uint8_t,
    aValueSize: uint32_t
) -> nsresult

void bindBlobByIndex (in unsigned long aIndex, [array, size_is (aValueSize), const] in octet aValue, in unsigned long aValueSize);

pub unsafe fn BindStringAsBlobByIndex(
    &self,
    aIndex: uint32_t,
    aValue: &nsAString
) -> nsresult

void bindStringAsBlobByIndex (in unsigned long aIndex, in AString aValue);

pub unsafe fn BindUTF8StringAsBlobByIndex(
    &self,
    aIndex: uint32_t,
    aValue: &nsACString
) -> nsresult

void bindUTF8StringAsBlobByIndex (in unsigned long aIndex, in AUTF8String aValue);

pub unsafe fn BindAdoptedBlobByIndex(
    &self,
    aIndex: uint32_t,
    aValue: *mut uint8_t,
    aValueSize: uint32_t
) -> nsresult

[noscript] void bindAdoptedBlobByIndex (in unsigned long aIndex, [array, size_is (aValueSize)] in octet aValue, in unsigned long aValueSize);

Trait Implementations

impl XpCom for mozIStorageBaseStatement

const IID: nsIID

IID: nsIID = nsID(382363562, 4901, 17378, [170, 199, 133, 154, 253, 21, 144, 178])

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 mozIStorageBaseStatement

unsafe fn addref(&self)

Increment the reference count.

unsafe fn release(&self)

Decrement the reference count, potentially freeing backing memory.

impl Deref for mozIStorageBaseStatement

type Target = mozIStorageBindingParams

The resulting type after dereferencing.

fn deref(&self) -> &mozIStorageBindingParams

Dereferences the value.