Class SQL
Base class for all SQL database query types.
This class is an abstract class for all SQL adapter implementations.
An instance of SQL provides methods for querying, updating and removing a datase
Defined in: sql.js.
| Constructor Attributes | Constructor Name and Description |
|---|---|
|
SQL()
|
| Field Attributes | Field Name and Description |
|---|---|
|
the current sql query string.
|
| Method Attributes | Method Name and Description |
|---|---|
| <static> |
SQL.addColumn()
Create an add column statement
See your client adpater for parameters! |
| <static> |
SQL.addForeignKey()
Create a add foreign key statement
See your client adpater for parameters! |
| <static> |
SQL.addPrimaryKey()
Create a add primary key statement
See your client adpater for parameters! |
| <static> |
SQL.addUnique()
Create a add unique constraint statement
See your client adpater for parameters! |
| <static> |
SQL.alterColumn()
Create an alter column statement
See your client adpater for parameters! |
| <static> |
SQL.alterTable(table, db)
Alter a table.
|
|
and(options)
Add and operator, one does not need to call this but it is provided for clarity.
|
|
|
avg(options)
|
|
|
between(options)
Add a between check for a column.
|
|
|
bitAnd(options)
Helper to add a bit and clause.
|
|
|
bitOr(options)
|
|
|
bitXor(options)
Helper to add a bit xor clause.
|
|
|
clear()
Clear the current query.
|
|
|
Clear the having clause from the query.
|
|
|
Clear the limit clause on this SQL query
|
|
|
Removes the offset clause from a query.
|
|
|
Clears the order clause
|
|
|
close()
Close the connection.
|
|
| <static> |
SQL.column()
Create a column statement
See your client adpater for parameters! |
|
count(options)
Add a count cause to the select portion of the query.
|
|
| <static> |
SQL.createTable(table, db)
Create a table.
|
|
crossJoin(table)
Add a cross join to another table
|
|
|
distinct()
Select on dinstict results, same is distinct clause in SQL statment.
|
|
| <static> |
SQL.dropColumn()
Create a drop column statement
See your client adpater for parameters! |
| <static> |
SQL.dropForeignKey()
Create a drop foreign key statement
See your client adpater for parameters! |
| <static> |
SQL.dropPrimaryKey()
Create a drop primary key statement
See your client adpater for parameters! |
| <static> |
SQL.dropTable(table, db)
Drop a table.
|
| <static> |
SQL.dropUnique()
Create a drop unique constraint statement
See your client adpater for parameters! |
|
end()
Performs clean up to add any needed protions of a query if not provided.
|
|
|
eq(options)
Use to find rows that equal a particular value
|
|
|
exec()
Executes the query, when finished the promise callback is called
if the query errors then the promise error is called.
|
|
|
find(query)
This is a wrapper to enable using an object to query a dataset.
|
|
| <static> |
SQL.foreignKey()
Create a foreign key statement
See your client adpater for parameters! |
|
format(sql, array)
Formats and escapes query string.
|
|
| <static> |
SQL.format(sql, array)
Formats and escapes query string.
|
|
fullJoin(table, options)
Add a full join to another table
|
|
|
fullOuterJoin(table, options)
Add a full outer join to another table
|
|
| <static> |
SQL.getLastInsertId(db)
Retrieve the last inserted id on a database.
|
|
group(key, having)
Perform a group operation.
|
|
|
groupAndAvg(key, having)
Helper to add a group and avg clause.
|
|
|
groupAndBitAnd(key, having)
Helper to add a group and bit and clause.
|
|
|
groupAndBitOr(key, having)
Helper to add a group and bit or clause.
|
|
|
groupAndBitXor(key, having)
Helper to add a group and bit xor clause.
|
|
|
groupAndCount(key, having)
Helper to add a group and count clause.
|
|
|
groupAndMax(key, having)
Helper to add a group and max clause.
|
|
|
groupAndMin(key, having)
Helper to add a group and min clause.
|
|
|
groupAndStd(key, having)
Helper to add a group and std clause.
|
|
|
groupAndStdDev(key, having)
Helper to add a group and std dev clause.
|
|
|
groupAndStdDevPop(key, having)
Helper to add a group and std dev pop clause.
|
|
|
groupAndStdDevSamp(key, having)
Helper to add a group and std dev samp clause.
|
|
|
groupAndSum(key, having)
Helper to add a group and sum clause.
|
|
|
groupAndVariance(key, having)
Helper to add a group and variance clause.
|
|
|
groupAndVarPop(key, having)
Helper to add a group and var pop clause.
|
|
|
groupAndVarSamp(key, having)
Helper to add a group and var samp clause.
|
|
|
gt(options)
Use to find rows that are greater than a particular value
|
|
|
gte(options)
Add a check for a value greater than or equal to a particular value.
|
|
|
having(options)
Add a having clause, this is only valid on queries that contain a group clause.
|
|
|
innerJoin(table, options)
Add an inner join to another table
|
|
|
is(options)
Specify an is clause.
|
|
|
isNot(options)
Add is not clause
|
|
|
isNotNull(options)
Check if a column is not null.
|
|
|
isNull(options)
Add is null check
|
|
| <static> |
SQL.isValidType()
Check if a type is a valid type for this adapter.
|
|
join(table, options)
This is an alias for an inner join.
|
|
|
leftJoin(table, options)
Add a left join to another table
|
|
|
leftOuterJoin(table, options)
Add a left outer join to another table
|
|
|
like(options)
Add a like clause.
|
|
|
limit(limit, offset)
Use to limit the number of results returned.
|
|
|
logicGroup(query)
Add a logic group to a query.
|
|
|
lt(options)
Add a check for a value less than a particular value.
|
|
|
lte(options)
Add a check for a value less than or equal to a particular value.
|
|
|
max(options)
Helper to add a max clause.
|
|
|
min(options)
Helper to add a min clause.
|
|
|
naturalJoin(table)
Add a natural join to another table
|
|
|
naturalLeftJoin(table)
Add a natural left join to another table
|
|
|
naturalRightJoin(table)
Add a natural right join to another table
|
|
|
neq(options)
Use to find rows that have a column that do not equal a particular value.
|
|
|
notBetween(@param)
Add a not between check for a column.
|
|
|
notIn(options)
Add a not in clause
|
|
|
notLike(options)
Add a not like clause.
|
|
|
offset(offset)
Specify an offset, offset says to skip that many rows
before beginning to return rows to the client.
|
|
|
or(query)
Use to add an or clause
|
|
|
order(options)
To be used with queries to specify an order of the result set.
|
|
|
orderBy(options)
|
|
| <static> |
SQL.primaryKey()
Create a primary key statement
See your client adpater for parameters! |
|
remove(tables, query)
Signify this SQL instance as a delete statement
Cannot be used in combination with update, or find queries. |
|
|
rightJoin(table, options)
Add a right join to another table
|
|
|
rightOuterJoin(table, options)
Add a right outer join to another table
|
|
| <static> |
SQL.save(table, object, db)
Perform a batch insert into a table the objects.
|
| <static> |
SQL.schema(tableName, db)
Retrieve and create a moose.Table from a schema stored in the database.
|
|
select(columns, options)
Use to return particular columns from a query, i.e.
|
|
|
std(options)
Helper to add a std clause.
|
|
|
stdDev(options)
Helper to add a std dev clause.
|
|
|
stdDevPop(options)
Helper to add a std dev clause.
|
|
|
stdDevSamp(options)
Helper to add a std dev samp clause.
|
|
|
sum(options)
Helper to add a sum clause.
|
|
| <static> |
SQL.unique()
Create a unique constraint statement
See your client adpater for parameters! |
|
update(values, query)
Signify this SQL instance as an update statement.
|
|
|
variance(options)
Helper to add a variance clause.
|
|
|
varPop(options)
Helper to add a var pop clause.
|
|
|
varSamp(options, options)
Helper to add a var samp clause.
|
|
|
where(options)
Set the where clause of the query.
|
See your client adpater for parameters!
See your client adpater for parameters!
See your client adpater for parameters!
See your client adpater for parameters!
See your client adpater for parameters!
- Parameters:
- {moose.Table} table
- the table to alter on the database
- {moose.adapters.client.Query|moose.adapters.client.TransactionQuery} db
- the conneciton to the database.
- Returns:
- {comb.Promise} called back with results or the error call back is called with an error.
//select * from test where x <= 1 and y >= 1 sql.lte({x : 1}).gte({y : 1}); sql.lte({x : 1}).and({y : { gte : 1}}); sql.lte({x : 1}).and().gte({y : 1});
- Parameters:
- {Object} options Optional
- query to append after the and.
- Returns:
- {SQL} this to allow chaining of query elements.
//select avg(name) as name_avg from test sql.avg("name");
- Parameters:
- {String|Array} options Optional, Default: "*"
- if a string is supplied then a avg is added for that particular columns, an array adds a avg for each column in the array.
- Returns:
- {SQL} this to allow chaining of query elements.
//select * from test where x >= 1 and x <= 5 sql.between({x : [1,5]}); //select * from test where x >= 'a' and x <= 'b' sql.find({x : {between : ["a","b"]}});
- Parameters:
- options
- options key value pairs where the key is coulmn name and the value is an array of two values, first value in the array represents the gte value and the second value being the lte value.
- Returns:
- {SQL} this to allow chaining of query elements.
//select bit_and(name) as name_bit_and from test sql.bitAnd("name");
- Parameters:
- {String|Array} options Optional, Default: "*"
- if a string is supplied then a bit and is added for that particular columns, an array adds a bit and for each column in the array.
- Returns:
- {SQL} this to allow chaining of query elements.
//select bit_or(name) as name_bit_or from test sql.bitOr("name");
- Parameters:
- {String|Array} options Optional, Default: "*"
- if a string is supplied then a bit or is added for that particular columns, an array adds a count for each column in the array.
- Returns:
- {SQL} this to allow chaining of query elements.
//select bit_xor(name) as name_bit_xor from test sql.bitXor("name");
- Parameters:
- {String|Array} options Optional, Default: "*"
- if a string is supplied then a bit xor is added for that particular columns, an array adds a bit xor for each column in the array.
- Returns:
- {SQL} this to allow chaining of query elements.
- Returns:
- {SQL} this to allow chaining of query elements.
- Returns:
- {SQL} this to allow chaining of query elements.
- Returns:
- {SQL} this to allow chaining of query elements.
- Returns:
- {SQL} this to allow chaining of query elements.
See your client adpater for parameters!
//select count(name) as name_count from test sql.count("name"); //select count(*) as count from test sql.count();
- Parameters:
- {String|Array} options Optional, Default: "*"
- if a string is supplied then a count is added for that particular columns, an array adds a count for each column in the array.
- Returns:
- {SQL} this to allow chaining of query elements.
- Parameters:
- {moose.Table} table
- the table to create on the database
- {moose.adapters.client.Query|moose.adapters.client.TransactionQuery} db
- the conneciton to the database.
- Returns:
- {comb.Promise} called back with results or the error call back is called with an error.
//select * from test cross join test2 sql.crossJoin("test2");
- Parameters:
- {String|SQL} table
- the table or SQL clause that specifies the joining table.
- Returns:
- {SQL} this to allow chaining of query elements.
//select distinct * from test where id = 1 sql.find({id : 1}).distinct(); //select distinct test.* from test inner join test2 on test.id=test2.id where test2.other = 1 sql.join("test2", {id : "id"}).where({"test2.other" : 1}).select("test.*").distinct();
- Returns:
- {SQL} this to allow chaining of query elements.
See your client adpater for parameters!
See your client adpater for parameters!
See your client adpater for parameters!
- Parameters:
- {moose.Table} table
- the table to drop on the database
- {moose.adapters.client.Query|moose.adapters.client.TransactionQuery} db
- the conneciton to the database.
- Returns:
- {comb.Promise} called back with results or the error call back is called with an error.
See your client adpater for parameters!
- Returns:
- {SQL} this to allow chaining of query elements.
//select * from test where x = 0"); sql.eq({x : 0}); sql.find({x : 0});
- Parameters:
- {Object} options
- object with key\
and value\
- Returns:
- {SQL} this to allow chaining of query elements.
- Returns:
- {comb.Promise} called back with results or the error call back is called with an error.
Cannot be used in combination with update, or remove queries.
;
var sql = new SQL("test", db); //select * from test sql.find(); //select * from test where id = 1; sql.find({id : 1}); //select * from test where x != 0 sql.find({x : {neq : 0}}); //select * from test where id in (1,2,3,4,5) sql.find({id : [1,2,3,4,5]}); //select distinct * from test where id = 1 sql.find({id : 1}).distinct(); //select * from test where a >= 'b' limit 1 sql.find({a : {gte : "b"}}).limit(1); //select * from test where flag is unknown sql.find({flag : {is : "unknown"}}); //select * from test where flag is not unknown sql.find({flag : {isNot : "unknown"}}); //select * from test where flag is false and flag is not unknown and anotherFlag is null and yetAnotherFlag is not null sql.find({flag : {is : false}, flag2 : {isNot : "unknown"}, anotherFlag : {isNull : true}, yetAnotherFlag : {isNotNull : true}}); //select * from test where firstName like 'bob' and lastName not like 'henry' sql.find({firstName : {like : 'bob'}, lastName : {notLike : "henry"}}); //select * from test where firstName like 'bob' and lastName not like 'henry' sql.find({firstName : {like : 'bob'}, lastName : {notLike : "henry"}});
- Parameters:
- {Object} query Optional
- query to limit result set.
- Returns:
- {SQL} this to allow chaining of query elements.
See your client adpater for parameters!
- Parameters:
- {String} sql
- the sql to format
- {Array} array
- of values to place in the query.
- Returns:
- {String} the formatted string.
- Parameters:
- {String} sql
- the sql to format
- {Array} array
- of values to place in the query.
- Returns:
- {String} the formatted string.
//select * from test full join test2 on test.id=test2.id sql.fullJoin("test2", {id : "id"}); //select * from test full join test2 using (id, name) sql.fullJoin("test2", ["id", "name"]);
- Parameters:
- {String|SQL} table
- the table or SQL clause that specifies the joining table.
- {Array|Object} options
- When an array is passed in the a using clause is used to specify the columns to join on, of an object is passed in then it is the same as using an on clause;
- Returns:
- {SQL} this to allow chaining of query elements.
//select * from test full outer join test2 on test.id=test2.id sql.fullOuterJoin("test2", {id : "id"}); //select * from test full outer join test2 using (id, name) sql.fullOuterJoin("test2", ["id", "name"]);
- Parameters:
- {String|SQL} table
- the table or SQL clause that specifies the joining table.
- {Array|Object} options
- When an array is passed in the a using clause is used to specify the columns to join on, of an object is passed in then it is the same as using an on clause;
- Returns:
- {SQL} this to allow chaining of query elements.
- Parameters:
- {moose.adapters.client.Query|moose.adapters.client.TransactionQuery} db
- the conneciton to the database.
- Returns:
- {comb.Promise} called back with id or the error call back is called with an error.
//select * from test group by name sql.group("name"); //select * from test group by name, age sql.group(["name", "age"]); //select * from test group by name having name = 'bob' sql.group("name", {name : "bob"}); //select * from test group by name, age having age >= 10 and age <= 20 sql.group(["name", "age"], {age : {between : [10, 20]}});
- Parameters:
- {String|Array} key
- specify the columns to group on.
- {Object} having
- specify a having clause SQL#having.
- Returns:
- {SQL} this to allow chaining of query elements.
//select *, avg(name) as name_avg from test group by name sql.groupAndAvg("name");
- Parameters:
- {String|Array} key
- specify the columns to group and avg on.
- {Object} having
- specify a having clause SQL#having.
- Returns:
- {SQL} this to allow chaining of query elements.
//select *, bit_and(name) as name_bit_and from test group by name sql.groupAndBitAnd("name");
- Parameters:
- {String|Array} key
- specify the columns to group and bit and on.
- {Object} having
- specify a having clause SQL#having.
- Returns:
- {SQL} this to allow chaining of query elements.
//select *, bit_or(name) as name_bit_or from test group by name sql.groupAndBitOr("name");
- Parameters:
- {String|Array} key
- specify the columns to group and bit or on.
- {Object} having
- specify a having clause SQL#having.
- Returns:
- {SQL} this to allow chaining of query elements.
//select *, bit_xor(name) as name_bit_xor from test group by name sql.groupAndBitXor("name");
- Parameters:
- {String|Array} key
- specify the columns to group and bit xor on.
- {Object} having
- specify a having clause SQL#having.
- Returns:
- {SQL} this to allow chaining of query elements.
//select *, count(name) as name_count from test group by name sql.groupAndCount("name");
- Parameters:
- {String|Array} key
- specify the columns to group and count on.
- {Object} having
- specify a having clause SQL#having.
- Returns:
- {SQL} this to allow chaining of query elements.
//select *, max(name) as name_max from test group by name sql.groupAndMax("name");
- Parameters:
- {String|Array} key
- specify the columns to group and max on.
- {Object} having
- specify a having clause SQL#having.
- Returns:
- {SQL} this to allow chaining of query elements.
//select *, min(name) as name_min from test group by name sql.groupAndMin("name");
- Parameters:
- {String|Array} key
- specify the columns to group and min on.
- {Object} having
- specify a having clause SQL#having.
- Returns:
- {SQL} this to allow chaining of query elements.
//select *, std(name) as name_std from test group by name sql.groupAndStd("name");
- Parameters:
- {String|Array} key
- specify the columns to group and std on.
- {Object} having
- specify a having clause SQL#having.
- Returns:
- {SQL} this to allow chaining of query elements.
//select *, stddev(name) as name_stddev from test group by name sql.groupAndStdDev("name");
- Parameters:
- {String|Array} key
- specify the columns to group and std dev on.
- {Object} having
- specify a having clause SQL#having.
- Returns:
- {SQL} this to allow chaining of query elements.
//select *, stddev_pop(name) as name_stddev_pop from test group by name sql.groupAndStdDevPop("name");
- Parameters:
- {String|Array} key
- specify the columns to group and std dev pop on.
- {Object} having
- specify a having clause SQL#having.
- Returns:
- {SQL} this to allow chaining of query elements.
//select *, stddev_samp(name) as name_stddev_samp from test group by name sql.groupAndStdDevSamp("name");
- Parameters:
- {String|Array} key
- specify the columns to group and std dev samp on.
- {Object} having
- specify a having clause SQL#having.
- Returns:
- {SQL} this to allow chaining of query elements.
sql.groupAndSum("name"); //select *, sum(name) as name_sum from test group by name
- Parameters:
- {String|Array} key
- specify the columns to group and sum on.
- {Object} having
- specify a having clause SQL#having.
- Returns:
- {SQL} this to allow chaining of query elements.
//select *, variance(name) as name_variance from test group by name sql.groupAndVariance("name");
- Parameters:
- {String|Array} key
- specify the columns to group and variance on.
- {Object} having
- specify a having clause SQL#having.
- Returns:
- {SQL} this to allow chaining of query elements.
//select *, var_pop(name) as name_var_pop from test group by name sql.groupAndVarPop("name");
- Parameters:
- {String|Array} key
- specify the columns to group and var pop on.
- {Object} having
- specify a having clause SQL#having.
- Returns:
- {SQL} this to allow chaining of query elements.
//select *, var_samp(name) as name_var_samp from test group by name sql.groupAndVarSamp("name");
- Parameters:
- {String|Array} key
- specify the columns to group and var samp on.
- {Object} having
- specify a having clause SQL#having.
- Returns:
- {SQL} this to allow chaining of query elements.
//select * from test where x > 0 sql.gt({x : 0}); sql.find({x : {gt : 0}});
- Parameters:
- {Object} options
- keys values to add greater than checks for.
- Returns:
- {SQL} this to allow chaining of query elements.
//select * from test where x >= 0 sql.gte({x : 0}); sql.find({x : {gte : 0}});
- Parameters:
- {Object} options
- key values to add greater than or equal to checks.
- Returns:
- {SQL} this to allow chaining of query elements.
//select * from test group by name, age having age >= 10 and age <= 20 sql.group(["name", "age"]).having({age : {between : [10, 20]}}); //select * from test group by name, age having age >= 10 and age <= 20 sql.group(["name", "age"]).having().find({age : {between : [10, 20]}}); //select * from test group by name, age having age is null sql.group(["name", "age"]).having().isNull("age");
- Parameters:
- {Object} options Optional
- the query use on the having clause, same syntax as SQL#find, SQL#where;
- Returns:
- {SQL} this to allow chaining of query elements.
//select * from test inner join test2 on test.id=test2.id sql.innerJoin("test2", {id : "id"}); //select * from test inner join test2 using (id, name) sql.innerJoin("test2", ["id", "name"]);
- Parameters:
- {String|SQL} table
- the table or SQL clause that specifies the joining table.
- {Array|Object} options
- When an array is passed in the a using clause is used to specify the columns to join on, of an object is passed in then it is the same as using an on clause;
- Returns:
- {SQL} this to allow chaining of query elements.
//select * from test where flag is true sql.is({flag : true}); //select * from test where flag is false sql.is({flag : false}); //select * from test where flag is null sql.is({flag : null}); //select * from test where flag is unknown sql.is({flag : "unknown"}); //select * from test where flag is true and otherFlag is false and anotherFlag is unknown and yetAnotherFlag is null sql.is({flag : true, otherFlag : false, anotherFlag : "unknown", yetAnotherFlag : null}); //select * from test where flag is unknown sql.find({flag : {is : "unknown"}}); //select * from test where flag is false and flag is not unknown and anotherFlag is null and yetAnotherFlag is not null sql.is({flag : false}).isNot({flag : "unknown"}).isNull("anotherFlag").isNotNull("yetAnotherFlag //select * from test where flag is not null and flag is true or flag is false sql.isNotNull("flag").is({flag : true}).or({flag : {is : false}});
- Parameters:
- {Object} options
- key value pairs to add is clauses for.
- Returns:
- {SQL} this to allow chaining of query elements.
//select * from test where flag is not true sql.isNot({flag : true}); //select * from test where flag is not false sql.isNot({flag : false}); //select * from test where flag is not null sql.isNot({flag : null}); //select * from test where flag is not unknown sql.isNot({flag : "unknown"}); //select * from test where flag is not true and otherFlag is not false and anotherFlag is not unknown and yetAnotherFlag is not null sql.isNot({flag : true, otherFlag : false, anotherFlag : "unknown", yetAnotherFlag : null}); //select * from test where flag is not unknown sql.find({flag : {isNot : "unknown"}}); //select * from test where flag is false and flag is not unknown and anotherFlag is null and yetAnotherFlag is not null sql.is({flag : false}).isNot({flag : "unknown"}).isNull("anotherFlag").isNotNull("yetAnotherFlag"); sql.find({flag : {is : false}, flag2 : {isNot : "unknown"}, anotherFlag : {isNull : true}, yetAnotherFlag : {isNotNull : true}}); //select * from test where flag is not null and flag is true or flag is false sql.isNotNull("flag").is({flag : true}).or({flag : {is : false}});
- Parameters:
- {Object} options
- key value pairs to add is not clauses for.
- Returns:
- {SQL} this to allow chaining of query elements.
//select * from test where flag is not null sql.isNotNull("flag"); //select * from test where flag is false and flag is not unknown and anotherFlag is null and yetAnotherFlag is not null sql.is({flag : false}).isNot({flag : "unknown"}).isNull("anotherFlag").isNotNull("yetAnotherFlag //select * from test where flag is not null and flag is true or flag is false sql.isNotNull("flag").is({flag : true}).or({flag : {is : false}});
- Parameters:
- {String} options
- name of column to check.
- Returns:
- {SQL} this to allow chaining of query elements.
//select * from test where flag is null sql.isNull("flag"); //select * from test where flag is false and flag is not unknown and anotherFlag is null and yetAnotherFlag is not null sql.is({flag : false}).isNot({flag : "unknown"}).isNull("anotherFlag").isNotNull("yetAnotherFlag //select * from test where flag is not null and flag is true or flag is false sql.isNotNull("flag").is({flag : true}).or({flag : {is : false}});
- Parameters:
- {String} options
- column to check is not null.
- Returns:
- {SQL} this to allow chaining of query elements.
- Returns:
- {Boolean} true if it is a valid type, false otherwise.
//select * from test inner join test2 on test.id=test2.id sql.join("test2", {id : "id"}); //select * from test inner join test2 using (id, name) sql.join("test2", ["id", "name"]); //select * from test inner join test2 on test.id=test2.id left join test3 using (name) sql.join("test2", {id : "id"}).leftJoin("test3", ["name"]); //select * from test inner join test2 using (id, name) natural join test3 sql.join("test2", ["id", "name"]).naturalJoin("test3 //select * from test inner join test2 on test.id=test2.id left join test3 using (name) where x = 2 or x = 3 sql.join("test2", {id : "id"}).leftJoin("test3", ["name"]).eq({x : 2}).or({x : 3});
- Parameters:
- {String|SQL} table
- the table or SQL clause that specifies the joining table.
- {Array|Object} options
- When an array is passed in the a using clause is used to specify the columns to join on, of an object is passed in then it is the same as using an on clause;
- Returns:
- {SQL} this to allow chaining of query elements.
//select * from test left join test2 on test.id=test2.id sql.leftJoin("test2", {id : "id"}); //select * from test left join test2 using (id, name) sql.leftJoin("test2", ["id", "name"]);
- Parameters:
- {String|SQL} table
- the table or SQL clause that specifies the joining table.
- {Array|Object} options
- When an array is passed in the a using clause is used to specify the columns to join on, of an object is passed in then it is the same as using an on clause;
- Returns:
- {SQL} this to allow chaining of query elements.
//select * from test left outer join test2 on test.id=test2.id sql.leftOuterJoin("test2", {id : "id"}); //select * from test left outer join test2 using (id, name) sql.leftOuterJoin("test2", ["id", "name"]);
- Parameters:
- {String|SQL} table
- the table or SQL clause that specifies the joining table.
- {Array|Object} options
- When an array is passed in the a using clause is used to specify the columns to join on, of an object is passed in then it is the same as using an on clause;
- Returns:
- {SQL} this to allow chaining of query elements.
//select * from test where name like 'bob' sql.like({name : "bob"}); //select * from test where firstName like 'bob' and lastName not like 'henry' sql.find({firstName : {like : 'bob'}, lastName : {notLike : "henry"}});
- Parameters:
- {Object} options
- key, value pairs with the key representing a column, and the key represents the like condition.
- Returns:
- {SQL} this to allow chaining of query elements.
//select * from test limit 1 sql.limit(1); //select * from test limit 1 offset 10 sql.limit(1, 10); //select * from test where a >= 'b' limit 1 sql.find({a : {gte : "b"}}).limit(1);
- Parameters:
- {Number} limit
- the limit to specify on the query
- {Number} offset Optional
- SQL#offset
- Returns:
- {SQL} this to allow chaining of query elements.
//select * from test where (flag is not null and x = 1) or (x = 2) sql.logicGroup({flag : {isNot : null}, x : 1}).or().logicGroup({x : 2});
- Parameters:
- {Object} query
- query to group as one logical group;
- Returns:
- {SQL} this to allow chaining of query elements.
//select * from test where x < 1 sql.lt({x : 1}); sql.find({x : {lt : 1}});
- Parameters:
- {Object} options
- key values to add less than checks.
- Returns:
- {SQL} this to allow chaining of query elements.
//select * from test where x <= 1 sql.lte({x : 1}); sql.find({x : {lte : 1}});
- Parameters:
- {Object} options
- key values to add less than or equal to checks.
- Returns:
- {SQL} this to allow chaining of query elements.
//select max(name) as name_max from test sql.max("name");
- Parameters:
- {String|Array} options Optional, Default: "*"
- if a string is supplied then a max is added for that particular columns, an array adds a max for each column in the array.
- Returns:
- {SQL} this to allow chaining of query elements.
//select min(name) as name_min from test sql.min("name");
- Parameters:
- {String|Array} options Optional, Default: "*"
- if a string is supplied then a min is added for that particular columns, an array adds a min for each column in the array.
- Returns:
- {SQL} this to allow chaining of query elements.
//select * from test natural full join test2 sql.naturalFullJoin("test2");
- Parameters:
- {String|SQL} table
- the table or SQL clause that specifies the joining table.
- Returns:
- {SQL} this to allow chaining of query elements.
//select * from test natural left join test2 sql.naturalLeftJoin("test2"); //select * from test natural join test2 sql.naturalJoin("test2");
- Parameters:
- {String|SQL} table
- the table or SQL clause that specifies the joining table.
- Returns:
- {SQL} this to allow chaining of query elements.
//select * from test natural right join test2 sql.naturalRightJoin("test2");
- Parameters:
- {String|SQL} table
- the table or SQL clause that specifies the joining table.
- Returns:
- {SQL} this to allow chaining of query elements.
//select * from test where x != 0; sql.neq({x : 0}); sql.find({x : {neq : 0}});
- Parameters:
- {Object} options
- key value pairs to find columns no equal to a value
- Returns:
- {SQL} this to allow chaining of query elements.
//select * from test where x <= 1 and x >= 5 sql.notBetween({x : [1,5]}); //select * from test where x <= 'a' and x >= 'b' sql.notBetween({x : ["a","b"]}); //select * from test where x <= 'a' and x >= 'b' sql.find({x : {notBetween : ["a","b"]}});
- Parameters:
- @param
- options options key value pairs where the key is coulmn name and the value is an array of two values, first value in the array represents the lte value and the second value being the gte value.
- Returns:
- {SQL} this to allow chaining of query elements.
//select * from test where id not in (1,2,3,4,5) sql.notIn({id : [1,2,3,4,5]}); sql.find({id : {notIn : [1,2,3,4,5]}}); //select * from test where id not in (1,2,3,4,5) and id2 in (6,7,8,9,10) sql.notIn({id : [1,2,3,4,5]}).in({id2 : [6,7,8,9,10]}); //select * from test where id not in (1,2,3,4,5) and id2 not in (6,7,8,9,10) sql.notIn({id : [1,2,3,4,5], id2 : [6,7,8,9,10]}); //select * from test where id not in (select id2 from test2 where name >= 'A' and name <= 'B') sql.notIn({id : new Mysql("test2", db).select("id2").between({name : ["A", "B"]})});
- Parameters:
- {Object} options
- options key value pairs where the key is coulmn name and the value is an array of values.
- Returns:
- {SQL} this to allow chaining of query elements.
//select * from test where name not like 'bob' sql.notLike({name : "bob"}); //select * from test where firstName like 'bob' and lastName not like 'henry' sql.find({firstName : {like : 'bob'}, lastName : {notLike : "henry"}});
- Parameters:
- {Object} options
- key, value pairs with the key representing a column, and the key represents the not like condition.
- Returns:
- {SQL} this to allow chaining of query elements.
//select * from test where a >= 'b' offset 10 sql.find({a : {gte : "b"}}).offset(10);
- Parameters:
- {Number} offset
- the number to offset the result set by.
- Returns:
- {SQL} this to allow chaining of query elements.
//select * from test where x <= 1 and y >= 1 sql.lte({x : 1}).or({y : {gte : 1}}); sql.lte({x : 1}).or().gte({y : 1});
- Parameters:
- {Object} query
- added after the or clause
//select * from test order by x sql.order("x"); //select * from test order by x desc sql.order({x : "desc"}); //select * from test order by x, y sql.order(["x", "y"]); //select * from test order by x, y desc sql.order(["x", {y : "desc"}]); //select * from test order by x desc, y desc sql.order([{x : "desc"},{y : "desc"}]); //select * from test order by x, y, z desc sql.order("x").order("y").order({z : "desc"});
- Parameters:
- {String|Array|Object} options
- see example for uses of each.
- Returns:
- {SQL} this to allow chaining of query elements.
- Parameters:
- options
- Returns:
- {SQL} this to allow chaining of query elements.
See your client adpater for parameters!
Cannot be used in combination with update, or find queries.
//delete from test sql.remove(); //delete from test where x >= 1 and x <= 5 sql.remove(null, {x : {between : [1,5]}}); //delete from test where x >= 1 and x <= 5 sql.remove().where({x : {between : [1,5]}}); //delete from test where x >= 1 and x <= 5 sql.remove().find({x : {between : [1,5]}}); //delete test from test inner join test2 on test.flag=test2.false sql.remove().join("test2", {flag : false}); //delete test, test2 from test inner join test2 on test.flag=test2.false sql.remove("test2").join("test2", {flag : false});
- Parameters:
- {String|Array} tables Optional, Default: null
- Should only be used to specify the removal of items from multiple tables.
- {Object} query Optional
- Use to limit the rows deleted SQL#where
- Returns:
- {SQL} this to allow chaining of query elements.
//select * from test right join test2 on test.id=test2.id sql.rightJoin("test2", {id : "id"}); //select * from test right join test2 using (id, name) sql.rightJoin("test2", ["id", "name"]);
- Parameters:
- {String|SQL} table
- the table or SQL clause that specifies the joining table.
- {Array|Object} options
- When an array is passed in the a using clause is used to specify the columns to join on, of an object is passed in then it is the same as using an on clause;
- Returns:
- {SQL} this to allow chaining of query elements.
sql.rightOuterJoin("test2", {id : "id"}); //select * from test right outer join test2 on test.id=test2.id sql.rightOuterJoin("test2", ["id", "name"]); //select * from test right outer join test2 using (id, name);
- Parameters:
- {String|SQL} table
- the table or SQL clause that specifies the joining table.
- {Array|Object} options
- When an array is passed in the a using clause is used to specify the columns to join on, of an object is passed in then it is the same as using an on clause;
- Returns:
- {SQL} this to allow chaining of query elements.
- Parameters:
- {String} table
- the name of the table
- {Object} object
- the values to insert into the table
- {moose.adapters.client.Query|moose.adapters.client.TransactionQuery} db
- the conneciton to the database.
- Returns:
- {comb.Promise} called back with results or the error call back is called with an error.
- Parameters:
- {String} tableName
- name of the table
- {moose.adapters.client.Query|moose.adapters.client.TransactionQuery} db
- the conneciton to the database.
- Returns:
- {comb.Promise} called back with moose.Table or the error call back is called with an error.
var sql = new SQL("test", db); //select a, b, c from testTable; sql.select(["a", "b", "c"]); //select a from testTable; sql.select("a"); //select a from test where x = 1 and y >=1 and y <= 10 sql.select("a", {x : 1, y : {between : [1,10]}});
- Parameters:
- {String|Array} columns
- the columns to select
- {Object} options
- query SQL#find
- Returns:
- {SQL} this to allow chaining of query elements.
//select std(name) as name_std from test sql.std("name");
- Parameters:
- {String|Array} options Optional, Default: "*"
- if a string is supplied then a std is added for that particular columns, an array adds a std for each column in the array.
- Returns:
- {SQL} this to allow chaining of query elements.
//select stddev(name) as name_stddev from test sql.stdDev("name");
- Parameters:
- {String|Array} options Optional, Default: "*"
- if a string is supplied then a std dev is added for that particular columns, an array adds a std dev for each column in the array.
- Returns:
- {SQL} this to allow chaining of query elements.
//select stddev_pop(name) as name_stddev_pop from test sql.stdDevPop("name");
- Parameters:
- {String|Array} options Optional, Default: "*"
- if a string is supplied then a std dev pop is added for that particular columns, an array adds a std dev pop for each column in the array.
- Returns:
- {SQL} this to allow chaining of query elements.
//select stddev_samp(name) as name_stddev_samp from test sql.stdDevSamp("name");
- Parameters:
- {String|Array} options Optional, Default: "*"
- if a string is supplied then a std dev samp is added for that particular columns, an array adds a std dev samp for each column in the array.
- Returns:
- {SQL} this to allow chaining of query elements.
//select sum(name) as name_sum from test sql.sum("name");
- Parameters:
- {String|Array} options Optional, Default: "*"
- if a string is supplied then a sum is added for that particular columns, an array adds a sum for each column in the array.
- Returns:
- {SQL} this to allow chaining of query elements.
See your client adpater for parameters!
Cannot be used in combination with remove, or find queries.
//update test set x=1 sql.update({x : 1}); //update test set x=1 where x >= 1 and x <= 5 sql.update({x : 1}, {x : {between : [1,5]}}); //update test set x=1 where x >= 1 and x <= 5 sql.update({x : 1}).where({x : {between : [1,5]}}); //update test set x=1 where x >= 1 and x <= 5 sql.update({x : 1}).find({x : {between : [1,5]}}); //update test inner join test2 on test.flag=test2.false set x=1 sql.update({x : 1}).join("test2", {flag : false});
- Parameters:
- {Object} values
- key value pairs of columns, and values to update.
- {Object} query Optional
- optional query to allow limiting of rows to update SQL#where
- Returns:
- {SQL} this to allow chaining of query elements.
//select variance(name) as name_variance from test sql.variance("name");
- Parameters:
- {String|Array} options Optional, Default: "*"
- if a string is supplied then a variance is added for that particular columns, an array adds a variance for each column in the array.
- Returns:
- {SQL} this to allow chaining of query elements.
//select var_pop(name) as name_var_pop from test sql.varPop("name");
- Parameters:
- {String|Array} options Optional, Default: "*"
- if a string is supplied then a var pop is added for that particular columns, an array adds a var pop for each column in the array.
- Returns:
- {SQL} this to allow chaining of query elements.
//select var_samp(name) as name_var_samp from test sql.varSamp("name");
- Parameters:
- options
- {String|Array} options Optional, Default: "*"
- if a string is supplied then a var samp is added for that particular columns, an array adds a var samp for each column in the array.
- Returns:
- {SQL} this to allow chaining of query elements.
QUERYING var sql = new SQL("test", db); //select * from test where id = 1 sql.where({id : 1}); //select * from test where id in (1,2,3,4,5) sql.where({id : [1,2,3,4,5]}); //select * from test where x != 0 sql.where({x : {neq : 0}}); //select distinct * from test where id = 1 sql.where({id : 1}).distinct(); //select * from test where a >= 'b' limit 1 sql.where({a : {gte : "b"}}).limit(1); //select * from test where flag is unknown sql.where({flag : {is : "unknown"}}); //select * from test where flag is not unknown sql.where({flag : {isNot : "unknown"}}); //select * from test where flag is false and flag is not unknown and anotherFlag is null and yetAnotherFlag is not null sql.where({flag : {is : false}, flag2 : {isNot : "unknown"}, anotherFlag : {isNull : true}, yetAnotherFlag : {isNotNull : true}}); //select * from test where firstName like 'bob' and lastName not like 'henry' sql.where({firstName : {like : 'bob'}, lastName : {notLike : "henry"}}); //select * from test where firstName like 'bob' and lastName not like 'henry' sql.where({firstName : {like : 'bob'}, lastName : {notLike : "henry"}});
UPDATES //update test set x=1 where x >= 1 and x <= 5 sql.update({x : 1}).where({x : {between : [1,5]}});
DELETIONS //delete from test where x >= 1 and x <= 5 sql.remove().where({x : {between : [1,5]}});
- Parameters:
- {Object} options
- See SQL#find
- Returns:
- {SQL} this to allow chaining of query elements.


