| 057:004 Khan | : |
He it is Who created the heavens and the earth in six Days and then Istawa (rose over) the Throne (in a manner that suits His Majesty). He knows what goes into the earth and what comes forth from it, what descends from the heaven and what ascends thereto. And He is with you (by His Knowledge) wheresoever you may be. And Allah is the All-Seer of what you do. |
| 057:004 Maulana | : |
He it is Who created the heavens and the earth in six periods, and He is established on the Throne of Power. He knows that which goes down into the earth and that which comes forth out of it, and that which comes down from heaven and that which goes up to it. And He is with you wherever you are. And Allah is Seer of what you do. |
| 057:004 Pickthal | : |
He it is Who created the heavens and the earth in six Days; then He mounted the Throne. He knoweth all that entereth the earth and all that emergeth therefrom and all that cometh down from the sky and all that ascendeth therein; and He is with you wheresoever ye may be. And Allah is Seer of what ye do. |
| 057:004 Rashad | : |
He is the One who created the heavens and the earth in six days, then assumed all authority. He knows everything that enters into the earth, and everything that comes out of it, and everything that comes down from the sky, and everything that climbs into it. He is with you wherever you may be. GOD is Seer of everything you do. |
| 057:004 Sarwar | : |
It is He who created the heavens and the earth in six days and then established His Dominion over the Throne. He knows whatever enters into the earth, what comes out of it, what descends from the sky, and what ascends to it. He is with you wherever you may be and He is Well Aware of what you do. |
| 057:004 Shakir | : |
He it is who created the heavens and the earth in six periods, and He is firm in power; He knows that which goes deep down into the earth and that which comes forth out of it, and that which comes down from the heaven and that which goes up into it, and He is with you wherever you are; and Allah sees what you do. |
| 057:004 Sherali | : |
HE it is Who created the heavens and the earth in six periods, then HE settled Himself on the Throne. HE knows what enters the earth and what comes out of it, and what comes down from the heaven and what goes up into it. And HE is with you wheresoever you may be. And ALLAH sees all that you do. |
| 057:004 Yusufali | : |
He it is Who created the heavens and the earth in Six Days, and is moreover firmly established on the Throne (of Authority). He knows what enters within the earth and what comes forth out of it, what comes down from heaven and what mounts up to it. And He is with you wheresoever ye may be. And Allah sees well all that ye do. |
Concepts/Themes Covered: أركان الإسلام > التوحيد > توحيد الله تعالي > صفات الله تعالى > البصير Pillars of Islam> Islamic> Oneness of Allah> His Glory's Characteristics> All Seer أركان الإسلام > التوحيد > توحيد الله تعالي > علمه جلّ شأنه Pillars of Islam> Islamic> Oneness of Allah> His Glory's Knowledge أركان الإسلام > التوحيد > توحيد الله تعالي > وحدانيته Pillars of Islam> Islamic> Oneness of Allah> Singularity and Being Unique
This tool uses eight English parallel translations for the Holy Quran imported from Mr. Clay Smith. You can also visit Qurany Concepts for browsing the Quran themes or topics. If you want to search the Holy Quran for keywords, please visit Qurany Keywords.


