Minimum

Minimum

Exposes API's to returns the minimum non-NULL value of all values in the group. The minimum value is the first non-NULL value that would appear in an ORDER BY of the column. Aggregate min() returns NULL if and only if there are no non-NULL values in the group.

Android API: Minimum

    public IMin min() throws DatabaseException;

• Android: IMin Interface

    public interface IMin {

        public IMinClause where(String column);
	
        public IMin whereClause(String whereClause);
	
        public IMinClause and(String column);
	
        public IMinClause or(String column);

        public IMin groupBy(String...columns);
	
        public IMinClause having(String column);

        public IMin havingClause(String havingClause);
	
        public IMin column(String column);
	
        public Object execute() throws DatabaseException;

    }

• Android: IMinClause Interface

    public interface IMinClause {

        public IMin equalTo(String value);

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

Android Sample: Get Minimum

    int minimum = 0;
	
    try {
        minimum = new Book().min().column(Book.COLUMN_NAME_WHICH_CONTAIN_NUMBRIC_VALUE).where(Book.TITLE).equalTo("C").execute();
    } catch(DatabaseException de) {
		//Log it.
    }
	

iOS API: Minimum

    - (id<SICIMin>)min;

• iOS: SICIMin Interface

    @protocol SICIMin <NSObject>

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

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

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

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

    - (id<SICIMin>)groupBy:(NSArray *)columns;

    - (id<SICIMinClause>)having:(NSString *)column;

    - (id<SICIMin>)havingClause:(NSString *)havingClause;

    - (id<SICIMin>)column:(NSString *)column;

    - (id)execute;

    @end

• iOS: SICIMinClause Interface

    @protocol SICIMinClause <NSObject>

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

    - (id<SICIMin>)notEqual:(id)value;

    - (id<SICIMin>)greaterThan:(id)value;
   
    - (id<SICIMin>)greaterThanEqual:(id)value;

    - (id<SICIMin>)lessThan:(id)value;

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

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

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

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

    @end

iOS Sample: Minimum

    double minimum = 0;
	
    @try {
        minimum = [[[[[[[Book alloc] init] min] column:[Book COLUMN_NAME_WHICH_CONTAIN_NUMBRIC_VALUE]] where:[Book TITLE]] equalTo:@"C"] execute];
    } @catch(SICDatabaseException *databaseException) {
		//Log it.
    }

	

Windows API: Minimum

    public IMin Min();

• Windows: IMin Interface

    public interface IMin 
    {
 
        IMinClause Where(String column);
	
        IMin WhereClause(String whereClause);
	
        IMinClause And(String column);
	
        IMinClause Or(String column);

        IMin GroupBy(String[] columns);
	
        IMinClause Having(String column);

        IMin HavingClause(String havingClause);
	
        IMin Column(String column);
	
        double Execute();

    }

• Windows: IMinClause Interface

    public interface IMinClause 
    {

        IMin EqualTo(String value);

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

Windows Sample: Minimum

    double minimum = 0;
	
    try 
    {
        minimum = new Book().Min().Column(Book.COLUMN_NAME_WHICH_CONTAIN_NUMBRIC_VALUE).Where(Book.TITLE).EqualTo("C").Execute();
    } 
    catch(DatabaseException de) 
    {
		//Log it.
    }
	

JavaScript API: Minimum

    this.min = function();

• JavaScript: IMin Interface

    function IMin() {
 
        this.where = function(column);
	
        this.whereClause = function(whereClause);
	
        this.and = function(column);
	
        this.or = function(column);

        this.groupBy = function(columns);
	
        this.having = function(column);

        this.havingClause = function(havingClause);
	
        this.column = function(column);
	
        this.execute = function();

        this.executeAsync = function(callback, transaction);

    }

• JavaScript: IMinClause Interface

    function IMinClause() {

        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: Minimum

    
            /** Minimum Sample **/

    double minimum = 0;
	
    try {
        minimum = new Book().min().column(Book.COLUMN_NAME_WHICH_CONTAIN_NUMBRIC_VALUE).where(Book.TITLE).equalTo("C").execute();
    } catch(de) {
		//Log it.
    }
	

            /** Minimum Async Sample **/

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

    }

    new Book().min().executeAsync(callback);

            /** Minimum Async Transaction Sample **/

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

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

        }

        new Book().min().executeAsync(minCallback, transaction);
    }

    callback.onSuccess = function() {

    }

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