ITEM ONLY SKILLS
Aside from the regular character skills, Median XL: Ultimative features a variety of item-only skills. Some are so powerful and devastating that the human mind cannot learn or comprehend them. Others were abandoned in favour of new and stronger magic, but are still useful for adventurers looking for a solution to a particular problem.
Some of these can be cast much like regular skills when you equip the item that grants the skill. Others are triggered by items. Either way, these skills enable you to create a character like no other!
See THIS PAGE for a complete list of oskills and charged oskills on items (no descriptions).
Spell scaling
Item-only elemental spells gain a damage bonus from energy, just like regular elemental spells.
NOTE: Some Item-only skills are not listed yet on this page.
CASTABLE SKILLS
Which class do I need?
The icons tell you which classes can get the skill as oskill (eg. +4 to Flash), allowing you to cast the skill like a regular character skill.
Other classes may be able to get the skill as charges on an item or as a chance to cast skill.
Amazon
Assassin
Barbarian
Druid
Necromancer
Paladin
Sorceress
| Name | Icon | Effect |
|---|---|---|
| ANCIENTS' HAND |
Effect: melee attack that sends a shockwave explosion through the ground | |
| BLOODSPEAKER'S MARK |
Effect: melee attack that summons bloodknights with a Tremor attack | |
| CAUTIOUS STRIKE |
Effect: dual wield attack that raises defence and reduces damage taken | |
| CHERUB STRIKE |
Effect: retaliatory attack that manifests an angel that attacks enemies | |
| CLAW TORNADO |
Effect: melee attack that unleashes weapon damage twisters | |
| CLOBBER |
Effect: melee attack that hits faster, does more damage and knocks back | |
| CONQUEST |
Effect: melee attack that temporarily turns you invulnerable | |
| DANSE MACABRE |
Effect: a fierce spinning attack | |
| FERAL STRIKE |
Effect: melee attack that increases your speed after striking | |
| FOWL FIGHT |
Effect: melee attack that unleashes homing chickens | |
| GOREFEST |
Effect: melee attack that splatters the area with damaging guts and blood | |
| HAMSTRING |
Effect: melee attack that adds stun damage to subsequent attacks | |
| HARVEST |
Effect: whirling necromantic melee attack of death | |
| MEDUSA |
Effect: melee attack that summons water snakes that attack enemies | |
| OVERPOWER |
Effect: melee attack that hits the target multiple times | |
| RAVAGE |
Effect: multiple very fast melee attacks against all enemies | |
| ROCK SHOCK |
Effect: melee attack that produces a rock that bounces off enemies | |
| SPIN TO WIN |
Effect: Demaciaaaaaaaa!!! | |
| SPIRAL DANCE |
Effect: melee attack that emits a circle of whirling spirits | |
| SUNBURN |
Effect: melee attack that blinds enemies around the target | |
| THORN FIELD |
Effect: melee attack that summons a ripple of spiked roots | |
| TIME STRIKE |
Effect: melee attack that hits again after a short delay | |
| WHIRLPOOL |
Effect: melee attack that creates a devastating vortex | |
| ARROW SWARM |
Effect: shoot multiple zigzagging arrows | |
| AMBUSH |
Effect: hidden archers randomly fire arrows from a distance | |
| CYCLONE |
Effect: shoot a zigzagging blast of wind from your bow | |
| DEATHSTRIKE |
Effect: crossbow attack that calls down an energy blast | |
| GUIDED CHAIN |
Effect: arrow that pierces and tracks down random enemies | |
| O.H.M.A.N. |
Effect: shoot an Orb of Homing Multishot Arrow Novas! | |
| SCATTERSHOT |
Effect: arrow that pierces and unleashes shock novas | |
| SILVER DART |
Effect: crossbow bolt that pierces and splits on impact | |
| SQUALL GUST |
Effect: shoot a wall of clouds from your bow | |
| TANTRUM |
Effect: shoots shrapnel from your bow in all directions around you | |
| WRAITH ARROW |
Effect: arrow that unleashes magical homing spirits on striking | |
| MAELSTROM |
Effect: javelin that emits multiple novas while in flight | |
| SUNSPEAR |
Effect: javelin that bounces off the target, stunning enemies in its path | |
| SHADOW BLADE |
Effect: throwing knife that inflicts lethal magic damage | |
| HAWK TALONS |
Effect: landmine that explodes with a flurry of throwing axes | |
| ATMG SENTRY |
Effect: sentry that fires a machine gun at nearby enemies | |
| BLADE BARRIER |
Effect: spiked wall that fragments on contact, dealing weapon damage | |
| DEATH SHARDS |
Effect: detonates a corpse, sending out a weapon damage spike blast | |
| DISCO INFERNO |
Effect: kills your enemies deader than disco! | |
| GUARD TOWER |
Effect: summons a tower that shoots arrows at enemies | |
| SLICER BLADE |
Effect: magnetically suspends spinning blades in front of you | |
| SMG |
Effect: fires a machine gun at your target | |
| SOULSHATTER |
Effect: kills target minion and emits a nova shockwave of damage | |
| TIME WAVE |
Effect: triggers a Time Strike attack against all enemies | |
| WYRD |
Effect: spirit of the dead that unleashes multiple weapon damage novas | |
| APOCALYPSE |
Effect: causes nearby enemies to burst into hellfire | |
| BLOODSTAR |
Effect: burning blood missile that knocks the target back | |
| CATACLYSM |
Effect: nova of exploding fireballs | |
| DEATH BLOSSOM |
Effect: melee attack that emits a nova of fire | |
| FIRE CASCADE |
Effect: cast fireballs at all nearby targets | |
| FIRE FOUNTAIN |
Effect: scatters explosive volcanic bombs around you | |
| HOLY TRAP |
Effect: places a landmine that explodes with holy fire | |
| IMMOLATION BOMB |
Effect: places a fireball bomb at the target spot | |
| METEOR SHOWER |
Effect: devastating bombardment of meteors on a wide area | |
| PATH OF FLAMES |
Effect: periodically creates a pool of flames | |
| PENTAGRAM |
Effect: cast an expanding pentagram of hellfire | |
| PHOENIX WAVE |
Effect: wide advancing wall of flame | |
| POWDER KEG |
Effect: throw a barrel of gunpowder with a burning fuse | |
| PYROCLASTIC FLOW |
Effect: massive rolling wave from a distant volcanic eruption | |
| RAIN OF BOMBS |
Effect: bombards target area with a hail of explosives | |
| RUNE OF FIRE |
Effect: rune trap that explodes when triggered | |
| SPLITFIRE |
Effect: casts powerful fireballs to your left and right | |
| WRATH |
Effect: expanding circle of holy stones | |
| AVALANCHE |
Effect: two parallel rolling clouds of ice | |
| CHUREL |
Effect: gravestone that emits homing frost spirits | |
| COLD FEAR |
Effect: nova of icy terror that makes enemies flee | |
| CONE OF COLD |
Effect: short ranged but deadly blast of ice | |
| COUNTDOWN |
Effect: use target as focus for a delayed cold explosion | |
| CRYO BEAM |
Effect: freeze laser with a chance to annihilate the target | |
| FROSTFIRE WAVE |
Effect: multiple homing waves of ice flame | |
| FROZEN CROWN |
Effect: missile that emits a cold circle around the target on impact | |
| FROZEN SOUL |
Effect: cast a freezing orb at a random nearby enemy | |
| GLACIAL NOVA |
Effect: nova of ice that freezes all enemies | |
| HAILSTORM |
Effect: targets an enemy and rains down ice | |
| ICE BEAM |
Effect: cast a piercing beam of ice and frost | |
| ICE BOLT NOVA |
Effect: nova of powerful ice bolts | |
| ICE WHIRL |
Effect: cast multiple whirling loops of frost at your enemies | |
| RUNE OF ICE |
Effect: rune trap that freezes the enemy when triggered | |
| SHACKLES OF ICE |
Effect: freezes target solid in a large block of ice | |
| SHADOW AVATAR |
Effect: floating avatar that unleashes waves of ice flame | |
| WINTER AVATAR |
Effect: floating apparition that blasts the area with frost novas | |
| ELECTROBOLT |
Effect: piercing bolt of lightning that leaves a wake of energy | |
| FLASH |
Effect: short ranged electrical radius blast | |
| LIGHTNING ARENA |
Effect: periodically creates a circular stun fence of lightning | |
| LIGHTNING WALL |
Effect: wall of lightning that disintegrates when touched | |
| NOVA BOMB |
Effect: places a nova bomb at the target spot | |
| SHOCK FLOWER |
Effect: melee attack that unleashes an electrical shockwave | |
| STATIC LANCE |
Effect: lightning missile that emits charged bolts on impact | |
| STATIC SPIKE |
Effect: emits a large number of charged bolts in all directions | |
| STATIC WARD |
Effect: cast on a minion, emits charged bolts from the minion | |
| STORMFRONT |
Effect: throw multiple lightning bolts that explode on impact | |
| SUPERNOVA |
Effect: gigantic nova that does more damage at close range | |
| VORTEX |
Effect: whirling maelstrom of lightning damage around target point | |
| AMATOXIN |
Passive effect: adds poison damage to weapon attacks, 1/4 of Curare | |
| BLACK LOTUS STRIKE |
Effect: melee attack that emits a nova of poison | |
| DEVOURING CLOUD |
Effect: advancing poison cloud that leaves deadly acid puddles | |
| DISEASED CATTLE |
Effect: gates in hexed cows that emit disease | |
| EMERALD PRISON |
Effect: surrounds target enemy with poison filled glass spheres | |
| PUNISHER |
Effect: slow moving death bolt of poison | |
| RAZOR SPINES |
Effect: slams a ripple of poisoned spines through the ground | |
| VENOMOUS SPIRIT |
Effect: slow moving poisonous spirit of death | |
| BLAST WAVE |
Effect: multiple blast novas that stun and knock back enemies | |
| DEATH RAY |
Effect: press and hold button to emit a deadly energy ray | |
| DISINTEGRATE |
Effect: radius blast of deadly energy that slays nearby enemies | |
| ENERGY BEAM |
Effect: cast a piercing beam of magic damage | |
| EXORCISM |
Effect: melee attack that inflicts magical damage over time that spreads | |
| HAIL OF STONES |
Effect: stone your enemies with a bombardment of thrown rocks | |
| ORB OF ANNIHILATION |
Effect: deadly energy orb that emits bolts at nearby enemies | |
| PAIN SPIRIT |
Effect: spirit tracks random enemy and deals magic damage | |
| PSICROWN |
Effect: circle of bouncing ectoplasmic bolts dealing mana-based damage | |
| RAVEN FLIGHT |
Effect: flock of ravens passes through the area, dealing damage on the way | |
| RUNE OF MANA |
Effect: places a mine that steals mana and deals damage based on mana lost | |
| SEARING ORB |
Effect: orb of holy light that explodes at the target point | |
| TYPHOON SENTRY |
Effect: trap that casts wind blasts that knock enemies around | |
| BLOOD FLASH |
Effect: short ranged radius blast that steals life | |
| DEATH COIL |
Effect: bolt that steals life and does damage based on life stolen | |
| MANA COIL |
Effect: bolt that steals mana and does damage based on mana stolen | |
| BLOOD FURY |
Effect: increases spell damage but slowly drains life | |
| BLOODY MARY |
Effect: grants a vitality bonus to apples | |
| DARK POWER |
Effect: grants damage and crushing blow to the party | |
| DEMONIC SPEED |
Effect: increases run speed but makes you vulnerable to damage | |
| HOUNFOR |
Effect: ritual circle that amplifies spells cast inside | |
| INNER FIRE |
Effect: heal yourself with the power of fire | |
| LIGHTNING SHIELD |
Effect: casts a retaliatory shield of lightning on the party | |
| PAGAN HEART |
Effect: grants an energy bonus to apples | |
| RAVEN HEART |
Effect: increases cold spell damage but slowly drains life | |
| VANQUISH |
Effect: briefly grants a major boost to all damage | |
| CRANE STANCE |
Stance effect: increases damage and grants avoidance | |
| KRAKEN STANCE |
Stance effect: adds elemental damage to weapon attacks | |
| BANISH |
Curse effect: reduced life of the cursed by a percentage | |
| NIGHTMARE |
Curse effect: cursed enemies move slower and miss more often | |
| CHARM |
Effect: converts enemies to fight for you | |
| DIRE CHARM |
Effect: converts a random number of enemies for a random length of time | |
| DOMINATE |
Effect: long lasting single target charm spell | |
| BODY OF THE SAVIOR |
Effect: summons the corpse of Akarat to resurrect! | |
| CALL LEPRECHAUN |
Effect: summons a mischievous nature spirit to charm | |
| CALL TREEWARDEN |
Effect: summons a hostile treant creature to charm | |
| CHAMPIONS OF THE SUN |
Effect: summon golden spearwomen with a defensive aura | |
| GOLDEN CALF |
Effect: cow statue that attracts enemies and blinds attackers | |
| SUMMON AVALANCHE |
Effect: summon a dangerous cold demon | |
| SUMMON BANE MONSTER |
Effect: summon a demon with a Flash attack | |
| SUMMON DARKLINGS |
Effect: summon large numbers of insectoid minions | |
| SUMMON DAYSTAR |
Effect: summon a dark priest with an Angelfire attack | |
| SUMMON FALLEN |
Effect: summon numerous little useless fallen ones | |
| SUMMON GLOWING FUNGUS |
Effect: summon a mushroom fiend with a wide lightning attack | |
| SUMMON OVERLORD |
Effect: overseer that increases the size of your necromantic army | |
| SUMMON SHOCK BEAST |
Effect: summon an ape with a melee attack and Lightning Wall | |
| SUMMON SHREDDER |
Effect: summon a demon with a Frozen Orb attack | |
| SUMMON SINNER |
Effect: summon a fire demon with a Pyroblast attack | |
| SUMMON SIRENS |
Effect: summon female shadows that may charm enemies | |
| SUMMON THUNDER BEAR |
Effect: bear with Shower of Rocks attack | |
| TOTEMBOUND GUARDIAN |
Effect: minion that gains strength when near totems | |
| DEAD WALL TOTEM |
Totem effect: raises an army of zombies | |
| DEVIL'S FANG TOTEM |
Totem effect: raises an army of asatruar | |
| ELEMENTAL TOTEM |
Totem effect: increases elemental damage | |
| EXPLODING TOTEM |
Totem effect: does nothing until destroyed, then stuns enemies | |
| FEAR BOMB TOTEM |
Totem effect: casts a nova of terror, then self-destructs | |
| MANA TIDE TOTEM |
Totem effect: regenerates mana | |
| DARK SUMMONING |
Effect: summons a random monster, or in some places, an ancient evil... | |
| JITAN'S GATE |
Effect: burst from the ground at the target location | |
| PURIFY |
Effect: use this spell to kill Assur in Duncraig! | |
| SUMMON EDYREM |
Effect: summon ancient nephalem spirits, the enemies of the Triune... |
Trigger Only Skills
| Name | Effect | |
|---|---|---|
| ARROW | Effect: shoot an arrow at your target | |
| JAVELIN | Effect: throw a javelin at your target | |
| THROWING KNIFE | Effect: throw a knife at your target | |
| FLURRY OF JAVELINS | Effect: unleashes a barrage of javelins in random directions | |
| JAVELIN NOVA | Effect: throw a nova of javelins | |
| HAMMERTIME | Effect: blasts a stream of Thunder Hammer bolts at a random foe | |
| SPIKE NOVA | Effect: nova of spikes that deal weapon-based damage | |
| THUNDER HAMMER | Effect: hammer that deals weapon-based damage | |
| THUNDER WAVE | Effect: throw multiple Thunder Hammers | |
| CRATER | Effect: emits multiple fire novas from target point | |
| DEATH OF A GOD | Effect: corpse goes up in a blaze of holy fire | |
| FIRE BOLT NOVA | Effect: casts a nova of firebolts | |
| FIRE CANNONADE | Effect: unleashes a stream of firebolts at a random target | |
| FIRE SPLASH | Effect: creates a burning fire around the point of explosion | |
| FROG PRINCE | Effect: summon a fairy prince that casts frost novas | |
| SHADOWSTORM | Effect: swarm of homing shadow bolts that inflict cold damage | |
| STATIC TRAP | Effect: corpse trap that emits stunning electricity when touched | |
| TRINITY NOVA | Effect: casts a nova of fireballs, shock bolts and freeze bolts | |
| DEATH STAR | Effect: slow moving poison missile | |
| DEATH SPIRAL | Effect: slowly rotating beam of total annihilation | |
| MIRV | Effect: multiple independent nukes are launched at nearby points | |
| SLAYER BOLT | Effect: magical bolt similar to the bolts cast by the Slayer skill | |
| CELERITY | Effect: temporarily increases run speed and grants freeze immunity | |
| GIFT OF CELERITY | Curse effect: party version of the Celerity spell | |
| GIFT OF INNER FIRE | Curse effect: party version of the Inner Fire spell | |
| GIFT OF THE WILD | Curse effect: party version of the Mark of the Wild spell | |
| GIFT OF VANQUISHING | Curse effect: party version of the Vanquish spell | |
| LIFEBLOOD | Effect: slowly regenerates all your lost life over time | |
| RUST STORM | Curse effect: reduces defence and velocity of the cursed | |
| DEMON BLOOD AURA | Aura effect: increases life, life regeneration and elemental damage | |
| CALL BLOOD GOLEM | Effect: summons a hostile monster, a golem with a ranged attack | |
| CALL HENCHMEN | Effect: summons a hostile monster, one of Belial's angry rats! | |
| CALL NECROBOT | Effect: summons a hostile monster, a robot with lazorguns | |
| PANDEMONIUM | Effect: unleashes hell in the form of 44 hostile elite monsters |