C0 code coverage information
Generated on Tue Oct 21 01:05:24 +0100 2008 with rcov <IP_ADDRESS>
Code reported as executed by Ruby looks like this...
and this: this line is also marked as covered.
Lines considered as run by rcov, but not reported by Ruby, look like this,
and this: these lines were inferred by rcov (using simple heuristics).
Finally, here's a line marked as not executed.
1 module Sequel
2 # The SQL module holds classes whose instances represent SQL fragments.
3 # It also holds modules that are included in core ruby classes that
4 # make Sequel a friendly DSL.
5 module SQL
6 ### Parent Classes ###
7
8 # Classes/Modules aren't an alphabetical order due to the fact that
9 # some reference constants defined in others at load time.
10
11 # Base class for all SQL fragments
12 class Expression
13 # Returns self, because SQL::Expression already acts like
14 # LiteralString.
15 def lit
16 self
17 end
18 end
19
20 # Represents a complex SQL expression, with a given operator and one
21 # or more attributes (which may also be ComplexExpressions, forming
22 # a tree). This class is the backbone of the blockless filter support in
23 # Sequel.
24 #
25 # This is an abstract class that is not that useful by itself. The
26 # subclasses BooleanExpression, NumericExpression, and StringExpression
27 # define the behavior of the DSL via operators.
28 class ComplexExpression < Expression
29 # A hash of the opposite for each operator symbol, used for inverting
30 # objects.
31 OPERTATOR_INVERSIONS = {:AND => :OR, :OR => :AND, :< => :>=, :> => :<=,
32 :<= => :>, :>= => :<, :'=' => :'!=' , :'!=' => :'=', :LIKE => :'NOT LIKE',
33 :'NOT LIKE' => :LIKE, :~ => :'!~', :'!~' => :~, :IN => :'NOT IN',
34 :'NOT IN' => :IN, :IS => :'IS NOT', :'IS NOT' => :IS, :'~*' => :'!~*',
35 :'!~*' => :'~*', :NOT => :NOOP, :NOOP => :NOT, :ILIKE => :'NOT ILIKE',
36 :'NOT ILIKE'=>:ILIKE}
37
38 # Mathematical Operators used in NumericMethods
39 MATHEMATICAL_OPERATORS = [:+, :-, :/, :*]
40
41 # Mathematical Operators used in NumericMethods
42 BITWISE_OPERATORS = [:&, :|, :^, :<<, :>>]
43
44 # Inequality Operators used in InequalityMethods
45 INEQUALITY_OPERATORS = [:<, :>, :<=, :>=]
46
47 # Hash of ruby operator symbols to SQL operators, used in BooleanMethods
48 BOOLEAN_OPERATOR_METHODS = {:& => :AND, :| =>:OR}
49
50 # Operator symbols that take exactly two arguments
51 TWO_ARITY_OPERATORS = [:'=', :'!=', :IS, :'IS NOT', :LIKE, :'NOT LIKE', \
52 :~, :'!~', :'~*', :'!~*', :IN, :'NOT IN', :ILIKE, :'NOT ILIKE'] + \
53 INEQUALITY_OPERATORS + BITWISE_OPERATORS
54
55 # Operator symbols that take one or more arguments
56 N_ARITY_OPERATORS = [:AND, :OR, :'||'] + MATHEMATICAL_OPERATORS
57
58 # Operator symbols that take one argument
59 ONE_ARITY_OPERATORS = [:NOT, :NOOP, :'B~']
60
61 # An array of args for this object
62 attr_reader :args
63
64 # The operator symbol for this object
65 attr_reader :op
66
67 # Set the operator symbol and arguments for this object to the ones given.
68 # Convert all args that are hashes or arrays with all two pairs to ComplexExpressions.
69 # Raise an error if the operator doesn't allow boolean input and a boolean argument is given.
70 # Raise an error if the wrong number of arguments for a given operator is used.
71 def initialize(op, *args)
72 args.collect! do |a|
73 case a
74 when Hash
75 a.sql_expr
76 when Array
77 a.all_two_pairs? ? a.sql_expr : a
78 else
79 a
80 end
81 end
82 case op
83 when *N_ARITY_OPERATORS
84 raise(Error, "The #{op} operator requires at least 1 argument") unless args.length >= 1
85 when *TWO_ARITY_OPERATORS
86 raise(Error, "The #{op} operator requires precisely 2 arguments") unless args.length == 2
87 when *ONE_ARITY_OPERATORS
88 raise(Error, "The #{op} operator requires a single argument") unless args.length == 1
89 else
90 raise(Error, "Invalid operator #{op}")
91 end
92 @op = op
93 @args = args
94 end
95
96 # Delegate the creation of the resulting SQL to the given dataset,
97 # since it may be database dependent.
98 def to_s(ds)
99 ds.complex_expression_sql(@op, @args)
100 end
101 end
102
103 # The base class for expressions that can be used in multiple places in
104 # the SQL query.
105 class GenericExpression < Expression
106 end
107
108 # The base class for expressions that are specific and can only be used
109 # in a certain place in the SQL query (ordering, selecting).
110 class SpecificExpression < Expression
111 end
112
113 ### Modules ###
114
115 # Methods the create aliased identifiers
116 module AliasMethods
117 # Create an SQL column alias of the receiving column to the given alias.
118 def as(aliaz)
119 AliasedExpression.new(self, aliaz)
120 end
121 end
122
123 # This defines the bitwise methods &, |, ^, ~, <<, and >>. Because these
124 # methods overlap with the standard BooleanMethods methods, and they only
125 # make sense for numbers, they are only included in NumericExpression.
126 module BitwiseMethods
127 ComplexExpression::BITWISE_OPERATORS.each do |o|
128 define_method(o) do |ce|
129 case ce
130 when NumericExpression
131 NumericExpression.new(o, self, ce)
132 when ComplexExpression
133 raise(Sequel::Error, "cannot apply #{o} to a non-numeric expression")
134 else
135 NumericExpression.new(o, self, ce)
136 end
137 end
138 end
139
140 # Do the bitwise compliment of the self
141 def ~
142 NumericExpression.new(:'B~', self)
143 end
144 end
145
146 # This module includes the methods that are defined on objects that can be
147 # used in a boolean context in SQL (Symbol, LiteralString, SQL::Function,
148 # and SQL::BooleanExpression).
149 #
150 # This defines the ~ (NOT), & (AND), and | (OR) methods.
151 module BooleanMethods
152 # Create a new BooleanExpression with NOT, representing the inversion of whatever self represents.
153 def ~
154 BooleanExpression.invert(self)
155 end
156
157 ComplexExpression::BOOLEAN_OPERATOR_METHODS.each do |m, o|
158 define_method(m) do |ce|
159 case ce
160 when BooleanExpression
161 BooleanExpression.new(o, self, ce)
162 when ComplexExpression
163 raise(Sequel::Error, "cannot apply #{o} to a non-boolean expression")
164 else
165 BooleanExpression.new(o, self, ce)
166 end
167 end
168 end
169 end
170
171 # Holds methods that are used to cast objects to differen SQL types.
172 module CastMethods
173 # Cast the reciever to the given SQL type
174 def cast(sql_type)
175 IrregularFunction.new(:cast, self, :AS, sql_type.to_s.lit)
176 end
177 alias_method :cast_as, :cast
178
179 # Cast the reciever to the given SQL type (or integer if none given),
180 # and return the result as a NumericExpression.
181 def cast_numeric(sql_type = nil)
182 cast(sql_type || :integer).sql_number
183 end
184
185 # Cast the reciever to the given SQL type (or text if none given),
186 # and return the result as a StringExpression, so you can use +
187 # directly on the result for SQL string concatenation.
188 def cast_string(sql_type = nil)
189 cast(sql_type || :text).sql_string
190 end
191 end
192
193 # Includes a method that returns Identifiers.
194 module IdentifierMethods
195 # Return self wrapped as an identifier.
196 def identifier
197 Identifier.new(self)
198 end
199 end
200
201 # This module includes the methods that are defined on objects that can be
202 # used in a numeric or string context in SQL (Symbol, LiteralString,
203 # SQL::Function, and SQL::StringExpression).
204 #
205 # This defines the >, <, >=, and <= methods.
206 module InequalityMethods
207 ComplexExpression::INEQUALITY_OPERATORS.each do |o|
208 define_method(o) do |ce|
209 case ce
210 when BooleanExpression, TrueClass, FalseClass, NilClass, Hash, Array
211 raise(Error, "cannot apply #{o} to a boolean expression")
212 else
213 BooleanExpression.new(o, self, ce)
214 end
215 end
216 end
217 end
218
219 # This module augments the default initalize method for the
220 # ComplexExpression subclass it is included in, so that
221 # attempting to use boolean input when initializing a NumericExpression
222 # or StringExpression results in an error.
223 module NoBooleanInputMethods
224 # Raise an Error if one of the args would be boolean in an SQL
225 # context, otherwise call super.
226 def initialize(op, *args)
227 args.each do |a|
228 case a
229 when BooleanExpression, TrueClass, FalseClass, NilClass, Hash, Array
230 raise(Error, "cannot apply #{op} to a boolean expression")
231 end
232 end
233 super
234 end
235 end
236
237 # This module includes the methods that are defined on objects that can be
238 # used in a numeric context in SQL (Symbol, LiteralString, SQL::Function,
239 # and SQL::NumericExpression).
240 #
241 # This defines the +, -, *, and / methods.
242 module NumericMethods
243 ComplexExpression::MATHEMATICAL_OPERATORS.each do |o|
244 define_method(o) do |ce|
245 case ce
246 when NumericExpression
247 NumericExpression.new(o, self, ce)
248 when ComplexExpression
249 raise(Sequel::Error, "cannot apply #{o} to a non-numeric expression")
250 else
251 NumericExpression.new(o, self, ce)
252 end
253 end
254 end
255 end
256
257 # Methods that create OrderedExpressions, used for sorting by columns
258 # or more complex expressions.
259 module OrderMethods
260 # Mark the receiving SQL column as sorting in a descending fashion.
261 def desc
262 OrderedExpression.new(self)
263 end
264
265 # Mark the receiving SQL column as sorting in an ascending fashion (generally a no-op).
266 def asc
267 OrderedExpression.new(self, false)
268 end
269 end
270
271 # Methods that created QualifiedIdentifiers, used for qualifying column
272 # names with a table or table names with a schema.
273 module QualifyingMethods
274 # Qualify the current object with the given table/schema.
275 def qualify(ts)
276 QualifiedIdentifier.new(ts, self)
277 end
278 end
279
280 # This module includes the methods that are defined on objects that can be
281 # used in a numeric context in SQL (Symbol, LiteralString, SQL::Function,
282 # and SQL::StringExpression).
283 #
284 # This defines the like (LIKE) method, used for pattern matching.
285 module StringMethods
286 # Create a BooleanExpression case insensitive pattern match of self
287 # with the given patterns. See StringExpression.like.
288 def ilike(*ces)
289 StringExpression.like(self, *(ces << {:case_insensitive=>true}))
290 end
291
292 # Create a BooleanExpression case sensitive pattern match of self with
293 # the given patterns. See StringExpression.like.
294 def like(*ces)
295 StringExpression.like(self, *ces)
296 end
297 end
298
299 # This module is included in StringExpression and can be included elsewhere
300 # to allow the use of the + operator to represent concatenation of SQL
301 # Strings:
302 #
303 # :x.sql_string + :y => # SQL: x || y
304 module StringConcatenationMethods
305 def +(ce)
306 StringExpression.new(:'||', self, ce)
307 end
308 end
309
310 ### Modules that include other modules ###
311
312 # This module includes other Sequel::SQL::*Methods modules and is
313 # included in other classes that are could be either booleans,
314 # strings, or numbers. It also adds three methods so that
315 # can specify behavior in case one of the operator methods has
316 # been overridden (such as Symbol#/).
317 #
318 # For example, if Symbol#/ is overridden to produce a string (for
319 # example, to make file system path creation easier), the
320 # following code will not do what you want:
321 #
322 # :price/10 > 100
323 #
324 # In that case, you need to do the following:
325 #
326 # :price.sql_number/10 > 100
327 module ComplexExpressionMethods
328 include BooleanMethods
329 include NumericMethods
330 include StringMethods
331 include InequalityMethods
332
333 # Extract a datetime_part (e.g. year, month) from self:
334 #
335 # :date.extract(:year) # SQL: extract(year FROM date)
336 #
337 # Also has the benefit of returning the result as a
338 # NumericExpression instead of a generic ComplexExpression.
339 def extract(datetime_part)
340 IrregularFunction.new(:extract, datetime_part.to_s.lit, :FROM, self).sql_number
341 end
342
343 # Return a BooleanExpression representation of self.
344 def sql_boolean
345 BooleanExpression.new(:NOOP, self)
346 end
347
348 # Return a NumericExpression representation of self.
349 def sql_number
350 NumericExpression.new(:NOOP, self)
351 end
352
353 # Return a StringExpression representation of self.
354 def sql_string
355 StringExpression.new(:NOOP, self)
356 end
357 end
358
359 module SpecificExpressionMethods
360 include AliasMethods
361 include CastMethods
362 include OrderMethods
363 end
364
365 module GenericExpressionMethods
366 include SpecificExpressionMethods
367 include ComplexExpressionMethods
368 end
369
370 class ComplexExpression
371 include SpecificExpressionMethods
372 end
373
374 class GenericExpression
375 include GenericExpressionMethods
376 end
377
378 ### Classes ###
379
380 # Represents an aliasing of an expression/column to a given name.
381 class AliasedExpression < SpecificExpression
382 # The expression to alias
383 attr_reader :expression
384
385 # The alias to use for the expression, not alias since that is
386 # a keyword in ruby.
387 attr_reader :aliaz
388
389 # Create an object with the given expression and alias.
390 def initialize(expression, aliaz)
391 @expression, @aliaz = expression, aliaz
392 end
393
394 # Delegate the creation of the resulting SQL to the given dataset,
395 # since it may be database dependent.
396 def to_s(ds)
397 ds.aliased_expression_sql(self)
398 end
399 end
400
401 # Blob is used to represent binary data in the Ruby environment that is
402 # stored as a blob type in the database. In PostgreSQL, the blob type is
403 # called bytea. Sequel represents binary data as a Blob object because
404 # certain database engines, such as PostgreSQL, require binary data to be
405 # escaped.
406 class Blob < ::String
407 # return self.
408 def to_blob
409 self
410 end
411 end
412
413 # Subclass of ComplexExpression where the expression results
414 # in a boolean value in SQL.
415 class BooleanExpression < ComplexExpression
416 include BooleanMethods
417
418 # Take pairs of values (e.g. a hash or array of arrays of two pairs)
419 # and converts it to a BooleanExpression. The operator and args
420 # used depends on the case of the right (2nd) argument:
421 #
422 # * 0..10 - left >= 0 AND left <= 10
423 # * [1,2] - left IN (1,2)
424 # * nil - left IS NULL
425 # * /as/ - left ~ 'as'
426 # * :blah - left = blah
427 # * 'blah' - left = 'blah'
428 #
429 # If multiple arguments are given, they are joined with the op given (AND
430 # by default, OR possible). If negate is set to true,
431 # all subexpressions are inverted before used. Therefore, the following
432 # expressions are equivalent:
433 #
434 # ~from_value_pairs(hash)
435 # from_value_pairs(hash, :OR, true)
436 def self.from_value_pairs(pairs, op=:AND, negate=false)
437 pairs = pairs.collect do |l,r|
438 ce = case r
439 when Range
440 new(:AND, new(:>=, l, r.begin), new(r.exclude_end? ? :< : :<=, l, r.end))
441 when Array, ::Sequel::Dataset
442 new(:IN, l, r)
443 when NilClass
444 new(:IS, l, r)
445 when Regexp
446 StringExpression.like(l, r)
447 else
448 new(:'=', l, r)
449 end
450 negate ? invert(ce) : ce
451 end
452 pairs.length == 1 ? pairs.at(0) : new(op, *pairs)
453 end
454
455 # Invert the expression, if possible. If the expression cannot
456 # be inverted, raise an error. An inverted expression should match everything that the
457 # uninverted expression did not match, and vice-versa.
458 def self.invert(ce)
459 case ce
460 when BooleanExpression
461 case op = ce.op
462 when :AND, :OR
463 BooleanExpression.new(OPERTATOR_INVERSIONS[op], *ce.args.collect{|a| BooleanExpression.invert(a)})
464 else
465 BooleanExpression.new(OPERTATOR_INVERSIONS[op], *ce.args.dup)
466 end
467 when ComplexExpression
468 raise(Sequel::Error, "operator #{ce.op} cannot be inverted")
469 else
470 BooleanExpression.new(:NOT, ce)
471 end
472 end
473 end
474
475 # Represents an SQL CASE expression, used for conditions.
476 class CaseExpression < GenericExpression
477 # An array of all two pairs with the first element specifying the
478 # condition and the second element specifying the result.
479 attr_reader :conditions
480
481 # The default value if no conditions are true
482 attr_reader :default
483
484 # Create an object with the given conditions and
485 # default value.
486 def initialize(conditions, default)
487 raise(Sequel::Error, 'CaseExpression conditions must be an array with all_two_pairs') unless Array === conditions and conditions.all_two_pairs?
488 @conditions, @default = conditions, default
489 end
490
491 # Delegate the creation of the resulting SQL to the given dataset,
492 # since it may be database dependent.
493 def to_s(ds)
494 ds.case_expression_sql(self)
495 end
496 end
497
498 # Represents all columns in a given table, table.* in SQL
499 class ColumnAll < SpecificExpression
500 # The table containing the columns being selected
501 attr_reader :table
502
503 # Create an object with the given table
504 def initialize(table)
505 @table = table
506 end
507
508 # ColumnAll expressions are considered equivalent if they
509 # have the same class and string representation
510 def ==(x)
511 x.class == self.class && @table == x.table
512 end
513
514 # Delegate the creation of the resulting SQL to the given dataset,
515 # since it may be database dependent.
516 def to_s(ds)
517 ds.column_all_sql(self)
518 end
519 end
520
521 # Represents an SQL function call.
522 class Function < GenericExpression
523 # The array of arguments to pass to the function (may be blank)
524 attr_reader :args
525
526 # The SQL function to call
527 attr_reader :f
528
529 # Set the attributes to the given arguments
530 def initialize(f, *args)
531 @f, @args = f, args
532 end
533
534 # Functions are considered equivalent if they
535 # have the same class, function, and arguments.
536 def ==(x)
537 x.class == self.class && @f == x.f && @args == x.args
538 end
539
540 # Delegate the creation of the resulting SQL to the given dataset,
541 # since it may be database dependent.
542 def to_s(ds)
543 ds.function_sql(self)
544 end
545 end
546
547 # Represents an identifier (column or table). Can be used
548 # to specify a Symbol with multiple underscores should not be
549 # split, or for creating an identifier without using a symbol.
550 class Identifier < GenericExpression
551 include QualifyingMethods
552
553 # The table and column to reference
554 attr_reader :value
555
556 # Set the value to the given argument
557 def initialize(value)
558 @value = value
559 end
560
561 # Delegate the creation of the resulting SQL to the given dataset,
562 # since it may be database dependent.
563 def to_s(ds)
564 ds.quote_identifier(@value)
565 end
566 end
567
568 # IrregularFunction is used for the SQL EXTRACT and CAST functions,
569 # which don't use regular function calling syntax. The IrregularFunction
570 # replaces the commas the regular function uses with a custom
571 # join string.
572 #
573 # This shouldn't be used directly, see CastMethods#cast and
574 # ComplexExpressionMethods#extract.
575 class IrregularFunction < Function
576 # The arguments to pass to the function (may be blank)
577 attr_reader :arg1, :arg2
578
579 # The SQL function to call
580 attr_reader :f
581
582 # The literal string to use in place of a comma to join arguments
583 attr_reader :joiner
584
585 # Set the attributes to the given arguments
586 def initialize(f, arg1, joiner, arg2)
587 @f, @arg1, @joiner, @arg2 = f, arg1, joiner, arg2
588 end
589
590 # Delegate the creation of the resulting SQL to the given dataset,
591 # since it may be database dependent.
592 def to_s(ds)
593 ds.irregular_function_sql(self)
594 end
595 end
596
597 # Represents an SQL JOIN clause, used for joining tables.
598 class JoinClause < SpecificExpression
599 # The type of join to do
600 attr_reader :join_type
601
602 # The actual table to join
603 attr_reader :table
604
605 # The table alias to use for the join, if any
606 attr_reader :table_alias
607
608 # Create an object with the given conditions and
609 # default value.
610 def initialize(join_type, table, table_alias = nil)
611 @join_type, @table, @table_alias = join_type, table, table_alias
612 end
613
614 # Delegate the creation of the resulting SQL to the given dataset,
615 # since it may be database dependent.
616 def to_s(ds)
617 ds.join_clause_sql(self)
618 end
619 end
620
621 # Represents an SQL JOIN table ON conditions clause.
622 class JoinOnClause < JoinClause
623 # The conditions for the join
624 attr_reader :on
625
626 # Create an object with the given conditions and
627 # default value.
628 def initialize(on, *args)
629 @on = on
630 super(*args)
631 end
632
633 # Delegate the creation of the resulting SQL to the given dataset,
634 # since it may be database dependent.
635 def to_s(ds)
636 ds.join_on_clause_sql(self)
637 end
638 end
639
640 # Represents an SQL JOIN table USING (columns) clause.
641 class JoinUsingClause < JoinClause
642 # The columns that appear both tables that should be equal
643 # for the conditions to match.
644 attr_reader :using
645
646 # Create an object with the given conditions and
647 # default value.
648 def initialize(using, *args)
649 @using = using
650 super(*args)
651 end
652
653 # Delegate the creation of the resulting SQL to the given dataset,
654 # since it may be database dependent.
655 def to_s(ds)
656 ds.join_using_clause_sql(self)
657 end
658 end
659
660 # Subclass of ComplexExpression where the expression results
661 # in a numeric value in SQL.
662 class NumericExpression < ComplexExpression
663 include BitwiseMethods
664 include NumericMethods
665 include InequalityMethods
666 include NoBooleanInputMethods
667 end
668
669 # Represents a column/expression to order the result set by.
670 class OrderedExpression < SpecificExpression
671 # The expression to order the result set by.
672 attr_reader :expression
673
674 # Whether the expression should order the result set in a descending manner
675 attr_reader :descending
676
677 # Set the expression and descending attributes to the given values.
678 def initialize(expression, descending = true)
679 @expression, @descending = expression, descending
680 end
681
682 # Delegate the creation of the resulting SQL to the given dataset,
683 # since it may be database dependent.
684 def to_s(ds)
685 ds.ordered_expression_sql(self)
686 end
687 end
688
689 # Represents a qualified (column with table) reference. Used when
690 # joining tables to disambiguate columns.
691 class QualifiedIdentifier < GenericExpression
692 # The table and column to reference
693 attr_reader :table, :column
694
695 # Set the attributes to the given arguments
696 def initialize(table, column)
697 @table, @column = table, column
698 end
699
700 # Delegate the creation of the resulting SQL to the given dataset,
701 # since it may be database dependent.
702 def to_s(ds)
703 ds.qualified_identifier_sql(self)
704 end
705 end
706
707 # Subclass of ComplexExpression where the expression results
708 # in a text/string/varchar value in SQL.
709 class StringExpression < ComplexExpression
710 include StringMethods
711 include StringConcatenationMethods
712 include InequalityMethods
713 include NoBooleanInputMethods
714
715 # Creates a SQL pattern match exprssion. left (l) is the SQL string we
716 # are matching against, and ces are the patterns we are matching.
717 # The match succeeds if any of the patterns match (SQL OR). Patterns
718 # can be given as strings or regular expressions. Strings will cause
719 # the SQL LIKE operator to be used, and should be supported by most
720 # databases. Regular expressions will probably only work on MySQL
721 # and PostgreSQL, and SQL regular expression syntax is not fully compatible
722 # with ruby regular expression syntax, so be careful if using regular
723 # expressions.
724 #
725 # The pattern match will be case insensitive if the last argument is a hash
726 # with a key of :case_insensitive that is not false or nil. Also,
727 # if a case insensitive regular expression is used (//i), that particular
728 # pattern which will always be case insensitive.
729 def self.like(l, *ces)
730 case_insensitive = ces.extract_options![:case_insensitive]
731 ces.collect! do |ce|
732 op, expr = Regexp === ce ? [ce.casefold? || case_insensitive ? :'~*' : :~, ce.source] : [case_insensitive ? :ILIKE : :LIKE, ce.to_s]
733 BooleanExpression.new(op, l, expr)
734 end
735 ces.length == 1 ? ces.at(0) : BooleanExpression.new(:OR, *ces)
736 end
737 end
738
739 # Represents an SQL array access, with multiple possible arguments.
740 class Subscript < GenericExpression
741 # The SQL array column
742 attr_reader :f
743
744 # The array of subscripts to use (should be an array of numbers)
745 attr_reader :sub
746
747 # Set the attributes to the given arguments
748 def initialize(f, sub)
749 @f, @sub = f, sub
750 end
751
752 # Create a new subscript appending the given subscript(s)
753 # the the current array of subscripts.
754 def |(sub)
755 Subscript.new(@f, @sub + Array(sub))
756 end
757
758 # Delegate the creation of the resulting SQL to the given dataset,
759 # since it may be database dependent.
760 def to_s(ds)
761 ds.subscript_sql(self)
762 end
763 end
764
765 if RUBY_VERSION >= '1.9.0'
766 class VirtualRow < BasicObject
767 end
768 else
769 class VirtualRow
770 (instance_methods - %w"__id__ __send__ instance_eval == equal?").each{|m| undef_method(m)}
771 end
772 end
773
774 # An instance of this class is yielded to the block supplied to filter.
775 # Useful if another library also defines the operator methods that
776 # Sequel defines for symbols.
777 #
778 # Examples:
779 #
780 # ds = DB[:t]
781 # ds.filter{|r| r.name < 2} # SELECT * FROM t WHERE (name < 2)
782 # ds.filter{|r| r.table__column + 1 < 2} # SELECT * FROM t WHERE ((table.column + 1) < 2)
783 # ds.filter{|r| r.is_active(1, 'arg2')} # SELECT * FROM t WHERE is_active(1, 'arg2')
784 class VirtualRow
785 # Can return Identifiers, QualifiedIdentifiers, or Functions:
786 #
787 # * Function - returned if any arguments are supplied, using the method name
788 # as the function name, and the arguments as the function arguments.
789 # * QualifiedIdentifier - returned if the method name contains __, with the
790 # table being the part before __, and the column being the part after.
791 # * Identifier - returned otherwise, using the method name.
792 def method_missing(m, *args)
793 if args.empty?
794 table, column = m.to_s.split('__', 2)
795 column ? QualifiedIdentifier.new(table, column) : Identifier.new(m)
796 else
797 Function.new(m, *args)
798 end
799 end
800 end
801 end
802
803 # LiteralString is used to represent literal SQL expressions. A
804 # LiteralString is copied verbatim into an SQL statement. Instances of
805 # LiteralString can be created by calling String#lit.
806 # LiteralStrings can use all of the SQL::ColumnMethods and the
807 # SQL::ComplexExpressionMethods.
808 class LiteralString < ::String
809 include SQL::OrderMethods
810 include SQL::ComplexExpressionMethods
811 end
812 end
Generated using the rcov code coverage analysis tool for Ruby
version <IP_ADDRESS>.


