Delete

Delete

Database class provides following API's to delete tuples from table.

Android API: Delete

    public IDelete delete() throws DatabaseException { }

• Android API: IDelete Interface

    public interface IDelete {

        public IDeleteClause where(String column);
	
        public IDelete whereClause(String whereClause); 

        public IDeleteClause and(String column);
	
        public IDeleteClause or(String column);

        public Object execute() throws DatabaseException;

    }

• Android API: IDeleteClause Interface

    public interface IDeleteClause {

        public IDelete equalTo(String value);

        public IDelete notEqualTo(String value);
	
        public IDelete greaterThan(String value);
	
        public IDelete greaterThanEqual(String value);
	
        public IDelete lessThan(String value);
	
        public IDelete lessThanEqual(String value);
	
        public IDelete between(String start, String end);
	
        public IDelete like(String like);
	
        public IDelete in(String...values);

    }

Android Sample: Delete

    Book book = new Book();
    book.delete().execute();

iOS API: Delete

    - (id<SICIDelete>)delete { }

• iOS API: SICIDelete

    @protocol SICIDelete <NSObject>

    - (id<SICIDeleteClause>)where:(NSString *)column;

    - (id<SICIDelete>)whereClause:(NSString *)whereClause;

    - (id<SICIDeleteClause>)and:(NSString *)column;
 
    - (id<SICIDeleteClause>)or:(NSString *)column;

    - (id)execute;

    @end

• iOS API: SICIDeleteClause

    @protocol SICIDeleteClause <NSObject>

    - (id<SICIDelete>)equalTo:(id)value;

    - (id<SICIDelete>)notEqualTo:(id)value;

    - (id<SICIDelete>)greaterThan:(id)value;

    - (id<SICIDelete>)greaterThan:(id)value;
 
    - (id<SICIDelete>)lessThan:(id)value;

    - (id<SICIDelete>)lessThanEqual:(id)value;

    - (id<SICIDelete>)between:(id)start end:(id)end;

    - (id<SICIDelete>)like:(id)like;

    - (id<SICIDelete>)in:(id)values;

    @end

iOS Sample: Delete

    Book *book = [[Book alloc] init];
    [[book delete] execute];

Windows API: Delete

    public IDelete Delete() { }

• Windows API: IDelete

    public interface IDelete 
    {

        IDeleteClause Where(String column);
	
        IDelete WhereClause(String whereClause); 

        IDeleteClause And(String column);
	
        IDeleteClause Or(String column);

        void Execute();

    }

• Windows API: IDeleteClause

    public interface IDeleteClause 
    {

        IDelete EqualTo(String value);

        IDelete NotEqualTo(String value);
	
        IDelete GreaterThan(String value);
	
        IDelete GreaterThanEqual(String value);
	
        IDelete LessThan(String value);
	
        IDelete LessThanEqual(String value);
	
        IDelete Between(String start, String end);
	
        IDelete Like(String like);
	
        IDelete In(String[] values);

    }

Windows Sample: Delete

    Book book = new Book();
    book.Delete().Execute();

JavaScript API: Delete

    - this.delete = function() { }

• JavaScript API: IDelete

    function IDelete() {

        this.where = function(column) {};
	
        this.whereClause = function(whereClause) {}; 

        this.and = function(column) {};
	
        this.or = function(column) {};

        this.execute = function() {};

        this.executeAsync = function(callback, transaction) {};

    }

• JavaScript API: IDeleteClause

    function IDeleteClause() {

        this.equalTo = function(value) {};

        this.notEqualTo = function(value) {};
	
        this.greaterThan = function(value) {};
	
        this.greaterThanEqual = function(value) {};
	
        this.lessThan = function(value) {};
	
        this.lessThanEqual = function(value) {};
	
        this.between = function(start, end) {};
	
        this.like = function(like) {};
	
        this.in = function(values) {};

    }

JavaScript Sample: Delete

            /** Delete Sample **/

    var book = new Book();
    book.delete().execute();

            /** Delete Async Sample **/

    var book = new Book();

    var callback = new Callback();
    callback.onSuccess = function() {

    }

    book.delete().executeAsync(callback);

            /** Delete Async Transaction Sample **/

    var book = new Book();

    var callback = new Callback();
    callback.onExecute = function(transaction) {

        var deleteCallback = new Callback();
        deleteCallback.onSuccess = function() {

        }

        new Book().delete().executeAsync(deleteCallback, transaction);
    }

    callback.onSuccess = function() {

    }

    var databaseDescriptor = new Book().getDatabaseDescriptor();
    Database.beginTransactionAsync(databaseDescriptor, callback);