Gender of Confirmed Cases Gender of Confirmed Cases
Age Groupings of Confirmed Cases Age Groupings of Confirmed Cases
Why did the case counts reported by DSHS increase suddenly? Why did the case counts reported by DSHS increase suddenly?
DSHS updated the method of reporting COVID-19 cases in Texas to provide the public with more timely information. The DSHS daily case count now includes all cases reported publicly by local health departments around the state. With the change, Texas is now reporting an additional 305 cases of COVID-19. DSHS updated the method of reporting COVID-19 cases in Texas to provide the public with more timely information. The DSHS daily case count now includes all cases reported publicly by local health departments around the state. With the change, Texas is now reporting an additional 305 cases of COVID-19.
The case counts do not include people who were repatriated from China or a cruise ship on U.S. government flights to JBSA-Lackland in San Antonio. The case counts do not include people who were repatriated from China or a cruise ship on U.S. government flights to JBSA-Lackland in San Antonio.
Why are these case counts different from what other sources are reporting? Why are these case counts different from what other sources are reporting?
Other dashboards may be using media reports to gather information about new cases, which may result in some cases being counted more than once. Other dashboards may be using media reports to gather information about new cases, which may result in some cases being counted more than once.
Case Numbers By County Case Numbers By County
Case Reporting Information Case Reporting Information