Introduction
What is BECCS
Emissions
Land Use
Other Considerations
Conclusion
Already feed 70% of the population
Using less than a quar-
ter of agricultural land
critique
conclusion


Nicky Byrne admits he didn't think Westlife could succeed again as new album drops
EXCLUSIVE: The Irish boyband are back with new album Spectrum - and they reckon it's the best one of their 20-year career
by Vicki Newman, https://www.mirror.co.uk/authors/vicki-newman/Westlife star Nicky Byrne has admitted he didn't think Westlife could succeed again before their comeback.
The Irish boyband have released new album Spectrum today - 20 years on from their self-titled debut.
And after their comeback singles Hello My Love and Dynamite smashed it in the charts, Nicky has admitted he's shocked.
The 41-year-old exclusively told Mirror Online: "We are all proud of the new music. The reaction from the fans has been phenomenal.
"If you'd have asked me when we split up if we'd have ever been in contention for the possibility of a hit album again I would have doubted it, but the success of our comeback singles such as Hello My Love has given us confidence.
"This all means more to us this time around and we have all put a lot into making an album that feels fresh for today."
Spectrum is the band's first album in nine years, and Nicky, Shane Filan, Mark Feehily and Kian Egan have been dying for fans to hear it.
The album was co-written and produced by Westlife, Ed Sheeran and Steve Mac. The album follows a remarkable comeback year for the pop music treasures, which has seen the nation fall in love with them all over again.
Recorded in Dublin, LA and London, Spectrum is released as Shane, Nicky, Mark and Kian make pop music history, with them officially confirmed as the biggest selling Irish band in the UK in the 21st century.
The boys said: "We have all been driven by trying to create the best album of our careers. We wanted to make something current, something that feels fresh.
"The huge success of our comeback single Hello My Love gave us the confidence that our fans and the public were completely up for a new album of original songs.
"We’ve probably had more input into this album than any other in our careers.
"Spectrum has everything we love in music and includes a mixture of great uptempo’s such as well as heartfelt ballads. We’re excited for everyone to hear it."
Speaking about their collaboration with Sheeran and reunion with iconic music-maker Steve Mac, who has written some of Westlife’s biggest hits, they added: "The album has been a huge team effort and it has been fantastic to collaborate with our long term friend Steve Mac, James Bay and Ed Sheeran. There’s no doubt that they’ve helped us make this album the best it can be."
Westlife announced their return to music in October 2018 when they signed a new deal with Virgin EMI.
Their comeback included the success of this summer’s Twenty Tour, which sold a record 600,000 tickets across 27 cities and 13 countries.
The band have also announced a stadium tour for 2020 which culminates at their first ever Wembley Stadium show on August 22.
Westlife have sold over 55 million records worldwide, and are the only band to have their first 7 singles enter the UK chart at No.1. They also have the most singles of any artist to debut at No.1 in the UK.
Overall the band have had an incredible 14 No.1 singles, behind only Elvis Presley and The Beatles. They have had 33 No.1 albums worldwide and as a live act have sold 5 million concert tickets worldwide.
* Spectrum is out now
Do you have a story to sell? Get in touch with us at<EMAIL_ADDRESS>or call us direct 0207 29 33033


Dear
Thankyou for shopping with SwagTech. We hope you enjoyed our service.
Your Order number is: #.Here is your order detail:
| Billing Detail | Payment Information | Shipping Address | |
|---|---|---|---|
| Item Name | Item Price | Item Quantity | Total |
| Subtotal | |||
| Tax | |||
| Total |
Best,
SwagTech
Since 2019


Use this menu option to reduce the size of the CrypTool window down to an icon. The window can then be restored to its original size by selecting the Restore menu option.
Shortcuts


{% include sidebars/sections/recent_posts.html %} {% include sidebars/sections/twitter.html %} {% include sidebars/sections/delicious.html %} {% include sidebars/sections/pinboard.html %} {% include sidebars/sections/google_plus.html %}


--- layout: documentation title: PersonasType ---
The persona field characterizes a single persona (identity) leveraged by a threat to masquerade as another party.


Feature selection and learning curves¶
As mentioned above, one problem with our current model is over-fitting. To further understand and minimize the effect of over-fitting, it is often necessary to construct learning curves and perform feature selection to obtain a reduced feature set which most accurately describes your data. To do this, we are going to add two additional sections to our input file.
The first section is related to feature selection. Here, we will use the SequentialFeatureSelector algorithm, which performs forward selection of features. We will select a total of 20 features, and use a KernelRidge model to evaluate the selected features. Here, we ahve denoted our estimator as “KernelRidge_select”. The models used in feature selection and learning curves are removed from the model queue, because in general one may want to use a different model for this step of the analysis than what will ultimately be used for fitting. Therefore, we need to also amend our models list to have this new KernelRidge_select model, as shown below.
Example:
[FeatureSelection]
[[SequentialFeatureSelector]]
estimator = KernelRidge_select
k_features = 20
[Models]
[[KernelRidge]]
kernel = rbf
alpha = 1
gamma = 1
[[KernelRidge_select]]
kernel = rbf
alpha = 1
gamma = 1
The second section we will add is to plot learning curves. There are two types of learning curves MAST-ML can make: a data learning curve and feature learning curve. The former is a plot of the metric of interest versus the amount of training data used in the fits. The latter is a plot of the metric of interest versus the number of features comprising the X feature matrix. In the example LearningCurve input file section shown below, we are going to use a KernelRidge model, a random k-fold cross-validation and the root_mean_square_error to evaluate our learning curves. We will also use a maximum of 20 features, and use the SelectKBest algorithm to assess the choice of features.
Example:
[LearningCurve]
estimator = KernelRidge_learn
cv = RepeatedKFold_learn
scoring = root_mean_squared_error
n_features_to_select = 20
selector_name = SelectKBest
As with the above example of FeatureSelection, we need to add the KernelRidge_learn and RepeatedKFold_learn entries to the Models and DataSplits sections of our input file, respectively. At this point in the tutorial, the complete input file should look like this:
Example:
[GeneralSetup]
input_features = Auto
input_target = Reduced barrier (eV)
randomizer = False
metrics = Auto
input_other = Host element, Solute element, predict_Pt
[DataCleaning]
cleaning_method = imputation
imputation_strategy = mean
[FeatureGeneration]
[[Magpie]]
composition_feature = Solute element
[FeatureNormalization]
[[StandardScaler]]
[FeatureSelection]
[[SequentialFeatureSelector]]
estimator = KernelRidge_select
k_features = 20
[LearningCurve]
estimator = KernelRidge_learn
cv = RepeatedKFold_learn
scoring = root_mean_squared_error
n_features_to_select = 20
selector_name = SelectKBest
[Models]
[[KernelRidge]]
kernel = rbf
alpha = 1
gamma = 1
[[KernelRidge_select]]
kernel = rbf
alpha = 1
gamma = 1
[[KernelRidge_learn]]
kernel = rbf
alpha = 1
gamma = 1
[DataSplits]
[[NoSplit]]
[[RepeatedKFold]]
n_splits = 5
n_repeats = 2
[[RepeatedKFold_learn]]
n_splits = 5
n_repeats = 2
Let’s take a look at the same full fit and RepeatedKFold random cross-validation tests for this run:
Full-fit:
Random leave out cross-validation:
What we can see is, now that we down-selected features from more than 300 features in the previous run to just 20 here, that the fits have noticeably improved and the problem of over-fitting has been minimized. Below, we can look at the plotted learning curves
Data learning curve:
Feature learning curve:
We can clearly see that, as expected, having more training data will result in better test scores, and adding more features (up to a certain point) will also result in better fits. Based on these learning curves, one may be able to argue that additional features should could be used to further lower the error.


--- title: Twinning Analysis sidebar: documentation_sidebar permalink: TwinningBoundaries.html folder: documentation toc: false ---
In this section we consider the analysis of twining. Therefore lets start by importing some Magnesium data and reconstructing the grain structure.
{% highlight matlab %} % load some example data mtexdata twins % segment grains [grains,ebsd.grainId,ebsd.mis2mean] = calcGrains(ebsd('indexed'),'angle',5*degree); % remove two pixel grains ebsd(grains(grains.grainSize<=2)) = []; [grains,ebsd.grainId,ebsd.mis2mean] = calcGrains(ebsd('indexed'),'angle',5*degree); % smooth them grains = grains.smooth(5); % visualize the grains plot(grains,grains.meanOrientation) % store crystal symmetry of Magnesium CS = grains.CS; {% endhighlight %} {% highlight plaintext %} ebsd = EBSD Phase Orientations Mineral Color Symmetry Crystal reference frame 0 46 (0.2%) notIndexed 1 22833 (100%) Magnesium LightSkyBlue 6/mmm X||a*, Y||b, Z||c* Properties: bands, bc, bs, error, mad, x, y Scan unit : um {% endhighlight %}Next we extract the grainboundaries and save them to a separate variable
{% highlight matlab %} gB = grains.boundary {% endhighlight %} {% highlight plaintext %} gB = grainBoundary Segments length mineral 1 mineral 2 600 183 µm notIndexed Magnesium 3164 724 µm Magnesium Magnesium {% endhighlight %}The output tells us that we have 3219 Magnesium to Magnesium boundary segments and 606 boundary segements where the grains are cut by the scanning boundary. To restrict the grain boundaries to a specific phase transistion you shall do
{% highlight matlab %} gB_MgMg = gB('Magnesium','Magnesium') {% endhighlight %} {% highlight plaintext %} gB_MgMg = grainBoundary Segments length mineral 1 mineral 2 3164 724 µm Magnesium Magnesium {% endhighlight %}A variable of type grain boundary contains the following properties
These can be used to colorize the grain boundaries. By the following command, we plot the grain boundaries colorized by the misorientation angle
{% highlight matlab %} plot(gB_MgMg,gB_MgMg.misorientation.angle./degree,'linewidth',2) mtexColorbar {% endhighlight %}We observe that we have many grain boundaries with misorientation angle larger than 80 degree. In order to investigate the distribution of misorientation angles further we have the look at a misorientation angle histogramm.
{% highlight matlab %} close all histogram(gB_MgMg.misorientation.angle./degree,40) xlabel('misorientation angle (degree)') {% endhighlight %}Lets analyze the misorientations corresponding to the peak around 86 degree in more detail. Therefore, we consider only those misorientations with misorientation angle between 85 and 87 degree
{% highlight matlab %} ind = gB_MgMg.misorientation.angle>85*degree & gB_MgMg.misorientation.angle<87*degree; mori = gB_MgMg.misorientation(ind); {% endhighlight %}and observe that when plotted in axis angle domain they form a strong cluster close to one of the corners of the domain.
{% highlight matlab %} scatter(mori) {% endhighlight %}We may determin the center of the cluster and check whether it is close to some special orientation relation ship
{% highlight matlab %} % determine the mean of the cluster mori_mean = mean(mori,'robust') % determine the closest special orientation relation ship round2Miller(mori_mean) {% endhighlight %} {% highlight plaintext %} mori_mean = misorientation (Magnesium → Magnesium) antipodal: true Bunge Euler angles in degree phi1 Phi phi2 90.5949 86.0962 269.995 plane parallel direction parallel fit (01-1-1) || (-110-1) [10-11] || [10-1-1] 0.628° {% endhighlight %}Bases on the output above we may now define the special orientation relationship as
{% highlight matlab %} twinning = orientation.map(Miller(0,1,-1,-1,CS),Miller(-1,1,0,-1,CS),... Miller(1,0,-1,1,CS,'uvw'),Miller(1,0,-1,-1,CS,'uvw')) {% endhighlight %} {% highlight plaintext %} twinning = misorientation (Magnesium → Magnesium) (01-1-1) || (-110-1) [10-11] || [10-1-1] {% endhighlight %}and observe that it is actually a rotation about axis (-1210) and angle 86.3 degree
{% highlight matlab %} % the rotational axis round(twinning.axis) % the rotational angle twinning.angle / degree {% endhighlight %} {% highlight plaintext %} ans = Miller (Magnesium) h k i l -1 2 -1 0 ans = 86.2992 {% endhighlight %}Next, we check for each boundary segment whether it is a twinning boundary, i.e., whether boundary misorientation is close to the twinning.
{% highlight matlab %} % restrict to twinnings with threshold 5 degree isTwinning = angle(gB_MgMg.misorientation,twinning) < 5*degree; twinBoundary = gB_MgMg(isTwinning) % plot the twinning boundaries plot(grains,grains.meanOrientation) %plot(ebsd('indexed'),ebsd('indexed').orientations) hold on %plot(gB_MgMg,angle(gB_MgMg.misorientation,twinning),'linewidth',4) plot(twinBoundary,'linecolor','w','linewidth',4,'displayName','twin boundary') hold off {% endhighlight %} {% highlight plaintext %} twinBoundary = grainBoundary Segments length mineral 1 mineral 2 1649 361 µm Magnesium Magnesium {% endhighlight %}A common next step is to reconstruct the grain structure parent to twinning by merging the twinned grains. This is explained in detail in the section Merging Grains.


Good Reads
Hope this is useful! Please feel free to send me any reading recommendations and I'll consider adding them.
Data Science Interview Prep
Quora Interview Prep Resources
NLP
(coming soon!)
Images
Physics and ML
Unreasonable Effectiveness of Learning Neural Networks
Algorithms
Emperical Study of Naive Bayes Classifier


Menu
Accueil
Team
Prestations
Contact
Accueil
home
Team
supervisor_account
Prestations
thumb_up
Contact
contact_mail
YouMad
Civility:
Male
Female
face
first Name:
face
last Name:
phone
N° Phone:
email
Ent Email:
security
Password:
Availability:
Monday
Thuesday
Wednesday
Thursday
Friday
9h15-12h15
13h30-17h00
comment
your comment
Send


From the death certificate
for Ethel V. Fisher
Monroe County, Summit
Township, # 5308
Ethel V. Fisher
female, white, single
Birth: January 25, 1898, Ohio
Age: 19 yrs. ___ mos. 5 da.
Occupation: none
Father: M.M. Fisher, born Ohio
Mother: Elizabeth Buchanan, born Ohio
Informant: M.M. Fisher, Lewisville, O.
Death: January 30, 1917
Cause: cerebral meningitis, chronic**
Duration: 2 years
Contributory: LaGrippe
Duration: 7 days
Signed: L.P. Diehl, M.D., Jan. 30, 1917, Lewisville,
O.
Burial: Buchanan Cemetery, Feb. 1st, 1917
**Submitter's note: This death certificate was marked RETURNED. On the amended document, under the cerebral meningitis, chronic, it had: Sequal [sic] to typhoid fever.
Provided by Betty Latta Kitchen
Click here for the Short-Cut Table of Contents


--- layout: example categories: example/v1.0.0 version: v1.0.0 title: Filter by marker type description: Using setFilter, lookup the type of marker to be displayed on a map. tags: - markers ---


Period is used to separate search in link and class parts: [what to search in link].[what to search in class].Only one period symbol is allowed.Spaces and commas are allowed as separators to search for multiple words.
Change Link Type
Add linked class information to the joint selection
Use to aggregate (count, sum, max, ...) over linked class elements (or their attributes) that are connected to the source instance. Use to check, if a connected linked class instance exists.
Helps to create an aggregation variable and display or test it within the main query


If you wished you could have grep'd and monitored only few processes in top, this script is for you - ptop.sh:
while(true)
do
ps -ef | grep $1
sleep 1
clear
done
Run it:
% ptop.sh xterm
And you can see all the xterms currently running and refreshed every second.


🥳 Welcome to your notes! 🥳
Enjoy your notes:
{% for note in notes %}
{{ note }}
{% endfor %}
Want to take another note?🤔
Go ahead!
Send my note 😍