Review Summary
Pros Summary (Best 5 lines picked):
{{result.pros|safe}}
Cons Summary (Best 5 lines picked):
{{result.cons|safe}}


Prefix:
s! // Default
sm? // Math
s~ // Developer/Creator
Generic Commands
s!ping
Sends a Ping message
s!invite
An invite for the bot
s!discord
A Invite to the discord server
Moderation Commands [All Broken at the moment]
s!kick [User to kick]
Requires Admin/Moderator
s!ban [User to ban] [Reason]
Requires Admin/Moderator
s!purge [ammount of messages to delete]
Deletes a certian ammount of messages
Requires Admin/Moderator
Fun Commands
s!rps
Rock Paper Scissors!
s!punch
Punches someone you don't like
s!Avatar
Gets your discord pfp/avatar
s!Hammer
Bashes someone
DMOJ Commands
s!problem
Loads problem info and a link to the problem
s!search
Searches for a problem
s!contest
Loads content data and a link to the contest
s!content-search
Searches for a contest that has a similar name
s!user
Loads information about the user and a link to the user
s!user-search
Searches for a user with a similar name and loads information about the user.
Math Commands Commands
sm! [Math Equation]
Supported Equations
= + - * / ÷ % ( ) pow sqrt round floor ceiling
ceil pi euler absolute abs exp logarithm log random rand
Developer Commands
s~exec [Execute a node.js command]
s~serverlist
Outputs a list of servers that the bot is apart of
s~usercount
Outputs the total number of users that are apart of all servers
s~channels
DM's the owner the total number of channels that the bot can read.
s~restart
Restarts the bot
s~rpc [set Rich Presence message]
s~spam [ammount of msg's] [payload]
Spams the payload for the ammount that you want.
Made with ♥ by jyles.pw && strafecode.com
github


Welcome to EZ Book! You can visualise and update your itinerary, search for hotel availabilities and book in one click!


Examples
Following are links to examples of marking up data in Darwin Core:
<<<<<<< HEAD ======= >>>>>>> 3f4250f44d233b1ab4b22dc0864b9b2ff4d7949fFollowing are links to examples of marking up data in Darwin Core:
<<<<<<< HEAD ======= >>>>>>> 3f4250f44d233b1ab4b22dc0864b9b2ff4d7949f


After a month of coding non-stop, you finally finished project 3...
Now it is time to have some beers with your friend, who has waited patiently without bugging you, and
celebrate it!
But wait... you forgot where she lives... darn. So let's go search for her house!


{% extends "layout.home.server.view.html" %}
{% block content %}
Build a connection with your customers.
Call42 was originally developed for our own site with great care to make it flexible, convenient, easy to use and robust solution.
You have 42 free notifications monthly. Email digest is always free. Beyond that you only pay for what you actually use.
Getting started with Call42 is incredibly easy. You can have a callback widget on your site set up and running in minutes!
You can use it to engage your customers, keep track of callback requests, connect your Asterisk-based call center to your website...
Easy setup: Sign up, register your website, get widget code and insert it on your website. Few minutes and you are ready to receive callback requests from your customers.
Smart customer engagement: we use special algorithms to analyze the customer behavior on your website and suggest to make a callback request if the visitor is interested in your product.
Convenient notifications: you can use what works better to you and get an notification with customer's phone number as SMS, twitter direct message, jabber notification or a direct call via Asterisk.
Call42 is built on top of Amazon AWS to be robust and scalable. It works great for both small websites and big, heavy loaded sites.
Call42 starts bringing new customers immediately. Try it now, it's free and easy.


[1]
never complained about a bed before as i am really not fussy but in this hotel .
[2]
however in reality the soap is from a dispenser and the bathroom only includes minimal toiletries .


3.0.0
Type: string
Type: string
(string)
(string)
(string)
(string)
(string)
(string)
FDSNSourceId
(string)
FDSNSourceId
FDSNSourceId
(NslcId)
FDSNSourceId
(string)
(any
= '.'
)
FDSNSourceId
StationSourceId
NetworkSourceId
((FDSNSourceId | null))
boolean
FDSNSourceId
(string)
(string)
NetworkSourceId
(NetworkSourceId)
boolean
(string)
StationSourceId
NetworkSourceId
(StationSourceId)
boolean
Generates the best band code for a channel based on the sample rate and optionally the response lower bound period, which is mostly useful for separating broadband from short period seismometers.
(number?)
sample rate in samples per second
(number?)
response long period bound in seconds
string
:
single character band code
Type: string
(string)
(FDSNSourceId | NetworkSourceId | StationSourceId)
(FDSNSourceId)
(FDSNSourceId)
number


Presentation by Bryant Diaz
Software developers are the people who create the different programs that computers use for everything they do.
This may be something small such as a unit converter, or a simple mobile game, all the way up to the entire operating system that runs the computer.
Software developers may work in developing software programs for retail, or they may work to develop private software used by businesses.
These are some of their tasks
Review current systems and suggest areas of improvement.
Work closely with analysts, designers and programmers
Create detailed product specifications
Write, test and rewrite computer code
Test, improve and retest software
Median Salary: $92,660
Employment of software developers is projected to grow 22 percent from 2012 to 2022, much faster than the average for all occupations.
United States Bureau of Labor StatisticsA major in Computer science helps in becoming a software
developer.
Graduate school is not a requirement.
Computer Science is a broad field, but includes many of my
interests
3 year Major
CSCI-UA.0101 Introduction to Computer Science prereq: CSCI-UA.0002 or placement exam
CSCI-UA.0102 Data Structures
CSCI-UA.0201 Computer Systems Organization
CSCI-UA.0202 Operating Systems
CSCI-UA.0310 Basic Algorithms
MATH-UA.0121 Calculus I
MATH-UA.0120 Discrete Mathematics
FIVE electives, numbered CSCI-UA.04xx
Programming involves writing code (instructions to the computer) to achieve a task
Code is written in different programming languages
Popular ones are:
This minty color + transition.
section data-transition="slide"data-background="#9edec6" data-background-transition="zoom"


tmp_2c78d90
and
tmp_2c78d90
DIAG Set 4a - Vertical contour (XZ) plots of DJF, JJA and ANN meridional means
| DJF | JJA | ANN | ||
|---|---|---|---|---|
| CLOUD | Cloud fraction | plot | plot | plot |
| CWAT | Cloud ice+liquid | plot | plot | plot |
| EKE | Transient eddy KE | plot | plot | plot |
| GCLDLWP_ICE | Grid-box cloud LWP (ice only) | plot | plot | plot |
| GCLDLWP_LIQUID | Grid-box cloud LWP (lqd only) | plot | plot | plot |
| ICLDTWP | In-cloud liquid WP | plot | plot | plot |
| OBSTAR_TBSTAR | Stat eddy vert heat | plot | plot | plot |
| OMEGA * | Pressure vertical velocity | plot | plot | plot |
| OPTP_BAR | Transient eddy vert heat | plot | plot | plot |
| QRL | LW heating rate | plot | plot | plot |
| QRS | SW heating rate | plot | plot | plot |
| RELHUM * | Relative humidity | plot | plot | plot |
| SHUM * | Specific humidity | plot | plot | plot |
| T * | Temperature | plot | plot | plot |
| TDH | Total diabatic Heating | plot | plot | plot |
| TDM | Total diabatic moistening | plot | plot | plot |
| UBSTAR_QBSTAR | Stat eddy moisture | plot | plot | plot |
| UBSTAR_TBSTAR | Stationary eddy heat | plot | plot | plot |
| U * | Zonal wind | plot | plot | plot |
| VBSTAR_UBSTAR | Stationary eddy momentum | plot | plot | plot |
| VPUP_BAR | Transient eddy momentum | plot | plot | plot |


| Comparison 1 | s||
|---|---|---|
| Company: | Parent Company: | |
| Animal Cruelty | ||
| Diversity | ||
| Environmetal Impact | ||
| Human Rights | ||
| Political Contributions | ||
| Workers Rights |
| Comparison 2 | Add | x |
|---|---|---|
| Company | Parent Company | |
| Animal Cruelty | 4 | 5 |
| Diversity | 4 | 5 |
| Environmental Impact | 4 | 5 |
| Human Rights | 4 | 5 |
| Political Contributions | 4 | 5 |
| Workers Rights | 4 | 5 |
| Comparison 3 | x | |
|---|---|---|
| Company | Parent Company | |
| Animal Cruelty | 4 | 5 |
| Diversity | 4 | 5 |
| Environmental Impact | 4 | 5 |
| Human Rights | 4 | 5 |
| Political Contributions | 4 | 5 |
| Workers Rights | 4 | 5 |


Sunday! Sunday! Sunday!
Wrox Press Presents
Uppercase
vs.
Small Caps
A fight to the DEATH!
We'll sell you the whole seat, but you'll only need the edge!


- getArrival() - Method in class daewoo.management.system.gui.Slots
-
This is the accessors method to get the arrival time of the slot
- getArrival_city() - Method in class daewoo.management.system.gui.Slots
-
This is the accessors method to get the arrival city of the slot
- getB_id() - Method in class daewoo.management.system.gui.Buses
-
This is the accessors method to get the id of the bus
- getBus_id() - Method in class daewoo.management.system.gui.Tickets
-
This is the accessors method to get the id of the bus
- getCnic() - Method in class daewoo.management.system.gui.Passengers
-
This is the accessors method to get the cnic of the passenger
- getD_name() - Method in class daewoo.management.system.gui.Buses
-
This is the accessors method to get the name of the driver
- getDeparture() - Method in class daewoo.management.system.gui.Slots
-
This is the accessors method to get the departure time of the slot
- getDeparture_city() - Method in class daewoo.management.system.gui.Slots
-
This is the accessors method to get the departure city of the slot
- getdID() - Method in class daewoo.management.system.gui.Drivers
-
This is the accessors method to get the value of the driver id
- getdMob() - Method in class daewoo.management.system.gui.Drivers
-
This is the accessors method to get the mobile number of the driver
- getdName() - Method in class daewoo.management.system.gui.Drivers
-
This is the accessors method to get the name of the driver
- getFare() - Method in class daewoo.management.system.gui.Tickets
-
This is the accessors method to get the fare
- getFares() - Method in class daewoo.management.system.gui.Slots
-
This is the accessors method to get the fares
- getID() - Method in class daewoo.management.system.gui.Passengers
-
This is the accessors method to get the id of the passenger
- getId() - Method in class daewoo.management.system.gui.Slots
-
This is the accessors method to get the id of the slot
- getMob() - Method in class daewoo.management.system.gui.Passengers
-
This is the accessors method to get the mobile no of the passenger
- getn_o_w() - Method in class daewoo.management.system.gui.WeeklyDriver
-
This is the accessors method to get the number of weeks of the driver
- getName() - Method in class daewoo.management.system.gui.Passengers
-
This is the accessors method to get the name of the passenger
- getName() - Method in class daewoo.management.system.gui.Tickets
-
This is the accessors method to get the name of the passenger to whom the
ticket is assigned
- getSeat_no() - Method in class daewoo.management.system.gui.Tickets
-
This is the accessors method to get the seat no of the bus
- getSlot_id() - Method in class daewoo.management.system.gui.Buses
-
This is the accessors method to get the id if the slot
- getspay() - Method in class daewoo.management.system.gui.SalariedDriver
-
This is the accessors method to get the pay of the driver
- getT_id() - Method in class daewoo.management.system.gui.Tickets
-
This is the accessors method to get the id of the ticket
- getwpay() - Method in class daewoo.management.system.gui.WeeklyDriver
-
This is the accessors method to get the pay of the driver


Oh, this little girlie is going to go places. Tinsel is like the starlett, bound for Hollywood. We are very pleased with everything about this one. She somehow avoided the kennel and went directly to the chesterfield, well adjusted and easy to train. She's quite a wiggle worm. Will try to get some better pictures of her standing. Watch for her in the limelight!


{% raw %}
ImageMatcher
{{model.metadata.name}}
{{data.metadata.name}}
Associate a music
Your browser does not support the
audio
element.
Close
Delete
Save
Import new image
Select an image
Select a music (optional)
Cancel
Import
Search image
Select an image
Close
{% endraw %}


Sign Up
Your name
Your email
Password
By creating this account you agree to the terms
of use of our
privacy policy
Already have an account?
Login.


1
2
3
4
5
Good Morning to all
CSS
What is css?
CSS is the language for describing the presentation of Web pages
Colors, Layout and Fonts
Types of useage?
Inline
Internal
External


Do not use this application for malicious purposes. If you damage your phone or another persons phone I take no responsibility. This app was designed for security researchers to find vulnerabilities related to sms
I make NO guarantee that this app will work on your device. Hacker & AT require root access and are very powerful compared to Newbie node
Expert & Hacker modes are only for people that spend the time to research PDU sms and AT commands. Chances are if you seen an exploit that uses PDU sms this app can send the payload
if your device allows it
This option allows you to send a wap push sms in PDU format. This will show up on the users device as if it came from whatever name you put in the header. So if you entered Update a message will appear in the users sms inbox from Update. Your number will not be displayed to the user, headers are limited to 18 characters and the body is limited to 88 characters. Very good for pranking your friends;-D
This option allows you to send a silent text message to a users phone and it will alert you if the phone is online. The user will not see this message on their phone.
This option allows you to send your own payload in PDU format. Requires advanced knowledge of building PDU sms and limited compared to Expert Mode
------------------------
This section gives you full access to the payload that is getting sent.
Google wap push PDU sms if you want to find information on how to build a particular type of wap push msg.
- and spaces will be removed from the hex payload and are only there to make payload more readable.
Warning : requires rooted device
You will not get a delivery report for these messages when sent. you can use adb to view the logcat of your device to see what is sent/received
make sure usb debugging is enabled on your device and you have adb tools installed then use the following commands
adb shell
logcat -b radio
Note about which port the use in /dev folder, a lot of android phones use ports labeled smd so you will have to connect your device by usb and use adb to list the ports
ls /dev |grep smd
Some of these ports will not work and you will have to try a lot of them to see will they work. What I do is go to expert mode and send a normal type sms to my own number then I know that this port is working. Or if you go to AT section and open a port then select ATI and send, if you get back a response this port is working.
This option allows you to send a flash sms this will display on the users phone in a message dialog (Sender will be shown on some devices)
This option allows you to send a Voice Mail Waiting Indication message to the users phone. It doesn't really do anything but annoying to the user because they cannot remove the icon
Just sends a normal sms through the modem
This sms type is used by the certain organisations to keep a users device active for tracking purposes and cannot be seen by the user.
Probably the most powerful option if you know how to craft a raw PDU sms. In theory you can send any type of sms using this option and if you are a security researcher this would be your tool of choice to find vulnerabilities. This is a PDU in raw format so the number you selected has nothing to do with this option. Google search is your friend for this option.
------------------------
This section is not related to SMS but allows you to send any AT command to the modem. This is called Hacker mode because users that use tools like gr-gsm and airprobe need an Encryption Key to decrypt GSM traffic which can be then viewed in wireshark. Getting the Encryption Key is very hit and miss and I've managed to get it on a Sony ST26i. Again I repeat these sections are only for advanced users that know what they are doing and what commands to use.
------------------------


BY EDWIN JAHIEL
PAYBACK *** Directed by Brian Helgeland. Written by Helgeland and Terry Hayes, from the novel "The Hunter," by Richard Stark. Photography, Ericson Core. Editing, Kevin Stitt. Production design , Richard Hoover. Music, Chris Boardman. Produced by Bruce Davey. Cast: Mel Gibson (Porter), Gregg Henry (Val), Maria Bello (Rosie), David Paymer (Stegman), Deborah Kara Unger (Lynn), William Devane (Carter), Bill Duke (Detective Hicks), Kris Kristofferson (Bronson), Lucy Liu (Pearl), James Coburn - uncredited, et al. A Paramount release.110 minutes. R (much violence, kinky sex, language, dope)
Released at the same time, there's a movie called Simply Irresistible. Haven't seen it, don't know whether or not it 's irresistible. Mel Gibson, however, is. This may sound like a gushing fan's judgment, but I don't do gush and don't do fan. The opinion is objectively supported by the man's acting record and his versatility. It is buttressed too by Gibson as a producer, by his directorial debut (and performance) in the overlooked The Man Without a Face, his helming of Braverheart (Best Picture Oscar). Then there's his unexpectedly fine job in the title role of Franco Zeffirelli's Hamlet.
The now 43-year-old Mel (still quite young by male Hollywood standards) is an original presence - not only because his wife is expecting their 7th child! Offhand, what comes to my mind is a soupcon of Cary Grant-ish appeal in many performances. Not all of them have been in winner movies, but there are enough combinations of film and acting to place Gibson in the constellation.
The two main pillars of Gibson's popularity -- up to Braveheart-- have been his Australian Mad Max pictures and the American Lethal Weapon series in which he plays mad cop Martin Riggs. But there's a lot more than just that.
Now his company has made Payback. Mel apparently took a big hand in shaping it.  A tricky work to judge. Action fans who love Gibson will applaud. Fans of just Gibson might say "ho-hum.". Haters of blood and guts; traditionalists;"nice movie" partisans; many older viewers, will doubtlessly stay away.
The plot is simple: a tale of dishonor among thieves and revenge, a reinterpretation --not a remake-- of the now cultish Point Blank (1967) which came from the same book by Richard Stark (a pseudonym for Donald E. Westlake).
Gibson, called Porter (just one name) is a thief and all-around criminal. He is involved by his pal Val in a violent robbery of Orientals who regularly carry money for a mob, here referred to as The Outfit. The two men are aided by Porter's junkie wife Lynn. Lying Val had dangled to Porter a sum of up to half-a-million though he knew full well that the gangsters always carried $140,000. Worse yet, Val and Lynn take Porter's portion and shoot him dead, or so they think.
Porter improbably survives. The underworld doctor who takes out the bullets surpasses in shabbiness and filth even the stock figures of earlier crime movies. He is closer to back-room abortionists.
The penniless, improbably fully healed man, with improbable dexterity picks a wallet, gets himself money, clothes and other necessities, sets on the road to recovery. Not of his health (that's a done deal) but of his half of $70,000, from Val.
Double and triple crosses abound. So do improbabilities. A couple of the latter can be tolerated in most films, but twenty or more improbabilities make one huge impossibility.
For one thing, Porter narrates the movie in the tough voice-over style of earlier (especially 1940s) films noirs, say, like Dick Powell's Philip Marlowe in Murder, My Sweet. A bonus of this device is to reassure the audience that the protagonist has survived. For another, there is a quota of Gibsonisms in jokes and humor of speech and behavior. While some work and others don't, there is enough irony to keep us going.
Then there's the outrageous dominatrix Pearl (Lucy Liu of "Ally Mc Beal"), a high-price call girl and hoodlum associate who gets such high kicks from S & M that she steals all the scenes she's in.
Porter's journey to recover his 70 grand takes him through a full array of situations and characters, starting with his stoned-out wife, a heroin-delivery boy (whose nose ring Porter yanks out (an homage to Jack Nicholson's slashed nose in "Chinatown"?), a small-timer (nicely weasely David Paymer), to a black and white duo of corrupt cops (an upending of Lethal Weapon), to Val and to Val's bosses in The Outfit. Persistent Porter gets to the hierarchy of the Big Boys.
Amusingly, Porter keeps correcting those who quote him as claiming the full $140.000. He only wants his half back. Thieve's honor for a change? Suave mobster James Coburn, whose chic clothes and luggage gives an extra meaning to "outfit" is shocked at the modest request. "My suits cost more than that!" Coburn, smooth and delightful as ever, cringes when Top Man Kris Kristofferson, for reasons I cannot reveal, has captive Porter savagely treated and tells him "I'll make you last for weeks. I'll give you blood transfusions, if needed, to keep you alive."
The female element is enriched by Rosie, a fancy prostitute connected with the Outfit, erstwhile and now again Porter's girlfriend. Though not the traditional Girl Friday, she assists the man and vice-versa. And her character implies (but does develop) the distantly Godardian touch that she's the kind of woman one can rent, but not buy. The saddest moment in the film for me was when her guard dog got shot in a fracas, but to my boundless relief, he recovered. Miraculously. Just like Porter.
 Then again, the sympathy is continuously distracted by our having to suspend our disbelief. Just about everything Porter does, he does so well that unbelievability crops up in scene after scene.
The makers of Payback clearly had the ambition to make a tale for all seasons. It takes place in an unnamed, fabricated city (much of it shot in Chicago), in a recent but still unfathomable period. Moody hues are used. The composite look of the place and its artifacts, some archaic expressions of the 1930s, the tone of older Warners or RKO thrillers, modernistic touches, anonymous contemporary cars but of no discernible decade, pointedly located dial telephones and more anachronisms will puzzle audiences that know their cinema.
Director and co-writer Brian Helgeland (b. 1961) has scripted L.A.Confidential, Kevin Costner's The Postman, Conspiracy Theory (starring Gibson). Payback is his first big directorial job. Gibson, dissatisfied with the finished film, made changes, shot new scenes, re-shot extant ones, added 20 minutes-- partly, 'tis said, to make his role more likable. This may or may not have added to Helgeland's problems with disconnections, gaps and loose threads. The result, however, warts and all, has enough comic-book inventiveness to keep some of us taking it all in, in a silly, un-bored way.
" Le mauvais gout mene au crime" (Stendhal)
Edwin Jahiel's movie reviews are at http://www.prairienet.org/ejahiel
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


{{/* .Kind = "home" */}}
{{ define "main" }}
{{ .Content }}
{{/* Define a section to pull recent posts from. For Hugo 0.20 this will default to the section with the most number of pages. */}}
{{ $mainSections := .Site.Params.mainSections | default (slice "posts") }}
{{ $site := .Site }}
{{ $n_posts := $.Param "recent_posts_number" | default 3 }}
{{/* Range through all of main sections */}}
{{ range $mainSections }}
{{ $section_pages := where $site.RegularPages "Section" . }}
{{ $section_pages_count := len $section_pages }}
{{ $section_name := . }}
{{/* Display section that has least one page */}}
{{ if ge $section_pages_count 1 }}
{{/* Use $section_name to get the section index page's title. Use "with" to only show it if it exists */}}
{{ with $site.GetPage "section" $section_name }}
{{ i18n "Recent" }} {{ .Title }}
{{ end }}
{{/* Range through the first $n_posts items of the section */}}
{{ range (first $n_posts $section_pages) }}
{{ partial "summary-with-image.html" . }}
{{ end }}
{{/* If there are too many posts, range through the next four after the initial $n_posts items and display a link to the section index page */}}
{{ if ge $section_pages_count (add $n_posts 1) }}
{{ i18n "More" . }}
{{/* Nest the requirements, "after" then "first" on the outside */}}
{{ range (first 4 (after $n_posts $section_pages)) }}
{{ end }}
{{/* As above, Use $section_name to get the section title, and URL. Use "with" to only show it if it exists */}}
{{ with $site.GetPage "section" $section_name }}
{{ i18n "All" . }} {{.Title }}
{{ end }}
{{ end }}


THE VANISHING A film review by Paultje Bakker Copyright 1991 Paultje Bakker
Have you ever gone to a public place, like a shopping centre, or a pool, or a petrol station, and lost track of your friend/ sibling/wife/husband/child? Have they then inexplicably failed to show up at a pre-arranged meeting place, leaving you to torture yourself with horrible thoughts about what might have happened to them?
This is the topic of the newly released Dutch film, THE VANISHING. This is no horror movie, and yet it can be very scary; it evokes that mildly terrifying experience of loss and panic that most of us have had.
Although it's a Dutch movie, most of the dialogue is in French and almost all of the action is set in France. It's about a young Dutch couple who drive to France for their summer holiday, as young Dutch couples tend to do. They stop at a petrol station, and red-headed Saskia goes inside to buy a Coke and a Beer. She never returns. Her husband (Rolf?) freaks out, but is unable to locate her and eventually has to return to Holland. For three years he runs a desperate poster campaign to locate her. Then, .... well, I don't want to spoil it for you! Suffice to say that the plot takes a devious turn, and the movie climaxes in one of the most surprising and emotional endings I have ever seen.
And most distressing of all, it's 100% believable. SEE THIS MOVIE! and if anyone tries to tell you the ending, KILL THEM!
It's currently showing in Brisbane; I don't know about any other cities.
-- paultje<EMAIL_ADDRESS>--Paul Bakker email<EMAIL_ADDRESS>.
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


fun stopContentShare(): Unit
Stop sharing the content of a ContentShareSource that previously started.
Once the sharing stops successfully, ContentShareObserver.onContentShareStopped will be invoked with status code ContentShareStatusCode.OK.


{% include nav.html %}
Ethiopia Nov 9-13
3 days of single-track talks, 1 day of workshops and sprints
+Contact Us


Fare Chart
Caltrain fares are based on the number of zones that are partially or wholly traveled through by the passenger. View the System Map HERE.
Full fares will apply to all customers 18 years of age or older except those who qualify for an Eligible Discount ticket, which is approximately 50 percent of the full-fare price. View the fare descriptions HERE.
| Adult Full Fare | |||||||
| Ticket Type* | How to Buy | Travel within | |||||
| 1 Zone | 2 Zones | 3 Zones | 4 Zones | 5 Zones | 6 Zones | ||
| One Way | TVM | $3.00 | $5.00 | $7.00 | $9.00 | $11.00 | $13.00 |
| Clipper Card | $2.75 | $4.75 | $6.75 | $8.75 | $10.75 | $12.75 | |
| Day Pass+ | TVM | $6.00 | $10.00 | $14.00 | $18.00 | $22.00 | $26.00 |
| Zone Upgrade | TVM | $2.00 | |||||
| 8-ride | Clipper Card | $20.25 | $35.25 | $50.00 | $64.75 | $79.50 | $94.25 |
| Monthly Pass | Clipper Card | $73.00 | $126.00 | $179.00 | $232.00 | $285.00 | $338.00 |
TVM - Ticket Vending Machine
*Ticket Type definitions:
One-way: Valid 4 hours from time of purchase.
Day Pass: Valid the date of purchase, unlimited travel within zones indicated.
Zone Upgrade: Valid 4 hours from time of purchase, one way when accompanying another valid ticket (not valid with 8-ride Ticket).
8-ride: Valid 30 days from date of purchase.
Monthly Pass: Valid month of purchase.
For detailed Ticket Type information, click HERE.
Day Pass: Valid the date of purchase, unlimited travel within zones indicated.
Zone Upgrade: Valid 4 hours from time of purchase, one way when accompanying another valid ticket (not valid with 8-ride Ticket).
8-ride: Valid 30 days from date of purchase.
Monthly Pass: Valid month of purchase.
+ With the opening of Levi’s® Stadium, Caltrain is offering a joint adult Caltrain/VTA Day Pass. The Caltrain portion is valid to Zone 3 and costs an additional $6 compared to a Caltrain Day Pass. The joint pass is valid on Caltrain through the last train of the night and on VTA buses and light rail until 3 a.m.
View the System Map HERE
| Eligible Discount Fare** |
|||||||
| Ticket Type* | How to Buy | Travel within | |||||
| 1 Zone | 2 Zones | 3 Zones | 4 Zones | 5 Zones | 6 Zones | ||
| One Way | TVM | $1.50 | $2.50 | $3.50 | $4.50 | $5.50 | $6.50 |
| Clipper Card | $1.25 | $2.25 | $3.25 | $4.25 | $5.25 | $6.25 | |
| Day Pass | TVM | $3.00 | $5.00 | $7.00 | $9.00 | $11.00 | $13.00 |
| Zone Upgrade | TVM | $1.00 | |||||
| 8-ride | Clipper Card | $10.00 | $17.50 | $25.00 | $32.25 | $39.75 | $47.00 |
| Monthly Pass | Clipper Card | $36.50 | $63.00 | $89.50 | $116.00 | $142.50 | $169.00 |
** Senior / Disabled / Youth / Medicare Cardholder. Conductor or fare inspector may request proof of age or eligibility.


Notebooks
Story: Words given by Da
Words given by Da
Title
Words given by Da
Collection
Summary
A few words given by Da in October 1882.
Comments
1) This story is found in Book XI & XII-8
Contributors
Date
28 October 1882
Categories
Keywords
words and sentences (given by Da) , words and sentences (and |xue) , vocabulary (!kun) , vocabulary (given by Da) , |xue (and some words given by Da)
Story Pages
not numbered (opposite contents page)