|
ovs all
|
This file lists a number of project ideas for Open vSwitch. The ideas here overlap somewhat with those in the OPENFLOW-1.1+.md "OPENFLOW-1.1+.md" file.
Each of these projects would ideally result in a patch or a short series of them posted to ovs-dev.
Please read CONTRIBUTING.md and CodingStyle.md in the top of the source tree before you begin work. The OPENFLOW-1.1+.md "OPENFLOW-1.1+.md" file also has an introduction to how OpenFlow is implemented in Open vSwitch. It is also a good idea to look around the source tree for related code, and back through the Git history for commits on related subjects, to allow you to follow existing patterns and conventions.
Open vSwitch has OpenFlow protocol support for meters, but it does not have an implementation in the kernel or userspace datapaths. An implementation was proposed some time ago (I recommend looking for the discussion in the ovs-dev mailing list archives), but for a few different reasons it was not accepted. Some of those reasons apply only to a kernel implementation of meters. At the time, a userspace implementation wasn't as interesting, because the userspace switch did not perform at a production speed, but with the advent of multithreaded forwarding and, now, DPDK support, userspace-only meters would be a great way to get started.
Open vSwitch allows some weak ciphers to be used for its secure connections. Security audits often suggest that the project remove those ciphers, but there's not a clean way to modify the acceptable ciphers. At the very least, the cipher list should be audited, but it would be nice to make it configurable.
Open vSwitch does not insist on perfect forward security via ephemeral Diffie-Hellman key exchange when it establishes an SSL/TLS connection. Given the wiretapping revelations over the last year, it seems wise to turn this on. (This would probably amount to finding the right OpenSSL function to call or just reducing the acceptable ciphers further.)
These changes might have backward-compatibility implications; one would have to test the behavior of the reduced cipher list OVS against older versions.
ovs-vsctl and other programs would be easier to use if bash command completion (with ``tab'', etc.) were supported. Alex Wang alexw is leading a team for this project. @nic ira.c om
Auxiliary connections are a feature of OpenFlow 1.3 and later that allow OpenFlow messages to be carried over datagram channels such as UDP or DTLS. One place to start would be to implement a datagram abstraction library for OVS analogous to the ``stream'' library that already abstracts TCP, SSL, and other stream protocols.
http://patchwork.openvswitch.org/patch/2249/ is an RFC patch that allows the switch to record the traffic on OpenFlow controller connections to a pcap file for later analysis. The patch lacks a good way to enable and disable the feature. The task here would be to add that and repost the patch.
Some basic support for OpenFlow 1.4 is missing and needs to be implemented. These can be found by looking through lib/ofp-util.c for mentions of OFP14_VERSION followed by a call to OVS_NOT_REACHED (which aborts the program).
OpenFlow 1.4 introduces OFPMP_FLOW_MONITOR for notifying a controller of changes to selected flow tables. This feature is based on NXST_FLOW_MONITOR that is already part of Open vSwitch, so to implement this feature would be to extend that code to handle the OpenFlow 1.4 wire protocol.
OpenFlow 1.3 also includes this feature as a ONF-defined extension, so ideally OVS would support that too.
OpenFlow 1.4 section 7.4.4 ``Controller Role Status Message'' defines a new message sent by a switch to notify the controller that its role (whether it is a master or a slave) has changed. OVS should implement this.
OpenFlow 1.3 also includes this feature as a ONF-defined extension, so ideally OVS would support that too.
OpenFlow 1.4 section 7.4.5 ``Table Status Message'' defines a new message sent by a switch to notify the controller that a flow table is close to filling up (or that it is no longer close to filling up). OVS should implement this.
OpenFlow 1.3 also includes this feature as a ONF-defined extension, so ideally OVS would support that too.
OpenFlow 1.4 adds a feature whereby a controller can ask the switch to send it copies of messages that change groups and meters. (This is only useful in the presence of multiple controllers.) OVS should implement this.
OpenFlow 1.3 also includes this feature as a ONF-defined extension, so ideally OVS would support that too.
Each of these projects would ideally result in confirmation that features work or bug reports explaining how they do not. Please sent bug reports to dev at openvswitch.org, with as many details as you have.
Ben Pfaff has a collection of files reporting Open vSwitch conformance to OpenFlow 1.3 provided by one of the vendors at the ONF plugfest last year. Some of the reported failures have been fixed, some of the other failures probably result from differing interpretations of OpenFlow 1.3, and others are probably genuine bugs in Open vSwitch. Open vSwitch has also improved in the meantime. Ben can provide the results, privately, to some person or team who wishes to check them out and try to pick out the genuine bugs.
Build a ``fuzzer'' for the OpenFlow protocol (or use an existing one, if there is one) and run it against the Open vSwitch implementation. One could also build a fuzzer for the OSVDB protocol.
The Ryu controller comes with a suite of ``certification tests'' that check the correctness of a switch's implementation of various OpenFlow 1.3 features. The INSTALL file in the OVS source tree has a section that explains how to easily run these tests against an OVS source tree. Run the tests and figure out whether any tests fail but should pass. (Some tests fail and should fail because OVS does not implement the particular feature; for example, OVS does not implement PBB encapsulation, so related tests fail.)
OFTest is a test suite for OpenFlow 1.0 compliance. The INSTALL file in the OVS source tree has a section that explains how to easily run these tests against an OVS source tree. Run the tests and figure out whether any tests fail but should pass, and ideally why. OFTest is not particularly well vetted–in the past, at least, some tests have failed against OVS due to bugs in OFTest, not in OVS–so some care is warranted.
Each of these projects would ideally result in creating some new documentation for users. Some documentation might be suitable to accompany Open vSwitch as part of its source tree most likely either in plain text or ``nroff'' (manpage) format.
Open vSwitch has a tutorial that covers its advanced features, but it does not have a basic tutorial. There are several tutorials on the Internet already, so a new tutorial would have to distinguish itself in some way. One way would be to use the Open vSwitch ``sandbox'' environment already used in the advanced tutorial. The sandbox does not require any real network or even supervisor privilege on the machine where it runs, and thus it is easy to use with hardly any up-front setup, so it is a gentle way to get started.
FlowVisor is a proxy that sits between OpenFlow controllers and a switch. It divides up switch resources, allowing each controller to control a ``slice'' of the network. For example, it can break up a network based on VLAN, allowing different controllers to handle packets with different VLANs.
It seems that Open vSwitch has features that allow it to implement at least simple forms of FlowVisor control without any need for FlowVisor. Consider an Open vSwitch instance with three bridges. Bridge br0 has physical ports eth0 and eth1. Bridge v9 has no physical ports, but it has two ``patch ports'' that connect it to br0. Bridge v11 has the same setup. Flows in br0 match packets received on vlan 9, strip the vlan header, and direct them to the appropriate patch port leading to v9. Additional flows in br0 match packets received from v9, attach a VLAN 9 tag to them, and direct them out eth0 or eth1 as appropriate. Other flows in br0 treat packets on VLAN 11 similarly. Controllers attached to bridge v9 or v11 may thus work as if they had full control of a network.
It seems to me that this is a good example of the power of OpenFlow and Open vSwitch. The point of this project is to explain how to do this, with detailed examples, in case someone finds it handy and to open eyes toward the generality of Open vSwitch usefulness.
The Open vSwitch website has a few ``cookbook'' entries that describe how to use Open vSwitch in a few scenarios. There are only a few of these and all of them are dated. It would be a good idea to come up with ideas for some more and write them. These could be added to the Open vSwitch website or the source tree or somewhere else.
Record a demo of Open vSwitch functionality in use (or something else relevant) and post it to youtube or another video site so that we can link to it from openvswitch.org.
If you plan to contribute code for a feature, please let everyone know on ovs-dev before you start work. This will help avoid duplicating work.
Please consider the following:
Please report problems to<EMAIL_ADDRESS>open vswit ch.o rg
Local Variables: mode: text End:


| Name: |
|
| Email: |
|
| Website: |
|
| Comment: |
|
| Opt-in settings: |
Can send email?
Can send SMS?
|
| Which sex are you: |
Female
Male
|
| Where did you hear of us: |
From the Internet
At the water cooler
From your mother
|
| Select the preferred media for contacting you: |
|
| Select the media we can use for contacting you if the preferred media is unavailable: |
|
| Select your interests: |
|
| Select without value: |
|
| Select when value and text are not same |
|
| Select when value is duplicated |
|
| Select with many options |
|
|


--- layout: post title: Speaking at Dayton IIBA Chapter Meeting tags: - agile - Blog - business analysis - dayton iiba - iiba - presentation - speaking status: publish type: post published: true meta: {} ---
I know this is late notice, but I will be speaking at the next Dayton International Institute of Business Analysis (IIBA) chapter meeting, which is tonight – March 9th!
In this presentation, we’ll start with a brief introduction of what it means to be agile, and then we’ll talk about how business analysts fit into an agile project team and how to work effectively with the rest of the project team to help your next project succeed.
For information on the event, check out the Dayton IIBA chapter website or the event page for tonight’s chapter meeting! If you would like to attend, you can rsvp via email to dayton.iiba@gmail.com.


Version Control with Git, HTML Basics
Welcome to CS-5630 / CS-6630 - Visualization. In this class we will use a mix of traditional slides and interactive documents to teach, but you can also use that as a reference for reading. This is first of those interactive lectures. We will cover the basics of version control with git, as well as the basics of the web stack.
Git
We will be using a version control tool called git to track changes to our code. We’ll also be using Github, an online tool for hosting git repositories.
You should already have git installed, if not see the official documentation on how to install git on your operating system.
Why version Control?
- Keep copies of multiple states of files
By committing you record a state of the file to which you can go back any time. - Create alternative states
Imagine you just want to try out something, but you realize you have to modify multiple files. You’re not sure whether it works or is worth it. With version control you can just create a branch where you can experiment or develop new features without disturbing the main or other branches. - Collaborate in Teams
Nobody wants to send code via e-mail. Version control lets you keep your code remotely and has dedicated ways to merge and deal with conflicts. - Keep your work safe
Your hard drive breaks. Your computer is stolen. But your code is safe because you store it not only on your computer but also on a remote server. - Share
You developed something awesome and want to share it. But not only do you want to make it available, you’re also happy about contributions from others!
Types of Version Control: Central Repository
- Everybody needs to write to one server
- All operations (history, commit, branches) require server connection
- Common traditional model: CVS, SVN, etc.
- Pros:
- Simple Model
- Cons:
- Complex for larger projects
- Who is allowed to write?
- Complex for larger projects
Types of Version Control: Distributed Version Control
- Everybody has a full history of the repository locally
- No defined server - every node is equal.
- In practice: often server is used for one “official” copy of code.
But: server by convention only, no technical difference.
- In practice: often server is used for one “official” copy of code.
- Pros:
- No access issues
- Make a copy and hack away
- Ask if partner wants to accept your changes
- Everything is local
- Fast!
- No internet connection required
- Commit often model (once per feature) - don’t sync all the time.
- No access issues
- Cons:
- Extra effort to distinguish between committing and pushing/pulling (synchronizing).
Implementations
- Centralized
- CVS
- SVN
- Team Foundation Server
- …
- Distributed
- git
- Mercurial
- …

I’m an egotistical bastard, and I name all my projects after myself. First ‘Linux’, now ‘git’. – Linus Torvalds
Why git?
- Popular (~50% of open source projects)
- Truly distributed
- Very fast
- Everything is local
- Free
- Safe against corruptions
- GitHub!
git model
Whiteboard sketch of git with a server. A git repository is essentially a large graph.
git tutorial
This is a quick intro to git, used in combination with GitHub. This is not a complete tutorial, but will use the most important git features.
We start by configuring git
1 $ git config --global user.name "YOUR NAME"
2 $ git config --global user.email "YOUR EMAIL ADDRESS"
Make sure that his is set to your official school address and your correct name!
Create a folder for your project
1 $ mkdir myProject
2 $ cd myProject/
Initalize the git repository
1 $ git init
2 Initialized empty Git repository in ../myProject/.git/
What does git do to your file system?
1 # Let's look at what git creates
2 $ ls .git/
3 branches config description HEAD hooks info objects refs
4
5 # The interesting stuff is in the config file
6 $ cat .git/config
7 [core]
8 repositoryformatversion = 0
9 filemode = true
10 bare = false
11 logallrefupdates = true
12
13
14 # More interesting for a project with branches and remotes
15 $ cat .git/config
16 [core]
17 repositoryformatversion = 0
18 filemode = true
19 bare = false
20 logallrefupdates = true
21 [remote "origin"]
22 url = https://github.com/CS171/HW1.git
23 fetch = +refs/heads/*:refs/remotes/origin/*
24 [branch "master"]
25 remote = origin
26 merge = refs/heads/master
Now let’s create a file
1 $ echo 'Hello World' > demo.txt
2 $ cat demo.txt
3 Hello World
Let’s add it to version control
1 $ git add demo.txt
Let’s look at what is going on with the repository
1 $ git status
2 # On branch master
3 #
4 # Initial commit
5 #
6 # Changes to be committed:
7 # (use "git rm --cached <file>..." to unstage)
8 #
9 # new file: demo.txt
10 #
That means: git knows that it’s supposed to track this file, but it’s not yet versioned.
Let’s commit the file. Once a file is committed, it’s state is recorded and you can go back to previous versions any time.
1 # The -m option specifies the commit message. If you don't use it you'll go into an editor to enter your commit message.
2 $ git commit -m "Committing the test file"
3 [master (root-commit) 3be5e8c] Wrote to demo
4 1 file changed, 1 insertion(+)
5 create mode 100644 demo.txt
6
7 # Did it work?
8 $ git status
9 # On branch master
10 nothing to commit, working directory clean
That means that now the file is tracked and committed to git. But it’s still only stored on this one computer!
Next, we change a file and commit it again.
1 # Now let's change something
2 $ echo 'Are you still spinning?' >> demo.txt
3 $ cat demo.txt
4 Hello World!
5 Are you still spinning?
6
7 # Let's check the status of git!
8 $ git status
9 # On branch master
10 # Changes not staged for commit:
11 # (use "git add <file>..." to update what will be committed)
12 # (use "git checkout -- <file>..." to discard changes in working directory)
13 #
14 # modified: demo.txt
15 #
16 no changes added to commit (use "git add" and/or "git commit -a")
17
18 # So git knows that something has changed, but hasn't recorded it. Let's commit.
19 $ git commit -m "Added a line to the demo file"
20 On branch master
21 Changes not staged for commit:
22 modified: demo.txt
23
24 # That didn't work!  There is a shorthand that you can use to add all the tracked files: append '-a'.
25 $ git commit -a -m "added a line to the demo file"
26 [master b03178f] added a line to the demo file
27 1 file changed, 1 insertion(+)
28
29 # Better. Now, let's look at what happened up to now
30 $ git log
31 commit a939cdfeaf0a7ffb972e6616549e9053917e0673
32 Author: Alexander Lex<EMAIL_ADDRESS>33 Date: Thu Jan 30 20:35:37 2014 -0500
34
35 spinning
36
37 commit 3be5e8c4b3691a70598d784483ef9cf35d5663ba
38 Author: Alexander Lex<EMAIL_ADDRESS>39 Date: Thu Jan 30 20:29:52 2014 -0500
40
41 Wrote to demo
Commits have a unique ID. This ID is a hash of your complete history. When we retreive your homeworks, we will tell you the commit ID of the homework we grade. Check whether that’s the correct ID!
Through this cycle of editing, adding and committing, you can develop software in a linear fashion. Now let’s see how we can create alternate versions.
Branching
Now let’s create a branch
1 $ git branch draft
2
3 # This created a branch with the name draft. Let's look at all the other branches
4 $ git branch
5 draft
6 * master
We have two branches, draft and master. The * tells us the active branch (the HEAD).
The files in your folders are in the state as they are stored in the active branch. When you change the branch the files are changed, removed or added to the state of the target branch.
Let’s switch the branch.
1 $ git checkout draft
2 Switched to branch 'draft'
3
4 # Let's see if there is something different
5 $ cat demo.txt
6 Hello World!
7 Are you still spinning?
8
9 # No - it's the same! Now let's edit.
10 $ echo "Spinning round and round" >> demo.txt
11 $ cat demo.txt
12 Hello World!
13 Are you still spinning?
14 Spinning round and round
15
16 # And commit
17 $ git commit -a
18 [draft 059daaa] Confirmed, spinning
19 1 file changed, 1 insertion(+)
We have now written changes to the new branch, draft. The master branch should remain unchanged. Let’s see if that’s true.
1 # Now let's switch back to master again
2 $ git checkout master
3 Switched to branch 'master'
4
5 $ cat demo.txt
6 Hello World!
7 Are you still spinning?
The text we added isn’t here, as expected! Next we’re going to change something in the main branch and thus cause a conflict.
1 # Writing something to the front and to the end in an editor
2 $ cat demo.txt
3 I am here!
4 Hello World!
5 Are you still spinning?
6 Indeed!
7
8 # comitting again
9 $ git commit -a
10 [master 8437327] Front and back
11 1 file changed, 2 insertions(+)
At this point we have changed the file in two different branches of the repository. This is great for working on new features without breaking a stable codebase, but it can result in conflicts.
Let’s try to merge those two branches.
1 # the git merge command merges the specified branch into the currently active one. "master" is active, and we want to merge in "draft".
2 $ git merge draft
3 Auto-merging demo.txt
4 CONFLICT (content): Merge conflict in demo.txt
5 Automatic merge failed; fix conflicts and then commit the result.
6
7 # The result
8 $ cat demo.txt
9 I am here!
10 Hello World!
11 Are you still spinning?
12 <<<<<<< HEAD
13 Indeed!
14 =======
15 Spinning round and round
16 >>>>>>> draft
17
18 # The first line was merged without problems, The final line, where we have two alternative versions is a conflict. We have to manually resolve the conflict.
19
20 # Once this is done, we can commit again.
21 $ git commit -a
22 [master 4dad82f] Merge branch 'draft'
23
24 # Everything back in order.
25 $ git status
26 # On branch master
27 nothing to commit, working directory clean
These are the basics of git on a local server. Now we’ll learn how to sync with other people. This can be done with just git, but we’ll be using GitHub as we’re also using GitHub in the homeworks.
Working with GitHub
First, we’ll create a new repository on github by going to https://github.com/new.
Now let’s clone the repository from GitHub.
1 $ git clone https://github.com/alexsb/Demo.git
2
3 # Let's see how the config looks for this one.
4 $ cat .git/config
5 [core]
6 repositoryformatversion = 0
7 filemode = true
8 bare = false
9 logallrefupdates = true
10 ignorecase = true
11 precomposeunicode = true
12 [remote "origin"]
13 url = https://github.com/alexsb/demo.git
14 fetch = +refs/heads/*:refs/remotes/origin/*
15 [branch "master"]
16 remote = origin
17 merge = refs/heads/master
This creates a local copy of the (empty) GitHub repository. We will just start working with that and commit and push the code to the server. If you’d like to add an existing repository to GitHub, follow these instructions.
1 # What's currently in the repository?
2 $ ls
3 LICENSE README.md
4 # Write something to demo.txt.
5 $ echo "Hello world!" > demo.txt
6 echo "Hello world" > demo.txt
7 # Add demo.txt to the repository.
8 $ git add demo.txt
9 # Commit the file to the repository.
10 $ git commit -a -m "added demo file"
11 [master 2e1918d] added demo file
12 1 file changed, 1 insertion(+)
13 create mode 100644 demo.txt
14 # Pushing it to the server!
15 $ git push
16 Counting objects: 3, done.
17 Delta compression using up to 8 threads.
18 Compressing objects: 100% (2/2), done.
19 Writing objects: 100% (3/3), 324 bytes | 0 bytes/s, done.
20 Total 3 (delta 0), reused 0 (delta 0)
21 To https://github.com/alexsb/demo.git
22 8e1ecd1..2e1918d master -> master
We have now committed a file locally and pushed it to the server, i.e., our local copy is in sync with the server copy.
Note that the git push
command uses the origin defined in the config file. You can also push to other repositories!
Next, we will make changes at another place. We’ll use the GitHub web interface to do that.
Once these changes are done, our local repository is out of sync with the remote repository. To get these changes locally, we have to pull from the repository:
1 $ git pull
2 remote: Counting objects: 3, done.
3 remote: Compressing objects: 100% (2/2), done.
4 remote: Total 3 (delta 1), reused 0 (delta 0), pack-reused 0
5 Unpacking objects: 100% (3/3), done.
6 From https://github.com/alexsb/demo
7 2e1918d..5dd3090 master -> origin/master
8 Updating 2e1918d..5dd3090
9 Fast-forward
10 demo.txt | 1 +
11 1 file changed, 1 insertion(+)
12 # Let's see whether the changes are here
13 $ cat demo.txt
14 Hello world
15 Are you still spinning?
Other GitHub Features
- GitHub Issues
Github Issues are a great way to keep track of open tasks and problems. Issues can be references and closed from commits. - Forking
Forking is essentially making use of the distributed nature of git, while having the benefits of a server. When you fork a repository you make a clone of someone else’s code that you are not allowed to read. The repository appears in your github account and you can start editing the code. If you think you improved the code, you can send a “pull request” to the original owner. The owner can then review your code and merge your modifications into his main repository. Forking is hence virtually the same as branching, with the exception that it resolves issues with write permissions.
GUI Clients
- GitHub Desktop
Good option if you want a GUI client. Download here - Integrated in IDEs
Many operations can be done out of a IDE such as WebStorm
Setting up your homework repositories.
The homeworks are hosted in a git repository. Every time we release a homework we will just update the repository. You can then pull from that repository to get the latest homework on your computer.
To get the homework repository, run the following:
1 $ git clone https://github.com/dataviscourse/2015-dataviscourse-homework -o homework
2 $ cd 2015-dataviscourse-homework
Note that by using the -o homework
option we’re not using the default remote origin
but a user-defined remote called homework
.
Next, create a new repository on the Github website following the dataviscourse15-hw-lastname-firstname
naming convention. Use all lowercase for your repository name. It is important that your repository be named exactly as above so that we can access it for grading.
Ensure your new repository is private and don’t click the option to “Initialize the repository with a README”.
Run the two commands described on GitHub under the heading “Push an existing repository from the command line”. For my repository these are:
1 $ git remote add origin https://github.com/alexsb/dataviscourse15-hw-lex-alexander.git
2 $ git push -u origin master
On GitHub, go to the repository settings and navigate to the Collaborators page. Add datavis-ta
as a collaborator to your private repository.
Now your homework repository is all set!

The git push
operation pushes your local commits to the remote repository. It is important that you push your changes or others will not be able to see them.
You should do this frequently: as often as you have an incremental, standalone improvement.
Submitting your homework
We will automatically copy your repository after each homework deadline. You do not need to do anything else to submit your work (but make sure that you have pushed the latest version of your homework).
Refer to the homework page for more information on how to submit your homework.
Getting new homework assignments
When we release a new assignment we will simply add it to the homework github repository.
To get the latest homework assignments and potential updates or corrections to the assignment, run the following.
1 $ git pull homework master
Make sure to have all your changes committed before you do that.


| Methods' Details |
createBlankNode
- Description
- creates a fresh unique blank node.
- Returns
- a newly generated blank node which is unique in this repository
|
|
importGraph
- Description
- imports a named graph into the repository.
Implementations must support RDF/XML format.
Support for other RDF formats is optional.
If the format is not supported by the implementation, an
::com::sun::star::datatransfer::UnsupportedFlavorException is raised.
If the format requires use of a BaseURI, but none is given, an
::com::sun::star::lang::IllegalArgumentException
is raised.
- Parameter Format
- the format of the input file
- Parameter InStream
- the input stream, containing an RDF file in the specified format
- Parameter GraphName
- the name of the graph that is imported
- Parameter BaseURI
- a base URI to resolve relative URI references
- Returns
- the imported graph
- Throws
- com::sun::star::lang::IllegalArgumentException
if the given stream or the GraphName is NULL,
or BaseURI is NULL and the format requires use of a base URI
- Throws
- com::sun::star::datatransfer::UnsupportedFlavorException
if the format requested is unknown or not supported
- Throws
- com::sun::star::container::ElementExistException
if a graph with the given GraphName already exists in the
repository
- Throws
- ParseException
if the input does not conform to the specified file format.
- Throws
- RepositoryException
if an error occurs when accessing the repository.
- Throws
- com::sun::star::io::IOException
if an I/O error occurs.
- See also
- FileFormat
|
|
exportGraph
- Description
- exports a named graph from the repository.
Implementations must support RDF/XML format.
Support for other RDF formats is optional.
If the format is not supported by the implementation, an
::com::sun::star::datatransfer::UnsupportedFlavorException is raised.
- Parameter Format
- the format of the output file
- Parameter OutStream
- the target output stream
- Parameter GraphName
- the name of the graph that is to be exported
- Parameter BaseURI
- a base URI to resolve relative URI references
- Throws
- com::sun::star::lang::IllegalArgumentException
if the given stream or the GraphName is NULL,
or BaseURI is NULL and the format requires use of a base URI
- Throws
- com::sun::star::datatransfer::UnsupportedFlavorException
if the format requested is unknown or not supported
- Throws
- com::sun::star::container::NoSuchElementException
if a graph with the given GraphName does not exist
- Throws
- RepositoryException
if an error occurs when accessing the repository.
- Throws
- com::sun::star::io::IOException
if an I/O error occurs.
- See also
- FileFormat
|
|
getGraphNames
- Description
- gets the names of all the graphs in the repository.
- Returns
- a list containing the names of the graphs in the repository
- Throws
- RepositoryException
if an error occurs when accessing the repository.
|
|
getGraph
- Description
- gets a graph by its name.
- Parameter GraphName
- the name of the graph that is to be returned
- Returns
- the graph with the given name if it exists, else NULL
- Throws
- com::sun::star::lang::IllegalArgumentException
if the given GraphName is invalid
- Throws
- RepositoryException
if an error occurs when accessing the repository.
|
|
createGraph
- Description
- creates a graph with the given name.
The name must be unique within the repository.
- Parameter GraphName
- the name of the graph that is to be created
- Returns
- the graph with the given name
- Throws
- com::sun::star::lang::IllegalArgumentException
if the given GraphName is invalid
- Throws
- com::sun::star::container::ElementExistException
if a graph with the given GraphName already exists
- Throws
- RepositoryException
if an error occurs when accessing the repository.
|
|
destroyGraph
- Description
- destroys the graph with the given name, and removes it from the
repository.
This invalidates any instances of XNamedGraph
for the argument.
- Parameter GraphName
- the name of the graph that is to be destroyed
- Throws
- com::sun::star::lang::IllegalArgumentException
if the given GraphName is invalid
- Throws
- com::sun::star::container::NoSuchElementException
if a graph with the given GraphName does not exist
- Throws
- RepositoryException
if an error occurs when accessing the repository.
|
|
getStatements
- Description
- gets matching RDF statements from the repository.
Any parameter may be NULL, which acts as a wildcard.
For example, to get all statements about myURI:
getStatements(myURI, null, null)
- Parameter Subject
- the subject of the RDF triple.
- Parameter Predicate
- the predicate of the RDF triple.
- Parameter Object
- the object of the RDF triple.
- Returns
- an iterator over all RDF statements in the repository that match
the parameters, represented as an
enumeration of Statement
- Throws
- RepositoryException
if an error occurs when accessing the repository.
- See also
- Statement, XNamedGraph::getStatements
|
|
querySelect
- Description
- executes a SPARQL "SELECT" query.
This method runs a SPARQL query that returns a list of variable
bindings, i.e., a query beginning with "SELECT".
The result is basically a (rectangular) table with labeled columns,
where individual cells may be NULL.
- Parameter Query
- the SPARQL query
string
- Returns
- an enumeration, containing
- a list of query variable names (column labels)
- the query results (rows),
each being a list of bindings for the above variables
- Throws
- QueryException
if the query is malformed, or evaluation fails
- Throws
- RepositoryException
if an error occurs when accessing the repository.
- See also
- XQuerySelectResult
|
|
queryConstruct
- Description
- executes a SPARQL "CONSTRUCT" query.
This method runs a SPARQL query that constructs a result graph,
i.e., a query beginning with "CONSTRUCT".
- Parameter Query
- the SPARQL query
string
- Returns
- an iterator over the query result graph, represented as an
enumeration of Statement
- Throws
- QueryException
if the query is malformed, or evaluation fails
- Throws
- RepositoryException
if an error occurs when accessing the repository.
- See also
- Statement
|
|
queryAsk
- Description
- executes a SPARQL "ASK" query.
This method runs a SPARQL query that computes a boolean,
i.e., a query beginning with "ASK".
- Parameter Query
- the SPARQL query
string
- Returns
- the boolean query result
- Throws
- QueryException
if the query is malformed, or evaluation fails
- Throws
- RepositoryException
if an error occurs when accessing the repository.
|
|
Copyright © 2013, The Apache Software Foundation, Licensed under the Apache License, Version 2.0. Apache, the Apache feather logo, Apache OpenOffice and OpenOffice.org are trademarks of The Apache Software Foundation. Other names may be trademarks of their respective owners.


Symbl AI Personal Assistant
Fill in the information below to have Symbl join your conversation
Success! Symbl is now dialing into your meeting.
At the end of the call, Symbl will send you an email with the conversation summary.
Join another meeting


| About Dailyrotten |
|
Feedback
If you like this page, hate it, or would like to suggest changes,
<EMAIL_ADDRESS>is listening. This page
is experimental and somewhat different from what we usually offer, so please
do send your feedback.
Adding Stories
If you are a rotten newshound and you would like to suggest a story,
visit our submit page to
send us the URL. Stories that are accepted will have your name credited.
Posting Comments
In order to post comments to stories, you will have to
create an account.
Accounts will generally be validated within 24 hours, and of
course will be disabled if there is abuse.
Viewership
On the first full day this page went live, 100,000 people visited this Rotten
News page. Of course that was the day after the WTC attacks, so that number is
somewhat distorted. Right now this page gets between 50,000 and 75,000 people
every day.
Linking
We encourage everyone to link to this page; if you like it, others probably
will as well.
Other Rotten
Rotten
Gaping Maw
Celebrity Morgue
Mugshots
Rotten Store
Rate My Poo
Rate My Kitten
Rate My Finger
Penny Postcards
Phallic
Boners
Home
Make Dailyrotten your start page
|
|
|
April 21, 2002
Flesh Eating Plant Stolen by Drunkards
The Scotsman | Submitted by: Todrael
A bio-engineered plant programmed to eat slugs was stolen from behind a high tech laser alarm system. Erich Preymann says he "hope[s] that this was a prank played by some drunkards and the plant will be returned to me soon."
|
|
Read article...
|
|
Potheads arrested for meter long joint
Australian Broadcasting | Submitted by: aeon
"Darwin residents opposed to changing the Northern Territory's drug laws have held a protest in a city park lighting what they claim, at just under a metre in length, is Darwin's biggest joint. ... Five protesters were arrested, one of those for having a toke on the one-metre joint. ... However, the joint was not confiscated because police say it may not have contained marijuana."
|
|
Read article...
|
|
Harry Potter fans drink poisonous potion
BBC | Submitted by: tyche
"Harry Potter fans in the Siberian city of Novosibirsk are believed to
have been poisoned after drinking a "magic potion" inspired by the series
of books about a boy wizard. Local police suspect that older children stole
copper sulphate from a school laboratory and fed it to younger children
in a Potteresque initiation ceremony." Mmm, copper sulphate...
|
|
Read article...
|
|
Three die in Internet suicide pact
News Corporation | Submitted by: Ogrish
"Two teenaged girls and a 34-year-old man leaped 28 floors to their
deaths in the South Korean capital after making an internet suicide pact,
police said today. South Korean authorities have tried to clampdown on
internet sites that aid suicide but more than 20 people are now known
to have killed themselves over the past 18 months after
making plans on the web."
|
|
Read article...
|
|
He should have kept it with his putter
KHOU-TV 11 Houston | Submitted by: anonymous
"Larry Alford's prosthetic arm has been missing ever since last month,
when thieves stole his car and unwittingly took his false limb. Now police
believe they know who took the car, but they wonder whether they'll
ever find Alford's arm." Where do police think it is?
"It's very possible that one or even both arms are now in a landfill."
|
|
Read article...
|
|
City of Topeka published credit card numbers
Topeka Capital-Journal | Submitted by: newsnose
"He provided the exact address of the file, which the newspaper was able
to access. As he said, it was a listing of 500 people, apparently young
people who had at some time signed up for city recreation programs. Other
columns in the table provided the parents' names and addresses. Another
contained four sets of four numbers, a typical arrangement for
credit card numbers."
|
|
Read article...
|
|
Her entire family raped her
All Africa | Submitted by: anonymous
There is a lot of ethical and moral decay in certain parts of Africa, especially South Africa. This article detailed several cases of incestuous
child rape, which seems to be an epidemic in the region. To be fair, such
evil is not limited to South Africa, but it is certainly a larger problem
there: "She took off my pyjamas and told me to lay down. My father came
in and began fondling me and then raping me. When I struggled my
mother held me down."
|
|
Read article...
|
|
|
|
|


ChicagoHacksBig
We created 4,500+ geofences around live music venues in 16 U.S. cities. We captured visit data to these geofences during the evening of February 18th and the morning of February 19th, 2016 in collaboration with DoStuff, whose app had 10,000+ users share location data.
We published 13,000+ geofence visits using Gimbal (the SDK inside DoStuff's app) and we are visualizing live music attendees' real-life data using D3, Bootstrap, Gimbal SDKs, Heatmap.js, InfluxDB, JQuery, Leaflet, NVD3, Python and THREEJS.
Our Promise: ChicagoHacksBig will donate 100% of all prize money to Smart Chicago, who helps Chicago Youth learn tech skills as a mission-driven non-profit. (#chihacksbig on Twitter for more)


My team
Manager
Manager's Name: Raven
Manager's Email
Intern's ID: Manager's ID: 23423
Manager's Office #: 23423
Engineer
Engineer's Name: tay
Engineer's Email
Engineer's ID: 3243
Engineer's gitHub
Intern
Intern's Name: jason
Intern's Email
Intern's ID: Intern's ID: 345466
Intern'school: uot


Which movie to watch tonight? This decision is always made considering two factors, critics reviews and human instinct. Today with this
visualization we study the effect of other factors on the movie ratings. Can the factors such as budget, gross income, FB likes, Actors, Director and cast likes
help in determining the quality of the movie. With the help of MovieTime you would be able to analyze the effect of the above factors on the IMDB ratings of the movie and dive
into the cast and review details of a particular movie. So let's start!!


|
INI
NJAN URANGATTE (AND NOW LET ME SLEEP) NOVEL This novel is counted as one of the best novels of Malayalam literature and constant best seller since it was first published in 1973 The book subsists on the great epic ‘The
Mahabharath’ that has flourished over two thousand years. The main
element of the novel is the story of Karna woven into a delicately and
imaginatively developed parallel story of Draupadi. Maintaining the original
epic atmosphere, the story, events and characters are structured in the
strains of thought of Draupadi, imaginatively constructed. The details
of the story of Karna closely follows the original epic. |
TRANSLATIONS
| English:
'And Now Let Me Sleep', 1999 Translator: Dr. K.C. Sarsamma Publisher: Kendra Sahitya Akademi, Rabindra Bhavan,35, Ferozeshah Road, New Delhi, India. Pin 110 001 |
Tamil:
'Ini Njan Urangattum', 2001 Translator: A. Madhavan Publisher: Kendra Sahitya Akademi |
| Kannada:
'Naninnu Nidrisuve',2000 Translator:Sara Aboobacker Publisher: Kendra Sahitya Akademi |
Publishers: DC Books Kerala
First published by Sahitya Pravarthaka Co-operative Society, 1973
Price Rs.90/-


Get All Todos
Json will go here
limit:
get a limited number of todos
contains:
search todo body
status:
get the status of todos
owner:
get todos by this owner
category:
get todos in this category
ordered by:
get todos ordered alphabetically by this field
apply all of these filters


|
Date/Time
|
Location
|
Agenda
|
Minutes
|
Wednesday
February 13, 2019
3:00 P.M.
|
Climaco Law Offices
55 Public Square Suite 1950
Cleveland, Ohio 44113
|
|
|
Wednesday
May 29, 2019
12:00 P.M.
|
Climaco Law Offices
55 Public Square Suite 1950
Cleveland, Ohio 44113
|
|
|
Wednesday
September 11, 2019
12:00 P.M.
|
Climaco Law Offices
55 Public Square Suite 1950
Cleveland, Ohio 44113
|
|
|
Wednesday
November 13, 2019
1:00 P.M.
|
Climaco Law Offices
55 Public Square Suite 1950
Cleveland, Ohio 44113
|
|
|


Recommended Development Environment
Note: Spartacus 2.x is no longer maintained. Please upgrade to the latest version.
CLI tools
There are a number of necessary CLI tools that you need to have installed in order to work with Spartacus, as follows:
- Node - first and foremost you need Node installed. To install it, refer to the official site. An alternative to installing a system-wide version of node is to use a Node version manager, such as nvm.
nvm
also works on Windows via Windows Subsystem for Linux, a.k.a.WSL
; ifWSL
is not available, nvm-windows can be used. The advantage of installing a Node version manager is that it provides an ability to easily switch to a different version of Node. - Package manager - Spartacus team prefers
yarn
overnpm
, as a package manager solution, for its speed. To installyarn
see the official guide.npm
comes pre-installed with Node. - Angular CLI - to install it, run
npm install -g @angular/cli
. To configure angular CLI to always useyarn
overnpm
runng config -g cli.packageManager yarn
. This setting is stored in<YOUR_HOMEDIR>/.angular-config.json
. For more, see this article.
Versions
Your Angular development environment should include the following:
- Angular CLI: Version 9.1 or later, < 10.0.
- Node.js: The most recent 12.x version is recommended, < 13.
- Yarn: Version 1.15 or later.
Editor
Spartacus team recommends a highly extensible and open source editor - VSCode, which can be downloaded from here.
VSCode settings
To share some common settings across team members, create .vscode
folder in the root of your project, and inside of it create settings.json
file. Settings added here are known as workspace
settings.
Here are some recommended workspace settings that also help to avoid collision with the recommended code-formatter:
{
// Prettier uses single quotes.
"prettier.singleQuote": true,
// Prettify on save
"editor.formatOnSave": true,
// prettier uses 2 spaces instead of 4
"editor.tabSize": 2,
// organize imports on save
"editor.codeActionsOnSave": {
"source.organizeImports": true
},
// Uses the project specific typescript version.
"typescript.tsdk": "node_modules/typescript/lib"
}
VSCode extensions
Here is a list of recommended extensions when working with Spartacus:
- angular language services
- chrome debugger
- TSLint
- prettier - code formatter
There’s no need to manually install these extensions - just create .vscode
folder in the root of your project, and inside of it create extensions.json
with the following content:
{
"recommendations": [
// Angular Language Service
"Angular.ng-template",
// Debugger for Chrome
"msjsdiag.debugger-for-chrome",
// The ng lint command uses TSLint under the hood.
"ms-vscode.vscode-typescript-tslint-plugin",
// Prettier - Code formatter
"esbenp.prettier-vscode"
]
}
VSCode will automatically prompt you to install the recommended extensions with just one click. This is also a nice way to have a consistent environment across team members.
Some other notable extensions:
- Inline HTML and CSS highlighter -
natewallace.angular2-inline
- A more richer git support than VS Code’s default one -
eamodio.gitlens
- AI assisted IntelliSense -
visualstudioexptteam.vscodeintellicode
- Docker support -
peterjausovec.vscode-docker
- Languages support for the SAP Hybris import/export language ImpEx (unofficial) -
simplyroba.impex-support
- Markdown linting and style checking for Visual Studio Code -
davidanson.vscode-markdownlint
Project setup
After creating a new project and pulling Spartacus libraries, it’s time to set up the project.
Code formatting
As a code formatter, Spartacus team prefers prettier. To install it as a dependency, run yarn add prettier --dev
. To share prettier settings with all team members, create .prettierrc
file in the root of your project and paste the following:
{
"printWidth": 120,
"singleQuote": true,
"useTabs": false,
"tabWidth": 2,
"semi": true,
"bracketSpacing": true,
"trailingComma": "es5"
}
Most of these options are prettier’s defaults, but it’s a good practice to have them explicitly defined.
To ignore some files from being formatted, create .prettierignore
in the project’s root, and ignore your files like so:
**/*.md
To avoid collision between tslint
and prettier
, it’s recommended to remove formatting rules from the tslint.json
and leave the formatting to prettier
. This is a diff version of rules that should be removed from the tslint.json
:
{
"rulesDirectory": [
"node_modules/codelyzer"
],
"rules": {
"arrow-return-shorthand": true,
"callable-types": true,
"class-name": true,
-- "comment-format": [
-- true,
-- "check-space"
-- ],
-- "curly": true,
-- "eofline": true,
"forin": true,
"import-blacklist": [
true,
"rxjs",
"rxjs/Rx"
],
-- "import-spacing": true,
-- "indent": [
-- true,
-- "spaces"
-- ],
"interface-over-type-literal": true,
"label-position": true,
-- "max-line-length": [
-- true,
-- 140
-- ],
"member-access": false,
"member-ordering": [
true,
{
"order": [
"static-field",
"instance-field",
"static-method",
"instance-method"
]
}
],
"no-arg": true,
"no-bitwise": true,
"no-console": [
true,
"debug",
"info",
"time",
"timeEnd",
"trace"
],
"no-construct": true,
"no-debugger": true,
"no-duplicate-super": true,
"no-empty": false,
"no-empty-interface": true,
"no-eval": true,
"no-inferrable-types": [
true,
"ignore-params"
],
"no-misused-new": true,
"no-non-null-assertion": true,
"no-shadowed-variable": true,
"no-string-literal": false,
"no-string-throw": true,
"no-switch-case-fall-through": true,
-- "no-trailing-whitespace": true,
"no-unnecessary-initializer": true,
"no-unused-expression": true,
"no-use-before-declare": true,
"no-var-keyword": true,
"object-literal-sort-keys": false,
-- "one-line": [
-- true,
-- "check-open-brace",
-- "check-catch",
-- "check-else",
-- "check-whitespace"
-- ],
"prefer-const": true,
-- "quotemark": [
-- true,
-- "single"
-- ],
"radix": true,
-- "semicolon": [
-- true,
-- "always"
-- ],
"triple-equals": [
true,
"allow-null-check"
],
-- "typedef-whitespace": [
-- true,
-- {
-- "call-signature": "nospace",
-- "index-signature": "nospace",
-- "parameter": "nospace",
-- "property-declaration": "nospace",
-- "variable-declaration": "nospace"
-- }
-- ],
"typeof-compare": true,
"unified-signatures": true,
"variable-name": false,
-- "whitespace": [
-- true,
-- "check-branch",
-- "check-decl",
-- "check-operator",
-- "check-separator",
-- "check-type"
-- ],
"directive-selector": [
true,
"attribute",
"app",
"camelCase"
],
"component-selector": [
true,
"element",
"app",
"kebab-case"
],
-- "angular-whitespace": [true, "check-interpolation"],
"no-output-on-prefix": true,
"use-input-property-decorator": true,
"use-output-property-decorator": true,
"use-host-property-decorator": true,
"no-input-rename": true,
"no-output-rename": true,
"use-life-cycle-interface": true,
"use-pipe-transform-interface": true,
"component-class-suffix": true,
"directive-class-suffix": true
}
}
You can read more in this article.
To run prettier
you can add this script to package.json
to scripts
array: "prettier": "prettier --config ./.prettierrc --list-different \"src/**/*{.ts,.js,.json,.scss,.html}\""
.
Note: you may have to change src
to match the directory that you are using as a source directory.
To check for formatting violations run: yarn prettier
.
linting
To check for linting violations, run ng lint
.
To improve linting, add the following to the tsconfig.json
located in the project’s root:
"noUnusedLocals": true,
"noUnusedParameters": true,
git ignore
If you switched from using npm
to yarn
, it’s wise to delete package-lock.json
file that npm
generates, and add this file to .gitignore
:
package-lock.json
Final Steps
Finally, you may need to run yarn install
to install dependencies added to package.json
.