Analysis of a given Graph
Enjoy the stdout in the console of your favourite browser
Provide your data
Create and Inspect graph
Topologic sort
Find Mother Vertex
Find any path between "a" and "z" nodes
Find shortest path between "a" and "z" nodes
Retrun true if the graph is cyclic
Find representatives of connected subsets


Bug 1684673 N[Core:CSS Parsing and Computation]Some minor tweaks to class attribute handling.
Bug 1684689 U[Core:Canvas: 2D]WPT test fails for html/canvas/element/pixel-manipulation/2d.imageData.create2.zero.html
Bug 1664730 A[Core:DOM: UI Events & Focus Handling]Intermittent toolkit/content/tests/mochitest/test_mousecapture.xhtml | selection scroll position after timer is at least 140
Bug 1684668 R[Core:GFX: Color Management]Rename in_0 to input and out to output.
Bug 1684691 R[Core:GFX: Color Management]Make Matrix more Rust like.

Bug 987432 R[Core:SVG]Clean up possibly-unnecessary float casts in SVG matrix-creation code (maybe just replacing with gfx::Float)
Bug 1684645 R[Firefox Build System:Generated Documentation]Regex for copybutton_prompt_text not working
###########
Changes to 8 bugs - 5 fixed.


Interested in hiring Jason? Have an open source project you need help with? Feel free to reach out to him at the following email address, or on LinkedIn. He is interested in working on challenging projects, especially in the mobile and web development areas of CS.
You can also find him on GitHub and view the projects that he works on in his free time.
Jason Downing © 2016 - 2017. All rights reserved. Powered by Bootstrap. Source on GitHub. Theme based on the Creative Bootstrap Theme by Start Bootstrap.