You attempt to beguile a humanoid that you can see within range. It must succeed on a W isdom saving throw or be charmed by you for the duration. If you or creatures that are friendly to you are fighting it, it has advantage on the saving throw.
While the target is charmed, you have a telepathic link with it as long as the two of you are on the same plane of existence. You can use this telepathic link to issue commands to the creature while you are conscious (no action required), which it does its best to obey. You can specify a simple and general course of action, such as “Attack that creature,” “Run over there,” or “Fetch that object.” If the creature completes the order and doesn't receive further direction from you, it defends and preserves itself to the best of its ability.
You can use your action to take total and precise control of the target. Until the end of your next turn, the creature takes only the actions you choose, and doesn't do anything that you don't allow it to do. During this time you can also cause the creature to use a reaction, but this requires you to use your own reaction as well.
Each time the target takes damage, it makes a new Wisdom saving throw against the spell. If the saving throw succeeds, the spell ends.
At Higher Levels. When you cast this spell using a 6th-level spell slot, the duration is concentration, up to 10 minutes. When you use a 7th-level spell slot, the duration is concentration, up to 1 hour. When you use a spell slot of 8th level or higher, the duration is concentration, up to 8 hours.


{% extends 'software_manager/my_obj_list.html' %} {% block buttons %} Upgrade Devices {% endblock %} {% block title %}Scheduled Tasks{% endblock %} {% block bulk_buttons %} Re-Schedule Tasks Delete Selected {% endblock %}