| MATLAB 文件帮助: cv.filter2D | 查看 cv.filter2D 的代码 | Index |
filter2D Convolves an image with the kernel
dst = cv.filter2D(src, kernel)
dst = cv.filter2D(src, kernel, 'OptionName',optionValue, ...)
src
.DDepth=-1
, the output image will have the same depth as the source.
The following combinations are supported:dst
. Default 0The function applies an arbitrary linear filter to an image. When the aperture is partially outside the image, the function interpolates outlier pixel values according to the specified border mode.
The function does actually compute correlation, not the convolution:
dst(x,y) = \sum_{0 <= xp <= size(kernel,2), 0 <= yp <= size(kernel,1)}
kernel(xp,yp) * src(x + xp - anchor(1), y + yp - anchor(2))
That is, the kernel is not mirrored around the anchor point. If you need a
real convolution, flip the kernel using cv.flip and set the new anchor to
(size(kernel,2) - anchor(1) - 1, size(kernel,1) - anchor(2) - 1)
.
The function uses the DFT-based algorithm in case of sufficiently large
kernels (~11x11
or larger) and the direct algorithm for small kernels.


The Sixth Sense (1999) Reviewed by Brian Matherly **** out of *****
Cast: Bruce Willis, Toni Collette, Olivia Williams, Haley Joel Osment, Donnie Wahlberg Written and Directed by: M. Night Shyamalan Running Time: 107 minutes Date Reviewed: August 9, 1999
Bruce Willis stars as Malcolm, an award winning child psychologist who discovers one night that one of his former patients is still suffering from inner demons. The now grown man breaks into his apartment while he and his wife (Olivia Williams from Rushmore) are celebrating his award, shoots Malcolm in the stomach, then takes his own life. Almost nine months later, Malcolm discovers Cole (Haley Joel Osment, in a brilliant performance), another young man afflicted with the same turmoil as his former patient. He takes on the child's case in the hope of redeeming himself for botching up the previous one, alienating his wife in the process. He soon discovers that they boy can see and speak to the dead, and his life becomes forever turned upside down.
Although the first hour is very slow, The Sixth Sense turns out to be a very powerful and moving film. I was expecting this film to be Mercury Rising 2, but was astonished to discover an extremely well plotted out little thriller with an outstandingly satisfying ending. You'll find yourself mentally retracing your steps through the film to see if you actually saw what you think you did once the credits roll. I must give M. Night Shyamalan a lot of credit for a brilliantly written screenplay.
The cast should also be given a lot of credit for making the movie as solid as it is. A lesser cast could have made this film a joke. Bruce Willis portrays his character perfectly, balancing his need to help Cole and his agony over his strained relationship with his wife skillfully. Haley Joel Osment shines as nine year old Cole, showing patience in his character that few young actors these days can pull off. Toni Collette, looking markedly different from her pathetic character in Muriel's Wedding, gives a strong performance as Cole's mother, who is trying to cope with both her son's "illness" and the passing of her mother. Finally, Olivia Williams deftly portrays a woman having to struggle with a husband who's not around and flirtations with a co-worker that could lead to a begrudgingly accepted end.
It's a shame that they show Cole's abilities in the trailer, because the movie takes close to forty minutes to get around to doing the same, so we already know what's going on before most of the rest of the cast does. In retrospect though, the forty minute set-up is essential to enjoying the end of the film, so I have fewer complaints now then I did while I was watching the film. I'm glad that the run of teen-styled horror films has passed and filmmakers are starting to make more adult fare. Films like this, the similarly themed Stir of Echoes, and countless others to be released later in the year should make for a pretty entertaining close to 1999. [PG-13]
Brian Matherly --<EMAIL_ADDRESS>The Jacksonville Film Journal URL:http://users.southeast.net/~chuckd21/
© 1999 of The Jacksonville Film Journal. No reviews may be reprinted without permission.
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