Originally, Ionia is an ancient geographic region where science was born. But for us, Ionia is a state of soul that is powered by the curiosity of what is next.
As a company, actually, we are just bunch of geeks who develops games in weekends.
Creating entertainment is not a job for us but the only way to entertain ourselves. Every smile that we cause, is our highest motivation.
Roll 'n Break is our first game. Available on both platforms!
Go to App Store Go to Google PlayWe are close friends those know each other for than ten years. But now, the only important factor is the mindset we have. We are open to anybody that has this mindset or want to have it.


Eneergy Predictions
Quisque volutpat condimentum velit. Class aptent taciti
2,250
- Diretary intake
- Motion
- Other
Power
260
2016.1.20
+12.5(2.8%)
35% Dietary intake
65% Motion capture
TOTAL POWER
4200
3600
Total
Power
720
2016.1.20
+120.5(5.0%)
70% Dietary intake
30% Motion capture
TOTAL POWER
6200
4400
Total
Overview of
Last year
- TYPE1
- TYPE2
- TYPE3
Summary of
Last month
35%
TYPE A
20%
TYPE B
45%
TYPE C
3650
views of your project
3650
views of your project
LAST YEAR
Today May 12 2016
651
12
74,206
Lifetime earnings
Server Status
Kernel Menmory
50%
Physical Memory
80%
SYSTEM STATUS
-
82
-
66
-
43
Last 30 days
Viwers
10,251,541
Sales
120,232,874
Sales Analysis
View
TOTAL
20,186
TODAY
36
WEEK
60
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Integer nec odio. Praesent
libero.
MARKET DOW
26,580.62
APPL
82.24
FB
12.06
GOOG
24.86
You have earned
21,451
Currently
227.34
Average
117.65
-
Mail AppRedesign project template227.34KB
-
CalendarRedesign project template128.62KB
YOUR TRAFFIC VIEWS
76
PC Browser
24
Mobile Phone
- PC BROWSER
- MOBILE PHONE
OVERALL VIEWS
432,852
2% higher than last month
MY BALANCE
12,346
NEW ORDERS
17,555