In order to use the MultipartEncoder
class, you first need to initialize an instance of the library.
To do so, you can very simply say:
const multipartHandler = new MultipartEncoder();
Now, the instance exposes two methods:
encode( obj )
- takes in an object (obj
) and returns a string formatted asmultipart/form-data
.decode( str )
- takes in a string (str
) and returns an object representing the providedmultipart/form-data
.
Encoding
As a very basic example, let's take the following object:
const obj = {
name: 'Captain Underpants',
identifier: '172/B'
};
We can encode this like so:
const data = multipartHandler.encode( obj );
The output will be something like the following:
--12143381585252692
Content-Disposition: form-data; name=name
Content-Type: text/plain; charset=utf8
Captain Underpants
--12143381585252692
Content-Disposition: form-data; name=identifier
Content-Type: text/plain; charset=utf8
172/B
--12143381585252692--
Decoding
With the output (as defined above), we can pass the same to the .decode()
function and the latent isomorphic
object which we serialized will be returned.


DeCP uses a deep hierarchical index structure over thousands or millions of clusters. Using a deep deep hierarchy is striking a balance between performance and result quality. The largest index used to date had 20 million clusters, was five levels deep, and was designed to index 300 - 500 billion high-dimensional features. Towards Engineering a Web-Scale Multimedia Service: A Case Study Using Spark
DeCP focuses on searching large batches of images rather than single image queries, sacrificing response time for high throughput. The larger the batch the higher the throughput and batches of thousands of tens of thousands of images have been used in experiments and evaluation.
DeCP has been implemented on both Hadoop and Spark, two of the worlds most popular automatically distributed computing frameworks (ADCFs), and the Spark implementation has been made publicly available. DeCP git repository
| Gylfi Þór | Laurent | Björn Þór | Michael J. |
| Guðmundsson | Amsaleg | Jónsson | Franklin |
Computing power has now become abundant with multi-core machines, grids and clouds, but it remains a challenge to harness the available power and move towards gracefully handling web-scale datasets. Several researchers have used automatically distributed computing frameworks, notably Hadoop and Spark, for processing multimedia material, but mostly using small collections on small clusters. In this paper, we describe the engineering process for a prototype of a (near) web-scale multimedia service using the Spark framework running on the AWS cloud service. We present experimental results using up to 43 billion SIFT feature vectors from the public YFCC 100M collection, making this the largest high-dimensional feature vector collection reported in the literature. The design of the prototype and performance results demonstrate both the flexibility and scalability of the Spark framework for implementing multimedia services. Published in the proceedings of the 8th ACM conference on multimedia systems (MMSys) in 2017.