Programmer's Life

17.2 Advanced Function Options

2010-02-04T05:29:00.027-08:00

< Day Day Up >

17.2 Advanced Function Options

By now we've introduced you to

all

but one of Oracle's regular expression functions.

However, you've only seen them used in their

simplest form. Their full syntax is:

REGEXP_INSTR(source_string, expression 

            [, position [, occurrence

            [, return_option 

            [, match_parameter]]]])



REGEXP_LIKE (source_string, expression 

            [, match_parameter])



REGEXP_REPLACE(source_string, expression

              [, replace_string

              [, position [, occurrence

              [, match_parameter]]]])



REGEXP_SUBSTR(source_string, expression

             [, position [, occurrence

             [, match_parameter]]])

If you're familiar with Oracle's

string-manipulation functions, you'll have no

trouble discerning the purpose of the

REGEXP

functions:

REGEXP_INSTR: Returns the character position at which text can be found matching a

regular expression in a target string.
REGEXP_LIKE: Discerns whether a given string contains text matching an expression.

This is a Boolean function, returning TRUE or FALSE, or NULL.
REGEXP_REPLACE: Performs a regular expression search-and-replace operation, which

you'll learn about in Section 17.3.
REGEXP_SUBSTR: Extracts text matching a regular expression from a string.

The parameters to these functions are as follows:

source_string: The string to be searched.
expression: A regular expression describing the pattern of text that you seek.
replace_string: A string generating the replacement text to be used in a

search-and-replace operation.
position: The character position within

source_string at which to begin a search.

This defaults to 1.
occurrence: The occurrence of the pattern you wish to locate. This defaults to 1,

giving you the first possible match.
return_option: Valid only for REGEXP_INSTR, and determines whether the beginning or

ending character position is returned for text matching a pattern.

The default is 0, for the beginning. Use 1 to return the ending

position.
match_parameter: A text string through which you may specify options to vary the

behavior of the regular expression matching engine.

The match_parameter deserves a bit of explanation.

It's a character string that you build using one or

more of the following letters: i,

c, n, m. One

use is to specify whether matching is case-sensitive. By default,

your NLS_SORT setting drives this aspect of regular expression

behavior. You can override that default on a call-by-call basis,

using i to get case-insensitive matching, and

c to get case-sensitive matching. Following is a

simple demonstration that works with our example data set. When the

i option is used, the match succeeds, even though

the case really does not match:

SELECT emp_id, text

FROM employee_comment

WHERE REGEXP_LIKE(text, 'CEDAR LAKE', 'c');



no rows selected



SELECT emp_id, text

FROM employee_comment

WHERE REGEXP_LIKE(text, 'CEDAR LAKE', 'i');



    EMP_ID TEXT

---------- ---------------------------------------------

      7499 1105 McConnell Court

           Cedar Lake MI 48812

           Home: (989) 387-4321

           Cell: (237) 438-3333

      7782 Academy Apartments, #138, Cedar Lake MI 48812

      7788 #1 Water Tower Lane

           Cedar Lake MI 48812

The n option is useful when working with data,

such as ours, that contains embedded newline (usually

chr(10)) characters. By default, the period

(.) does not match newlines, which is why the

following query brings back only the first line of comment text:

SELECT emp_id, REGEXP_SUBSTR(text, '.*') text

FROM employee_comment

WHERE emp_id = 7698;



    EMP_ID TEXT

---------- ---------------

      7698 Marion Blake

Using 'n' for the match parameter, you can have

the period match newlines, which in the case of this query, results

in the entire comment being returned:

SELECT emp_id, REGEXP_SUBSTR(text, '.*', 1, 1, 'n') text

FROM employee_comment

WHERE emp_id = 7698;



    EMP_ID TEXT

---------- -----------------------

      7698 Marion Blake

           N1375 Lakeshore Drive

           Vestaburg MI 48891

           (989) 388-1234

This example also illustrates the important point that specifying a

match parameter forces you to also specify any preceding, optional

parameters that you would otherwise skip.

The final match option is m, which changes the

definition of line

with respect to the ^ and $

metacharacters. By default, line means the entire target

string, so an expression such as ^.*$,

together with the n option, will bring back all

characters in the target string:

SELECT emp_id, REGEXP_SUBSTR(text, '^.*$', 1, 1, 'n') text

FROM employee_comment

WHERE emp_id = 7788;



    EMP_ID TEXT

---------- --------------------

      7788 #1 Water Tower Lane

           Cedar Lake MI 48812

The

n option is necessary here, because otherwise the

period would not match the newline. If the period did not match the

newline, the expression would fail to match at that point, and it

would be impossible to match all characters between the beginning and

end of the string.

However, using the m option causes the definition

of line to change from the entire target string,

to any line within that string, where lines are

delimited by newline characters. The following example removes

n, replacing it with m:

SELECT emp_id, REGEXP_SUBSTR(text, '^.*$', 1, 1, 'm') text

FROM employee_comment

WHERE emp_id = 7788;



    EMP_ID TEXT

---------- --------------------

      7788 #1 Water Tower Lane

You can specify multiple match parameters in any order. For example,

'in' means the same as 'ni'. If

you specify

conflicting options, such as

'ic', the last option, 'c' in

this case, is the one that takes precedence.

Try our last example in this section using 'mn' as

the match parameter string. You'll get back the

entire target string. Why? Because of the greediness rule. When

'mn' is used, the first line is a match, but the

entire string is a longer match.

< Day Day Up >

Acknowledgments

2010-02-04T05:29:00.025-08:00

Ru-Brd

Acknowledgments

I'd like to thank my family, whom I bribed with four-wheelers with the advance money, in order to make losing a lot of Mom's time and attention worth it to them too. I especially want to thank my oldest daughter, Jennifer, for learning to make SpaghettiOs and hot dogs for herself and her sister so that Mommy could work on her book. I'd like to thank my youngest daughter, Jessica, for not letting me forget who is most important. And finally, I'd like to thank my husband, Ken, who really didn't understand why I needed to write this book but put up with it, and the never-ending crunching schedules, anyway … even when it didn't seem worth the four-wheelers anymore.

Thanks also to my manager and my friend, Carolyn Ruby, who made this book part of "my job" and has always been so supportive in helping me achieve my goals and find my killer instinct. Thanks to Janet Farrell and Vera Plechash, my cheerleaders. Thanks to Ward Harold for catching the JMX vision and for buddying up with me so that I could see my name in print. Thanks to Leigh for championing JMX in WebSphere and the JCP. And finally, thanks to Shelley Kronzek for continuing to nag until we were doing something we really wanted to do in the first place and for being the mediator between us technical chickens and the big scary publishing world.

� Heather Kreger

Wow, I'm writing acknowledgements. That must mean this project is almost complete. Saints be praised! Thanks to St. Heather for introducing me to JMX and, especially, for handling all the "lead author" administration chores. Our editor, St. Shelley Kronzek, persevered with us on this project through a series of trying circumstances and still bought us dinner in San Francisco. Thanks for your patience and dedication, Shelley.

Although I got to write the book, there is a fantastic group of people in Rome, Italy, who did most of the hard work of bringing JMX to life within Tivoli as TMX4J. To Kenneth Barron, Alfredo Cappariello, Raimondo Castino, Eliseba Costantini, Marco de Gregorio, Paola Diomede, Roberto Longobardi, Attilio Mattiocco, Marco Melillo, Alessio Menale, Chiara Montecchio, Massimiliano (Max) Parlione, Maurizio Simeoni, Massimo Tarquini, and Cosimo (Mimmo) Vampo, mille grazie ragazzi! My heartfelt thanks also go to Cesare Giuliani, the best development manager I've ever worked with, for turning my fuzzy musings into working code and never complaining when I didn't come back from Sabaudia when I said I would, and to Maurizio Piatti, who is simply my favorite Italian.

Finally, special thanks to my wife Diana and our kids Matthew, Aaron, and Kelly Rose for putting up with the constant presence of Daddy's laptop and the absence of his homemade bread for all these months. You guys make it all worthwhile.

� Ward Harold

I would like to thank my wife and daughter, Cheryl and Claire, for their patience and support. You are my compass and my light. I would also like to thank my coauthors, Heather and Ward, for their continued support and enthusiasm. Thanks go to all of the members of the JSR 77 expert group who worked so hard to produce the specification. Thanks to the management at IBM, Michelle Swenson and Diane Copenhaver, for encouragement and resources. And I would also like to thank the folks at Addison-Wesley, Shelley and all of the reviewers, for their excellent comments and suggestions.

� Leigh Williamson

Ru-Brd

11.5 Collection of Issues for Beyond Version 1.1

2010-02-04T05:29:00.023-08:00

[ Team LiB ]

11.5 Collection of Issues for Beyond Version 1.1

The public review period for CMMI version 0.2 in 1999 resulted in about 2,500 change requests to the model and the "books" that represent the model. Of these requests, approximately 400 were classified as "minor" and 500 were considered "global" (affecting several process areas or other elements). The remaining change requests were classified as being "local" to the individual model elements. For several of the change requests in the global and local categories, the CMMI Team lacked sufficient time to deal with them properly. Instead, they were placed on a list of potentially good ideas warranting more exploration.

The use of version 1.0 resulted in many more change requests to the model components. The CMMI Team used the same process to deal with the large number of changes requested, and as happened prior to version 1.0's release, version 1.1 does not address all of the potentially good ideas from the reviewers. In this section, we discuss a few of the other major open issues�that is, issues deferred for consideration to after version 1.1.

11.5.1 Advanced Practices

The implementation of advanced practices remains an issue. Version 1.1 allows advanced practices in the Engineering category but not in the other process area categories. For the future, we would expect that as the model is used, one of two things would occur. First, process improvement in the Engineering process areas might be aided by the presence of advanced practices, prompting users of this model to seek the expansion of this concept across the entire model.

Second, the value that advanced practices may have for process improvement might be viewed as insufficient to justify the architectural complexity they introduce, prompting model users to ask for their elimination across the entire model. The decision within the CMMI Team to put them into the initial model releases in a limited way was intended to lay the foundation for feedback either in favor of or opposed to advanced practices, as the team could not reach a consensus view. This disagreement was a part of the debate between proponents of staged versus continuous architectures.

11.5.2 Generic Attributes

EIA 731 contains generic attributes, an aspect of process improvement that is not included in any other source model. Generic attributes address the effectiveness of the process and the value of the work products produced by it. Proponents of generic attributes on the CMMI Team generated a proposal for CMMI generic attributes by making changes to improve the objectivity of the generic attributes in EIA 731. In the end, however, that proposal was not adopted.

Generic attributes add a significant aspect to process improvement that is not addressed by the capability dimension or the process dimension: How effective are the processes in your environment, and do they produce work products that the stakeholders find valuable? Some organizations have developed the ability to evaluate this process-improvement dimension by adopting the Lean initiative. For CMMI, the question remains: Would the inclusion of generic attributes in a CMMI appraisal be of sufficient value, given the issue of their objectivity?

11.5.3 Relationship to Other Process Areas

CMMI version 1.1 includes a section in each process area titled "Related Process Areas," which contains (not surprisingly) references to other process areas. A recommendation was made and accepted by the CMMI Team (but not implemented in version 1.1) to change the title of this section to "Relationships with Other Process Areas," and to make its content more meaningful.^[7]

^[7] An earlier version of CMMI (predating version 1.0) used two levels of reference: the currently used "informative" reference and a stronger reference. The stronger reference invoked another process area, stating "Use the x process areas to achieve y." The application of the "Use" reference was not consistent across the model, confused model users, and raised issues in the area of appraisal. It was not clear exactly what was implied by the stronger relationship between process areas. Given the many calls to reduce the model's complexity and of the time to adequately study the issue, the stronger reference was eliminated in version 1.0. Whether anyone will make the case to revive multiple forms of reference in CMMI remains to be seen.

The needs related to this issue are as follows:

Model users need to understand the high-level (key) relationships between process areas.
Those who develop CMMI training materials need a mechanism to generate a high-level diagram to show relationships between process areas.
Model users need to understand the difference between references at different levels (components) of the model.

The following guidelines were defined to restrict the use of the initial reference section in each process area to key process area interfaces:

Change the title of "Related Process Areas" to "Relationships with Other Process Areas."
Use the "Reference" architectural component but change the structure of the reference, in this section only, to an active statement of the relationship with other process areas.
Allow one to three sentences for each relationship description.
Include only the key relationships (that is, what the user needs to see at a high level).
Retain the normal references in the model from other components.
Generate a view in the Product Suite Repository that shows these relationships.

The CMMI Product Team has recommended such a change for each process area as a part of the next release of CMMI.

Example Update to Relationships Section

The following example is a proposed update to the Technical Solution process area:

Relationship with Other Process Areas

The Requirements Development process area provides product-component requirements to this process area so that alternative solutions can be developed.

The Requirements Development process area receives technical solutions, selected from the alternatives, to refine the product-component requirements.

The Work Product Verification process area verifies that the product components meet their requirements. As verification issues are identified, the design may need to change. This is an iterative process and occurs throughout the development of the product.

The Decision Analysis and Resolution process area provides structured decision-making practices that are used in selecting a technical solution from the alternative solutions.

The Product Integration process area receives the product components following their implementation.

The Product Integration process area provides integration test deficiencies to this process area for corrective action.

The Validation process area provides validation deficiencies to this process area for corrective action.

The Supplier Agreement Management process area handles the acquisition of all product components once the purchase decision is made in this process area.

[ Team LiB ]

Section 3.8. Objects

2010-02-04T05:29:00.021-08:00

3.8. Objects

Ruby is a very pure object-oriented language: all values are
objects, and there is no distinction between primitive types and object types as there are in many other
languages. In Ruby, all objects inherit from a class named
Object and share the methods defined by that class.
This section explains the common features of all objects in Ruby. It is
dense in parts, but it's required reading; the information here is
fundamental.

3.8.1. Object References

When we work with objects in Ruby, we are really working with
object references. It is not the
object itself we manipulate but a reference to it.^[*] When we assign a value to a variable, we are not copying an object "into" that variable; we are
merely storing a reference to an object into that variable. Some code
makes this clear:

^[*] If you are familiar with C or C++, you can think of a
reference as a pointer: the address of the object in memory. Ruby
does not use pointers, however. References in Ruby are opaque and
internal to the implementation. There is no way to take the address
of a value, dereference a value, or do pointer arithmetic.

Code View:

s = "Ruby" # Create a String object. Store a reference to it in s.
t = s      # Copy the reference to t. s and t both refer to the same object.
t[-1] = "" # Modify the object through the reference in t.
print s    # Access the modified object through s. Prints "Rub". 
t = "Java" # t now refers to a different object.
print s,t  # Prints "RubJava".

When you pass an object to a method in Ruby, it is an object
reference that is passed to the method. It is not the object itself, and
it is not a reference to the reference to the object. Another way to say
this is that method arguments are passed by value
rather than by reference, but that the values
passed are object references.

Because object references are passed to methods, methods can use
those references to modify the underlying object. These modifications
are then visible when the method returns.

3.8.1.1. Immediate values

We've said that all values in Ruby are objects and all objects
are manipulated by reference. In the reference implementation,
however, Fixnum and Symbol
objects are actually "immediate values" rather than references.
Neither of these classes have mutator methods, so
Fixnum and Symbol objects are
immutable, which means that there is really no way to tell that they
are manipulated by value rather than by reference.

The existence of immediate values should be considered an
implementation detail. The only practical difference between immediate
values and reference values is that immediate values cannot have
singleton methods defined on them. (Singleton methods
are explained in Section 6.1.4.)

3.8.2. Object Lifetime

The built-in Ruby classes described in this chapter have literal
syntaxes, and instances of these classes are created simply by including
their values literally in your code. Objects of other classes need to be
explicitly created, and this is most often done with a method named new:

myObject = myClass.new

new is a method of the Class
class. It allocates memory to hold the new object, then it initializes
the state of that newly allocated "empty" object by invoking its
initialize method. The arguments to new are passed
directly on to initialize. Most classes define an
initialize method to perform whatever initialization
is necessary for instances.

The new and initialize
methods provide the default technique for creating new classes, but
classes may also define other methods, known as "factory methods," that
return instances. We'll learn more about new,
initialize, and factory methods in Section 7.4.

Ruby objects never need to be explicitly deallocated, as they do
in languages like C and C++. Ruby uses a technique called
garbage collection to automatically destroy objects that are no longer needed.
An object becomes a candidate for garbage collection when it is
unreachable—when there are no remaining references to the object
except from other unreachable objects.

The fact that Ruby uses garbage collection means that Ruby
programs are less susceptible to memory leaks than programs written in
languages that require objects and memory to be explicitly deallocated
and freed. But garbage collection does not mean that memory leaks are
impossible: any code that creates long-lived references to objects that
would otherwise be short-lived can be a source of memory leaks. Consider
a hash used as a cache. If the cache is not pruned using some kind of
least-recently-used algorithm,
then cached objects will remain reachable as long as the hash itself is
reachable. If the hash is referenced through a global variable, then it
will be reachable as long as the Ruby interpreter is running.

3.8.3. Object Identity

Every object has an object identifier, a Fixnum, that you can obtain with the object_id
method. The value returned by this method is constant and unique for the
lifetime of the object. While the object is accessible, it will always
have the same ID, and no other object will share that ID.

The method id is a deprecated synonym for object_id. Ruby 1.8
issues a warning if you use it, and it has been removed in Ruby
1.9.

__id__ is a valid synonym for
object_id. It exists as a fallback, so you can access
an object's ID even if the object_id method has been
undefined or overridden.

The Object class implements the
hash method to simply return an object's ID.

3.8.4. Object Class and Object Type

There are several ways to determine the class of an object in Ruby. The simplest is
simply to ask for it:

o = "test"  # This is a value
o.class     # Returns an object representing the String class

If you are interested in the class hierarchy of an object, you can
ask any class what its superclass is:

o.class                       # String: o is a String object
o.class.superclass            # Object: superclass of String is Object
o.class.superclass.superclass # nil: Object has no superclass

In Ruby 1.9, Object is no longer the true root
of the class hierarchy:

# Ruby 1.9 only
Object.superclass             # BasicObject: Object has a superclass in 1.9
BasicObject.superclass        # nil: BasicObject has no superclass

See Section 7.3 for more on
BasicObject.

So a particularly straightforward way to check the class of an
object is by direct comparison:

o.class == String       # true if is o a String

The instance_of? method does the same thing and is a little more elegant:

o.instance_of? String   # true if o is a String

Usually when we test the class of an object, we would also like to
know if the object is an instance of any subclass of that class. To test
this, use the is_a? method, or its synonym kind_of?:

x = 1                    # This is the value we're working with
x.instance_of? Fixnum    # true: is an instance of Fixnum
x.instance_of? Numeric   # false: instance_of? doesn't check inheritance
x.is_a? Fixnum           # true: x is a Fixnum
x.is_a? Integer          # true: x is an Integer
x.is_a? Numeric          # true: x is a Numeric
x.is_a? Comparable       # true: works with mixin modules, too
x.is_a? Object           # true for any value of x

The Class class defines the === operator in such a way that it
can be used in place of is_a?:

Numeric === x            # true: x is_a Numeric

This idiom is unique to Ruby and is probably less readable than
using the more traditional
is_a? method.

Every object has a well-defined class in Ruby, and that class
never changes during the lifetime of the object. An object's
type, on the other hand, is more fluid. The type of
an object is related to its class, but the class is only part of an
object's type. When we talk about the type of an object, we mean the set
of behaviors that characterize the object. Another way to put it is that
the type of an object is the set of methods it can respond to. (This
definition becomes recursive because it is not just the name of the
methods that matter, but also the types of arguments that those methods
can accept.)

In Ruby programming, we often don't care about the class of an
object, we just want to know whether we can invoke some method on it.
Consider, for example, the << operator. Arrays,
strings, files, and other I/O-related classes define this as an append
operator. If we are writing a method that produces textual output, we
might write it generically to use this operator. Then our method can be
invoked with any argument that implements <<.
We don't care about the class of the argument, just that we can append
to it. We can test for this with the respond_to?
method:

o.respond_to? :"<<"  # true if o has an << operator

The shortcoming of this approach is that it only checks the name
of a method, not the arguments for that method. For example,
Fixnum and Bignum implement
<< as a left-shift operator and expect the
argument to be a number instead of a string. Integer objects appear to
be "appendable" when we use a respond_to? test,
but they produce an error when our code appends a string.
There is no general solution to this problem, but an ad-hoc remedy, in
this case, is to explicitly rule out Numeric objects
with the is_a? method:

o.respond_to? :"<<" and not o.is_a? Numeric

Another example of the type-versus-class distinction is
the StringIO class (from Ruby's standard
library). StringIO enables reading from and writing
to string objects as if they were IO objects.
StringIO mimics the IO
API—StringIO objects define the same methods that
IO objects do. But StringIO is not
a subclass of IO. If you write a method that expects
a stream argument, and test the class of the argument with
is_a? IO, then your method won't work with
StringIO arguments.

Focusing on types rather than classes leads to a programming style
known in Ruby as "duck typing." We'll see duck typing examples in Chapter 7.

3.8.5. Object Equality

Ruby has a surprising number of ways to compare objects for
equality, and it is important to
understand how they work, so you know when to use each method.

3.8.5.1. The equal? method

The equal? method is defined by Object to test whether two values
refer to exactly the same object. For any two distinct objects, this
method always returns false:

a = "Ruby"       # One reference to one String object
b = c = "Ruby"   # Two references to another String object
a.equal?(b)      # false: a and b are different objects
b.equal?(c)      # true: b and c refer to the same object

By convention, subclasses never override the
equal? method.

Another way to determine if two objects are, in fact, the same
object is to check their object_id:

a.object_id == b.object_id   # Works like a.equal?(b)

3.8.5.2. The == operator

The == operator is the most common way to test for equality. In the
Object class, it is simply a synonym for
equal?, and it tests whether two object references
are identical. Most classes redefine this operator to allow distinct
instances to be tested for equality:

a = "Ruby"    # One String object
b = "Ruby"    # A different String object with the same content
a.equal?(b)   # false: a and b do not refer to the same object
a == b        # true: but these two distinct objects have equal values

Note that the single equals sign in this code is the assignment
operator. It takes two equals signs to test for equality in Ruby (this
is a convention that Ruby shares with many other programming
languages).

Most standard Ruby classes define the ==
operator to implement a reasonable definition of equality. This
includes the Array and Hash
classes. Two arrays are equal according to == if
they have the same number of elements, and if their corresponding
elements are all equal according to ==. Two hashes
are == if they contain the same number of key/value
pairs, and if the keys and values are themselves equal. (Values are
compared with the == operator, but hash keys are
compared with the eql? method, described later in
this chapter.)

Equality for Java Programmers

If you are a Java programmer, you are used to using the
== operator to test if two objects are the same
object, and you are used to using the equals
method to test whether two distinct objects have the same value.
Ruby's convention is just about the opposite of Java's.

The Numeric classes perform simple type conversions in their
== operators, so that (for example) the
Fixnum 1 and the
Float 1.0 compare as equal. The
== operator of classes, such as
String and Array, normally
requires both operands to be of the same class. If the righthand
operand defines a to_str or
to_ary conversion function (see Section 3.8.7), then these operators invoke the
== operator defined by the righthand operand, and
let that object decide whether it is equal to the lefthand string or
array. Thus, it is possible (though not common) to define classes with
string-like or array-like comparison behavior.

!= ("not-equal") is used in Ruby to test for inequality. When Ruby sees
!=, it simply uses the ==
operator and then inverts the result. This means that a class only
needs to define the == operator to define its own
notion of equality. Ruby gives you the != operator
for free. In Ruby 1.9, however, classes can explicitly define their
own != operators.

3.8.5.3. The eql? method

The eql? method is defined by Object as a synonym for
equal?. Classes that override it typically use it
as a strict version of == that does no type
conversion. For example:

1 == 1.0    # true: Fixnum and Float objects can be ==
1.eql?(1.0) # false: but they are never eql!

The Hash class uses eql? to check whether two hash
keys are equal. If two objects are eql?, their
hash methods must also return the same value.
Typically, if you create a class and define the ==
operator, you can simply write a hash method and
define eql? to use ==.

3.8.5.4. The === operator

The === operator is commonly called the "case equality" operator and is
used to test whether the target value of a case
statement matches any of the when clauses of that
statement. (The case statement is a multiway branch
and is explained in Chapter 5.)

Object defines a default
=== operator so that it invokes the
== operator. For many classes, therefore, case
equality is the same as == equality. But certain
key classes define === differently, and in these
cases it is more of a membership or matching operator.
Range defines === to test
whether a value falls within the range. Regexp
defines === to test whether a string matches the
regular expression. And Class defines
=== to test whether an object is an instance of
that class. In Ruby 1.9, Symbol defines
=== to return true if the
righthand operand is the same symbol as the left or if it is a string
holding the same text. Examples:

(1..10) === 5    # true: 5 is in the range 1..10
/\d+/ === "123"  # true: the string matches the regular expression
String === "s"   # true: "s" is an instance of the class String
:s === "s"       # true in Ruby 1.9

It is uncommon to see the === operator used
explicitly like this. More commonly, its use is simply implicit in a
case statement.

3.8.5.5. The =~ operator

The =~ operator is defined by String and
Regexp (and Symbol in Ruby 1.9)
to perform pattern matching, and it isn't really an
equality operator at all. But it does have an equals sign in it, so it
is listed here for completeness. Object defines a
no-op version of =~ that always returns
false. You can define this operator in your own
class, if that class defines some kind of pattern-matching operation
or has a notion of approximate equality, for example.
!~ is defined as the inverse of
=~. It is definable in Ruby 1.9 but not in Ruby
1.8.

3.8.6. Object Order

Practically every class can define a useful
== method for testing its instances for equality.
Some classes can also define an ordering. That is: for any two instances
of such a class, the two instances must be equal, or one instance must
be "less than" the other. Numbers are the most obvious classes for which
such an ordering is defined. Strings are also ordered, according to the
numeric ordering of the character codes that comprise the strings. (With
the ASCII text, this is a rough kind of case-sensitive alphabetical
order.) If a class defines an ordering, then instances of the class can
be compared and sorted.

In Ruby, classes define an ordering by implementing the <=> operator. This operator
should return –1 if its left operand is less than its
right operand, 0 if the two operands are equal, and
1 if the left operand is greater than the right
operand. If the two operands cannot be meaningfully compared (if the
right operand is of a different class, for example), then the operator should return
nil:

1 <=> 5     # -1
5 <=> 5     # 0
9 <=> 5     # 1
"1" <=> 5   # nil: integers and strings are not comparable

The <=> operator is all that is needed to
compare values. But it isn't particularly intuitive. So classes that
define this operator typically also include the
Comparable module as a mixin. (Modules and mixins are covered in Section 7.5.2.) The Comparable mixin defines
the following operators in terms of <=>:

`<`	Less than
`<=`	Less than or equal
`==`	Equal
`>=`	Greater than or equal
`>`	Greater than

Comparable does not define the
!= operator; Ruby automatically defines that operator as the negation
of the == operator. In addition to these comparison
operators, Comparable also
defines a useful comparison method named
between?:

1.between?(0,10)  # true: 0 <= 1 <= 10

If the <=> operator returns
nil, all the comparison operators derived from it return
false. The special Float value
NaN is an example:

nan = 0.0/0.0;     # zero divided by zero is not-a-number
nan < 0            # false: it is not less than zero
nan > 0            # false: it is not greater than zero
nan == 0           # false: it is not equal to zero
nan == nan         # false: it is not even equal to itself!
nan.equal?(nan)    # this is true, of course

Note that defining <=> and including the
Comparable module defines a ==
operator for your class. Some classes define their own
== operator, typically when they can implement this
more efficiently than an equality test based on
<=>. It is possible to define classes that
implement different notions of equality in their ==
and <=> operators. A class might do
case-sensitive string comparisons for the ==
operator, for example, but then do case-insensitive comparisons for
<=>, so that instances of the class would sort
more naturally. In general, though, it is best if
<=> returns 0 if and only if
== returns true.

3.8.7. Object Conversion

Many Ruby classes define methods that return a representation
of the object as a value of a different class. The
to_s method, for obtaining a String representation
of an object, is probably the most commonly implemented and best known
of these methods. The subsections that follow describe various
categories of conversions.

3.8.7.1. Explicit conversions

Classes define explicit conversion methods for use by application code
that needs to convert a value to another representation. The most
common methods in this category are to_s,
to_i, to_f, and
to_a to convert to String,
Integer, Float, and
Array, respectively.

Built-in methods do not typically invoke these methods for you.
If you invoke a method that expects a String and
pass an object of some other kind, that method is not expected to
convert the argument with to_s. (Values
interpolated into double-quoted strings, however, are automatically
converted with to_s.)

to_s is easily the most important of the
conversion methods because string representations of objects are so
commonly used in user interfaces. An important alternative to
to_s is the inspect method.
to_s is generally intended to return a
human-readable representation of the object, suitable for end users.
inspect, on the other hand, is intended for
debugging use, and should return a representation that is helpful to
Ruby developers. The default inspect method,
inherited from Object, simply calls
to_s.

3.8.7.2. Implicit conversions

Sometimes a class has strong characteristics of some other class.
The Ruby Exception class represents an error or
unexpected condition in a program and encapsulates an error message.
In Ruby 1.8, Exception objects are not
merely convertible to strings; they are string-like objects and can be
treated as if they were strings in many contexts.^[*] For example:

^[*] Doing so is discouraged, however, and Ruby 1.9 no longer
allows the implicit conversion of Exception to
String.

# Ruby 1.8 only
e = Exception.new("not really an exception")
msg = "Error: " + e  # String concatenation with an Exception

Because Exception objects are string-like, they can be used with the string
concatenation operator. This does not work with most other Ruby
classes. The reason that Exception objects can behave like
String objects is that, in Ruby 1.8,
Exception implements the implicit conversion method
to_str, and the + operator
defined by String invokes this method on its
righthand operand.

Other implicit conversion methods are to_int
for objects that want to be integer-like, to_ary for objects that want to be
array-like, and to_hash for objects that want to be
hash-like. Unfortunately, the circumstances under which these implicit
conversion methods are called are not well documented. Among the
built-in classes, these implicit conversion methods are not commonly
implemented, either.

We noted earlier in passing that the ==
operator can perform a weak kind of type conversion when testing for
equality. The == operators defined by
String, Array, and
Hash check to see if the righthand operand is of
the same class as the lefthand operand. If so, they compare them. If
not, they check to see if the righthand operand has a
to_str, to_ary, or
to_hash method. They don't invoke this method, but
if it exists, they invoke the == method of the
righthand operand and allow it to decide whether it is equal to the
lefthand operand.

In Ruby 1.9, the built-in classes String,
Array, Hash,
Regexp, and IO all define a
class method named try_convert. These methods
convert their argument if it defines an appropriate implicit
conversion method, or they return nil otherwise.
Array.try_convert(o) returns
o.to_ary if o defines that
method; otherwise, it returns nil. These try_convert methods are convenient if you want to
write methods that allow implicit conversions on their
arguments.

3.8.7.3. Conversion functions

The Kernel module defines four conversion methods that behave as global
conversion functions. These functions—Array,
Float, Integer, and
String—have the same names as the classes that they
convert to, and they are unusual in that they begin with a capital
letter.

The Array function attempts to convert its argument to an array by calling
to_ary. If that method is not defined or returns
nil, it tries the to_a method.
If to_a is not defined or returns
nil, the Array function simply
returns a new array containing the argument as its single
element.

The Float function converts Numeric arguments to
Float objects directly. For any
non-Numeric value, it calls the
to_f method.

The Integer function converts its argument to a Fixnum or
Bignum. If the argument is a
Numeric value, it is converted directly.
Floating-point values are truncated rather than rounded. If the
argument is a string, it looks for a radix indicator (a leading
0 for octal, 0x for hexadecimal,
or 0b for binary) and converts the string
accordingly. Unlike String.to_i it does not allow
nonnumeric trailing characters. For any other kind of argument, the
Integer function first attempts conversion with
to_int and then with
to_i.

Finally, the String function converts its
argument to a string simply by calling its to_s
method.

3.8.7.4. Arithmetic operator type coercions

Numeric types define a conversion method named coerce. The intent of this
method is to convert the argument to the same type as the numeric
object on which the method is invoked, or to convert both objects to
some more general compatible type. The coerce
method always returns an array that holds two numeric values of the
same type. The first element of the array is the converted value of
the argument to coerce. The second element of the
returned array is the value (converted, if necessary) on which
coerce was invoked:

1.1.coerce(1)      # [1.0, 1.1]: coerce Fixnum to Float
require "rational" # Use Rational numbers
r = Rational(1,3)  # One third as a Rational number
r.coerce(2)        # [Rational(2,1), Rational(1,3)]: Fixnum to Rational

The coerce method is used by the arithmetic
operators. The + operator defined by Fixnum doesn't know about
Rational numbers, for example, and if its righthand
operand is a Rational value, it doesn't know how to
add it. coerce provides the solution. Numeric
operators are written so that if they don't know the type of the
righthand operand, they invoke the coerce method of
the righthand operand, passing the lefthand operand as an argument.
Returning to our example of adding a Fixnum and a
Rational, the coerce method of
Rational returns an array of two
Rational values. Now the +
operator defined by Fixnum can simply invoke
+ on the values in the array.

3.8.7.5. Boolean type conversions

Boolean values deserve a special mention in the context of type conversion. Ruby is very strict with its
Boolean values: true and false
have to_s methods, which return "true" and "false" but define no other
conversion methods. And there is no to_b method to
convert other values to Booleans.

In some languages, false is the same thing as
0, or can be converted to and from
0. In Ruby, the values true and
false are their own distinct objects, and there are
no implicit conversions that convert other values to
true or false. This is only half
the story, however. Ruby's Boolean operators and its conditional and
looping constructs that use Boolean expressions can work with values
other than true and false. The
rule is simple: in Boolean expressions, any value other than
false or nil behaves like (but
is not converted to)
true. nil, on the other hand
behaves like false.

Suppose you want to test whether the variable
x is nil or not. In some
languages, you must explicitly write a comparison expression that
evaluates to true or
false:

if x != nil   # Expression "x != nil" returns true or false to the if
  puts x      # Print x if it is defined
end

This code works in Ruby, but it is more common simply to take
advantage of the fact that all values other than
nil and false behave like
true:

if x       # If x is non-nil
  puts x   # Then print it
end

It is important to remember that values like
0, 0.0, and the empty string
"" behave like true in Ruby,
which is surprising if you are used to languages like C or
JavaScript.

3.8.8. Copying Objects

The Object class defines two closely
related methods for copying objects. Both clone and
dup return a shallow copy of the object on which they
are invoked. If the copied object includes one internal state that
refers to other objects, only the object references are copied, not the
referenced objects themselves.

If the object being copied defines an
initialize_copy method, then clone and dup
simply allocate a new, empty instance of the class and invoke the
initialize_copy method on this empty instance. The
object to be copied is passed as an argument, and this "copy
constructor" can initialize the copy however it desires. For example,
the initialize_copy method could
recursively copy the internal data of an object so that the resulting
object is not a simple shallow copy of the original.

Classes can also override the clone and
dup methods directly to produce any kind of copy they
desire.

There are two important differences between the
clone and dup methods defined by
Object. First, clone copies both
the frozen and tainted state (defined shortly) of an object, whereas
dup only copies the tainted state; calling
dup on a frozen object returns an unfrozen copy.
Second, clone copies any singleton methods of the
object, whereas dup does not.

3.8.9. Marshaling Objects

You can save the state of an object by passing it to the class method
Marshal.dump.^[*] If you pass an I/O stream object as the second argument,
Marshal.dump writes the state of the object (and,
recursively, any objects it references) to that stream. Otherwise, it
simply returns the encoded state as a binary string.

^[*] The word "marshal" and its variants are sometimes spelled with
two ls: marshall, marshalled, etc. If you spell the word this way,
you'll need to remember that the name of the Ruby class has only a
single l.

To restore a marshaled object, pass a string or an I/O stream
containing the object to Marshal.load.

Marshaling an object is a very simple way to save its state for
later use, and these methods can be used to provide an automatic file
format for Ruby programs. Note, however, that the binary format used by
Marshal.dump and Marshal.load is
version-dependent, and newer versions of Ruby are not guaranteed to be
able to read marshaled objects written by older versions of Ruby.

Another use for Marshal.dump and
Marshal.load is to create deep copies of objects:

def deepcopy(o)
  Marshal.load(Marshal.dump(o))
end

Note that files and I/O streams, as well as
Method and Binding objects, are
too dynamic to be marshaled; there would be no reliable way to restore
their state.

YAML ("YAML Ain't Markup Language") is a commonly used alternative to the Marshal module that dumps objects to (and
loads objects from) a human-readable text format. It is in the standard
library, and you must require 'yaml' to use
it.

3.8.10. Freezing Objects

Any object may be frozen by calling its freeze method. A frozen object
becomes immutable—none of its
internal state may be changed, and an attempt to call any of its mutator
methods fails:

s = "ice"      # Strings are mutable objects
s.freeze       # Make this string immutable
s.frozen?      # true: it has been frozen
s.upcase!      # TypeError: can't modify frozen string
s[0] = "ni"    # TypeError: can't modify frozen string

Freezing a class object prevents the addition of any methods to
that class.

You can check whether an object is frozen with the
frozen? method. Once frozen, there is no way
to "thaw" an object. If you copy a frozen object with
clone, the copy will also be frozen. If you copy a
frozen object with dup, however, the copy will not be
frozen.

3.8.11. Tainting Objects

Web applications must often keep track of data derived from untrusted user
input to avoid SQL injection attacks and similar security risks. Ruby
provides a simple solution to this problem: any object may be marked as
tainted by calling its taint method. Once an object
is tainted, any objects derived from it will also be tainted. The taint
of an object can be tested with the tainted? method:

s = "untrusted"   # Objects are normally untainted
s.taint           # Mark this untrusted object as tainted
s.tainted?        # true: it is tainted
s.upcase.tainted? # true: derived objects are tainted
s[3,4].tainted?   # true: substrings are tainted

User input—such as command-line arguments, environment variables,
and strings read with gets—are automatically
tainted.

Copies of tainted objects made with clone and
dup remain tainted. A tainted object may be untainted
with the untaint method. You should only do this, of
course, if you have examined the object and are convinced that it
presents no security risks.

The object tainting mechanism of Ruby is most powerful when used
with the global variable $SAFE. When this variable is
set to a value greater than zero, Ruby restricts various built-in
methods so that they will not work with tainted data. See Chapter 10 for further details on the $SAFE
variable.

Specific Practices by Goal

2010-02-04T05:29:00.019-08:00

[ Team LiB ]

Specific Practices by Goal

SG 1 Provide IPPD Infrastructure

An infrastructure that maximizes the productivity of people and affects the collaboration necessary for integration is provided.

An organizational infrastructure that supports and promotes IPPD concepts is critical if IPPD is to be successfully sustained over the long term. An IPPD infrastructure includes the following:

An organization's shared vision that promotes IPPD concepts such as concurrent development and integrated teaming

A work environment that enables efficient and effective collaboration and integration

People trained to collaborate, integrate, and lead others as necessary

SP 1.1-1 Establish the Organization's Shared Vision

Establish and maintain a shared vision for the organization.

Establishing and maintaining the organization's shared vision involves creating, communicating, using, and periodically evaluating and revising the shared vision. An organization's shared vision captures the organization's guiding principles including mission, objectives, expected behavior, and values. The shared visions of a project's integrated teams should be consistent with the project's shared vision, which in turn should be consistent with the organization's shared vision. (See the definition of "shared vision" in the glossary.)

Creating a shared vision involves establishing and actively maintaining agreement and commitment about what is to be done and how it will be accomplished, both procedurally and behaviorally. A shared vision is a result of an ongoing dialogue among all the people who will make it real. It continues to evolve as more ideas are shared.

The organization's shared vision facilitates people working together, helps those people to attain unity of purpose, and creates a common understanding of the end state that the organization is aiming to achieve. The organization's shared vision must speak to every element of the organization. Effectively impacting the lowest levels of the organization necessitates impacting the highest levels as well. The organization's leaders need to be role models for the actions of the organization. Their commitment to IPPD is critical to its success in the organization. They must clearly communicate their expectations for the organization's projects and integrated teams and what the projects and integrated teams can expect from management.

Table . Practice-to-Goal Relationship Table
Continuous Representation	Staged Representation
SG 1 Provide IPPD Infrastructure	SG 1 Provide IPPD Infrastructure
SP 1.1-1 Establish the Organization's Shared Vision

SP 1.1-1 Establish the Organization's Shared Vision

SP 1.2-1 Establish an Integrated Work Environment

SP 1.3-1 Identify IPPD-Unique Skill Requirements

SG 2 Manage People for Integration

SP 2.1-1 Establish Leadership Mechanisms

SP 2.2-1 Establish Incentives for Integration

SP 2.3-1 Establish Mechanisms to Balance Team and Home Organization Responsibilities

GG 1 Achieve Specific Goals

GP 1.1 Perform Base Practices

GG 2 Institutionalize a Managed Process

GG 3 Institutionalize a Defined Process

GP 2.1 Establish an Organizational Policy

GP 2.2 Plan the Process

GP 2.3 Provide Resources

GP 2.4 Assign Responsibility

GP 2.5 Train People

GP 2.6 Manage Configurations

GP 2.7 Identify and Involve Relevant Stakeholders

GP 2.8 Monitor and Control the Process

GP 2.9 Objectively Evaluate Adherence

GP 2.10 Review Status with Higher Level Management

GG 3 Institutionalize a Defined Process

GP 3.1 Establish a Defined Process

GP 3.2 Collect Improvement Information

GG 4 Institutionalize a Quantitatively Managed Process

GP 4.1 Establish Quantitative Objectives for the Process

GP 4.2 Stabilize Subprocess Performance

GG 5 Institutionalize an Optimizing Process

GP 5.1 Ensure Continuous Process Improvement

GP 5.2 Correct Root Causes of Problems

The organization's shared vision needs to be grounded in reality. Organizations may be tempted to include in their shared vision broad statements about integrated teaming and employee empowerment. It is more important, however, to use the shared vision to set reasonable expectations on the rate of change in an organization. Unrealistic proclamations can transform the shared vision into a source of frustration and cause the organization to retreat from it after initial pilot demonstrations.

The organization's shared vision should be articulated in sufficient detail to provide criteria against which the shared visions of the projects and integrated teams can be aligned. For example, the organization's shared vision should address the use of integrated teams for projects, the focus on the customer, and the concurrent development of both product-related life-cycle processes and the product. These concepts, in turn, should be reflected in the shared visions of the projects and integrated teams. Guidelines for how projects and integrated teams should develop their shared visions should be made part of the organization's process asset library.

Maintenance of the organization's shared vision involves evaluating its use and currency. Results of evaluations may indicate the need to update the organization's shared vision or to establish and maintain organizational practices and structures that implement the shared vision.

Typical Work Products

Organization's shared vision

Evaluations of the organization's shared vision

Guidelines for shared vision building within projects and integrated teams

Subpractices

Identify expectations, constraints, interfaces, and boundary conditions applicable to the organization's shared vision.

Create a shared vision for the organization.

The shared vision can include what the people in the organization can expect from the organization (e.g., some organizations have developed an "employees' bill of rights").

Communicate the shared vision both externally and internally.

Ensure that organizational practices and structures are aligned with the shared vision.

Periodically review the shared vision and update it as necessary.

Reexamine the shared vision to determine weaknesses and misunderstood parts. Revise the shared vision to improve its clarity and applicability to the current state of the organization. Periodically reinforce the clarity and reality of the shared vision.

Provide guidelines for shared vision building for use by projects and integrated teams.

These guidelines should establish the context for the shared visions of the projects and integrated teams.
Shared visions of the projects should be focused on product and contribute to achievement of the organization's shared vision. Shared visions of the projects could relate the minimum competencies, or demonstrated capabilities, for people assigned to integrated teams, such as individual leadership capabilities. Proposed products, activities, partnerships, organizational and project structures, and shared visions of the projects are tested against the organization's shared vision.

For the integrated teams, nurturing integration necessitates special attention to the objectives, values, and behaviors that are needed to affect integrated teamwork. Aspects, such as team operations, team behaviors, team responsibilities, and collaboration with interfacing teams, can be addressed.

SP 1.2-1 Establish an Integrated Work Environment

Establish and maintain an integrated work environment that supports IPPD by enabling collaboration and concurrent development.

An integrated work environment includes the physical infrastructure (e.g., facilities, tools, equipment, and support needed to effectively use them) that people need to perform their jobs effectively. Properly functioning environments help people communicate clearly and efficiently about the product, processes, people needs, and organization. An integrated work environment helps integrate the business and technical functions and the interfaces among teams, projects, and organizations.

The integrated work environment must accommodate both collocated and distributed integrated teams as required. Two-way communications media should be easily accessible by all relevant stakeholders.

Encouraging open dialogue by providing communication mechanisms enables everyone to effectively engage in and contribute to information sharing. Appropriate mechanisms might include meeting rooms, email, fax, FTP or Web sites, video teleconferencing capabilities, and others depending on the organization's culture and its project and integrated team preferences for efficient and effective information sharing. The types of information needed, which agents (projects, integrated teams, or individuals), and how many of them produce, own, and need that information should be considered in deciding the mechanisms to be used.

Integrated communication tool sets reduce time spent converting information from one medium or platform to another, and correcting transcriptions or misunderstandings when people do the conversions. Requirements for product and process information usability throughout the life of the product are important characteristics to consider in the selection of information-exchange tools. In an IPPD environment, it is particularly important that the tools for designing and developing the product-related life-cycle processes are integrated with the tools for designing and developing the product and product components.

Integrated work environments are developed with the same, or greater, rigor as that used to develop a specific product or service. Integrated work environments are capital assets that are often expensive, have unique implementations, are irreversible (their implementation can destroy or make unusable the assets being replaced), and whose modification disrupts ongoing activities. The rigor appropriate to the development should be matched to the magnitude of the needs to be resolved and the deployment risks.

Typical Work Products

Requirements for the integrated work environment

Design of the integrated work environment

Integrated work environment

Subpractices

Determine requirements for the integrated work environment.
Requirements for the integrated work environment are typically based on the following:
- The organization's set of standard processes
- The objectives of the organization articulated in the organization's shared vision
- The needs associated with developing, maintaining, and delivering the products and services of the organization

Regularly evaluate the effectiveness of the existing environment and forecast the need for additional, upgraded, or new tools or integrated work environment components.

Maintain awareness of current and emerging technologies, tools, and resources that are related to the integrated work environment.

Maintaining awareness may be accomplished through industry journals, professional societies, conferences, trade shows, or benchmarking.
Examples of technologies, tools, and resources include the following:

Computing resources and software productivity tools

Communications systems, tools, and resources

Communication tools (e.g., email, telephone, databases, archives)

Manufacturing and production facilities

Engineering or simulation tools

Proprietary engineering tools

Prototyping or production equipment

Work space

Office equipment and supplies

Raw or stock input materials

Transportation resources

"Hotlines" and "help desks"

Information brokerage services

Support staff and/or services

Information-technology capabilities

Process enactment and management tools

Plan, design, and implement an integrated work environment.

The critical aspects of the work environment are, like any other system, requirements driven. Work environment functionality (stimulated by customer needs and requirements) is explored with the same rigor as any other system development. Are the performance improvements (e.g., timely interoperable communications, safety, security, maintainability) worth the costs (e.g., capital outlays, training, support structure, disassembly and disposal of existing environments, performance and maintenance of the environment) and risks (e.g., workflow and project disruptions)?
Requirements are developed for the duration of the work environment and address, as appropriate, the three different cases for work environment improvements: developing a new environment, migrating an existing environment to new capabilities, and maintaining awareness of new and evolving technologies to exploit improvement opportunities. As required, the integrated work environment or some of its components can be developed in house or acquired from external sources.

Provide ongoing maintenance and operational support for the integrated work environment.

Maintenance and support of the integrated work environment can be accomplished either with capabilities found inside the organization or hired from outside the organization.
Examples of maintenance and support methods include the following:

Hiring people to perform the maintenance and support

Training people to perform the maintenance and support

Contracting the maintenance and support

Developing expert users for selected automation tools

Monitor and evaluate the adequacy of the integrated work environment to satisfy user needs.

Refer to the Project Monitoring and Control process area for more information about practices for monitoring and controlling the work environment.

The work environment should be monitored throughout its existence to ascertain if, and when, its performance degrades below that expected (or specified) as well as to identify opportunities for improvements. The key operating characteristics of the integrated work environment should be identified. The key operating characteristics are those performance, product, and process characteristics that can be measured and compared against expected capabilities of the integrated work environment. End users should be surveyed to determine the adequacy of the current environment and to identify potential improvements. Changes should be planned and implemented based on the analysis of usage and performance data and on identified real and potential problems.

Revise the integrated work environment as necessary, by adding, deleting, or replacing components.

SP 1.3-1 Identify IPPD-Unique Skill Requirements

Identify the unique skills needed to support the IPPD environment.

Refer to the Organizational Training process area for more information about determining training needs and delivering the training.

IPPD is a sufficiently different view of product development that the organization's leadership and workforce will need to develop new skills. IPPD requires integrative leadership, and interpersonal skills beyond those typically found in traditional environments where people tend to work alone or primarily interact with others from their own, or similar, functions or disciplines. Specific skills emphasized in an IPPD environment include the following:

The skills to integrate all appropriate business and technical functions and their processes

The interpersonal skills to coordinate and collaborate with others

The leadership skills to act, and successfully influence others to act, to achieve the shared vision

Training to support these new skills must be established and maintained to sustain the ongoing adoption of IPPD in the organization.

Each integrated team member needs to understand what is vital to other team members in terms of product characteristics and the descriptions, expectations, and interfaces of the processes associated with the other functions represented on the team. This understanding can often be augmented through cross training of individuals across their function or discipline boundaries.

Collaboration among integrated team members is essential to create a team product rather than a collection of independent products. Enhanced interpersonal skills can help bridge the differences among disparate functions and disciplines as well as the differences in cultures, values, and backgrounds.

Leadership demands also increase under IPPD. Leadership challenges include: ensuring that all team members mutually understand their roles and responsibilities; employing people in their intended roles; and effectively accessing the depth and wealth of specific expertise resident in the organization and integrating it into the overall integrated team effort.

Typical Work Products

IPPD strategic training needs

IPPD tactical training needs

Subpractices

Provide requirements for IPPD skills for inclusion in the organization's strategic training needs.

Provide requirements for IPPD skills for inclusion in the organization's tactical training plan.

SG 2 Manage People for Integration

People are managed to nurture the integrative and collaborative behaviors of an IPPD environment.

In an IPPD environment, special attention needs to be paid to aspects of organizational leadership and management. Nurturing integration necessitates focus on the objectives, values, and behaviors that are needed to affect integrated teamwork. The organization establishes the IPPD guidelines and processes that become part of the organization's set of standard processes and the project's defined process. The organization's standard processes enable, promote, and reinforce the integrative behaviors expected from projects, integrated teams, and people. For all IPPD processes and guidelines, people are recognized not as the tools or means to the end, but as part of a mutually beneficial collaboration to achieve the objectives.

In stimulating the integration needed, team-related incentives may be appropriate for people who work together. However, the value of individual excellence should not be overlooked. A balanced approach that addresses both individual performance as well as team performance would help maintain high standards of both team and individual achievement. Expectations from projects, integrated teams, and people are typically communicated in the form of policies, operating procedures, guidelines, and other organizational process assets.

SP 2.1-1 Establish Leadership Mechanisms

Establish and maintain leadership mechanisms to enable timely collaboration.

Implementing IPPD introduces challenges to leadership because of the cultural changes required when people and integrated teams are empowered and decisions are driven to the lowest level appropriate. Effective and efficient communication mechanisms are critical to timely and sound decision making in the integrated work environment. Once an integrated work environment is established and training is provided, mechanisms to handle empowerment, decision making, and issue resolution also need to be provided to affect the timely collaboration of relevant stakeholders required for IPPD.

In an IPPD environment, it is particularly important that clear channels of responsibility and authority be established. Within the projects and the organization, issues can arise when individuals or integrated teams assume too much or too little authority and when the level at which decisions are made, or who owns what decisions, is unclear. Organizational guidelines that scope the degree of empowerment for integrated teams serve an issue-prevention role. Best practices promote documented and deployed organizational guidelines that can preclude issues arising from empowerment and authority misinterpretation.

Empowerment does not necessarily mean that every decision in an IPPD environment must occur at the lowest level, that it must be done collaboratively, or even that it must reflect consensus among all integrated team members or project participants. Decisions on the style and procedures for leadership and decision making for projects and among integrated teams need to be made in collaboration with the relevant stakeholders. In establishing the context for decision making, the various kinds of issues are described and agreements are reached on the decision type that will be used to resolve each kind of issue.

Some examples of decision types include the following:

Command.
The leader examines the issue and makes a decision alone.

Consultative.
The leader receives and examines inputs on the issue from relevant stakeholders and makes the decision.

Collaborative.
Issues are raised by any relevant stakeholders (including the leader), issues are discussed, and solutions are voted on. Rules are needed to determine whether this vote is binding on the leader.

Consensus.
Issues are raised by any relevant stakeholders, including the leader, and are discussed until all members of the integrated team can live with and support the decision.

Structured.
Major issues may be decided using formal evaluations. The steps in formal evaluations may be carried out in a collaborative way.

For many issues, a command decision may be adequate. For issues that require several different areas of expertise or that have far-reaching consequences, collaborative decisions may be more appropriate. Defining decision types and the authority of those entrusted to make decisions enables efficient operations.

Mechanisms that grow leadership talent enable lower organizational unit delegation, which, in turn, enables faster, better responses to changing customer needs, technology, and environmental conditions.

Leadership characteristics cannot be viewed as solely embodied in the manager/leader. When leadership characteristics are evident in more than the leader, individual group members lead decision making and activities that heavily involve their areas of expertise. This flexibility can result in improved group efficiency and effectiveness.

Even with well-intentioned empowerment, leadership, and decision making, issues will arise that cannot be resolved at the same level. An organizational process for issue resolution can form the basis for project-and integrated-team-specific procedures and help ensure that basic issue-resolution avenues are available to projects and integrated teams when unresolved issues must be escalated. An organizational process for issue resolution can serve both issue-resolution and issue-prevention roles.

Typical Work Products

Guidelines for determining the degree of empowerment of people and integrated teams

Guidelines for setting leadership and decision-making context

Organizational process documentation for issue resolution

Subpractices

Establish and maintain guidelines for the degree of empowerment provided to people and integrated teams.

Collaboratively determine rules for the use of different decision types in making various kinds of decisions.

Refer to the Decision Analysis and Resolution process area for more information about approaches for evaluating and selecting among alternatives.

Define the process for using the decision-making rules.

Define a process for conflict resolution when an issue cannot be decided at the level at which it arose.

SP 2.2-1 Establish Incentives for Integration

Establish and maintain incentives for adopting and demonstrating integrative and collaborative behaviors at all levels of the organization.

The recognition and reward systems in an organization are one of the motivators for behavior and value changes. To support IPPD, the recognition and reward systems (both positive rewards and negative consequences) need to recognize a shift in values from a single point of success or failure (e.g., providing a management incentive package to the product or program manager alone) to integrated team success or failure (e.g., providing layered incentives to integrated team members based on degree of involvement and contribution).

Individual excellence still should be recognized, but criteria should discern whether such excellence was achieved at the expense of the integrative behaviors expected or in support of them. For example, individuals (such as leaders) removing integration barriers or implementing collaboration capabilities may be just as important as an integrated team performing well. Care should be taken, however, not to single out individuals for recognition for a team's achievement.

Incentives should be consistent with the objectives of the organization and applied to achieve desired behavior at all levels of the organization. Criteria can establish guidelines for the reassignment of people who are unable to demonstrate desired behavior and the selection of people who can exhibit desired behavior for challenging or important jobs.

Compensation is not the only motivator, although giving an object of some value is an appropriate recognition. Reinforcement of positive behavior via thanks or praise is usually appropriate, especially soon after the observed performance of a task. Such immediate recognition reinforces the collaborative nature of working in an IPPD environment. If staff must wait for yearly performance appraisals, their motivation for working outside of their strict functional job description is lessened.

The yearly performance appraisals also need to be addressed. Review mechanisms should be structured so that both home organization supervisors and team leaders contribute to a person's performance review.

Typical Work Products

Policies and procedures for performance appraisal and recognition that reinforce collaboration

Integrated team and individual recognition and rewards

Subpractices

Structure the recognition and reward system to be consistent with the IPPD environment.

The organization's recognition and reward system should recognize the value of individual and integrated team excellence and enable, promote, and reinforce integration.

Develop guidelines for team as well as individual recognition.

Define procedures for integrated review processes that involve both the integrated team leader and the functional manager.

Establish criteria for distinguishing behaviors that promote integrated team performance from those that establish barriers to team behaviors.

SP 2.3-1 Establish Mechanisms to Balance Team and Home Organization Responsibilities

Establish and maintain organizational guidelines to balance team and home organi zation responsibilities.

Here "home organization" refers to that part of the organization to which personnel are assigned when they are not in an integrated team. This home organization may be called the "functional organization," "home base," "home office," or "direct organization." Regardless of what it is called, it is often responsible for the career growth of the personnel assigned to it (e.g., performance appraisals and training to maintain functional and discipline expertise). In an IPPD environment, reporting procedures and rating systems should recognize that people's responsibility is focused on the integrated team, not on the traditional home organization. A balance must be struck, however, because the responsibility of integrated team members to their respective home organizations is still important, specifically for process implementation and improvement. Workloads should be balanced among projects and functions, while ensuring career growth and advancement. Mechanisms should be created that support the home organization responsibility but align the workforce to meet business objectives in a teaming environment.

Striking this balance is difficult for an organization but exceedingly important for the personnel and the success of IPPD implementation. The balance must be reflected in the personal or career development plans for each individual. The knowledge and skills needed for an individual to succeed in both their functional and integrated team role should be honed, taking into account current and future assignments.

Guidelines should also be in place for disbanding teams and maintaining home organizations. It has been observed that sometimes teams attempt to remain in place beyond their productive life in organizations that do not have a home organization for the team members to report back to after the team is dissolved.

Typical Work Products

Organizational guidelines for balancing team and home organization responsibilities

Performance review process that considers both functional supervisor and team leader input

Subpractices

Establish guidelines for home organization responsibilities in promoting integrated team behavior.

Establish guidelines for team management responsibilities to ensure integrated team members report appropriately to their home organization.

Establish a performance review process that considers input from home organization and integrated team leaders.

[ Team LiB ]

Day 17

2010-02-04T05:29:00.017-08:00

[ Team LiB ]

Day 17

1:	To create a new table by importing IXF data, which import mode should you use?
A1:	You must use the `CREATE` import mode to create a new table when importing IXF data.
2:	If you want to create a new table, what format should you use? Would you use the Load Wizard or the Import Wizard to create a new table?
A2:	Integrated exchange format (IXF) is used to create a new table; the DEL, ASC, and WSF formats can be used only to import data into an existing table. IXF format is the format used by database managers. Load doesn't support creating a new table; the table must exist before you can load data into it. To create a new table, use the Import utility.
3:	How do you export only a subset of the data in a table?
A3:	Click the Columns tab in the Export dialog box to specify only a subset of the columns to export. Exporting a subset of columns is supported only when using WSF or IXF formats.
4:	What must take place before you can save a copy of the changes when using the Load Wizard?
A4:	Forward recovery must be turned on to enable you to save a copy of the changes when using the Load utility. On the Copy Options page of the Load Wizard, specify that a copy of the changes be saved.

[ Team LiB ]

The Unbearable Lightness of False Positives

2010-02-04T05:29:00.015-08:00

The Unbearable
Lightness of False Positives

The temptation when you get access to a
powerful new toy, er, tool like Snort is to overuse it. At first you will turn
on every single rule. You will set them to the detailed alert mode. You will
have the alerts send you pages on your cell phone. Don't!

The rule library is very conservative. Many
of the rules will be triggered by ordinary activity on a large and complex
network. You will be paged perpetually. These events are called class=docemphasis1>false positives. The real problem with them is not
that you will be pestered and hounded but that you might raise so many things
to an alert level that you will miss the real cracking attempts because you are
buried up to your eyes in employees accessing E-bay.

Another mistake is to use the rule libraries
without giving any thought to the details of your environment. If you use only
Apache Web servers, you probably don't need the rules in class=docemphasis1>web-iis.rules. Are you using Snort on a single box to
watch for attempts to break into just that box, or are you using it in your DMZ
to watch all attempts to get through your firewall?

I haven't got room to tell you how to design
an intrusion-detection system. I'm just showing you the basics of Snort.
Remember that while the tool may be one-size-fits-all, you do actually have to
pull in the drawstrings if you are going to keep the rain out.

Keep some of these elements in mind when you
are figuring out how to fit Snort into your setup:

How many networks, hosts, routers do I want
to watch?

What potentially vulnerable services do I
want to monitor?

Do I or can I trust my internal hosts?

How many "ports of entry" do I
have, and can Snort see them all?

How much computer power do I need? Snort can
easily watch a 28.8-kbps PPP link running on a 486, but to watch an
asynchronous transfer mode (ATM) router you might need a bit more than that.

That's not an exhaustive list by any means. It's
just the start of the sort of questions you must ask yourself when planning to
deploy Snort or indeed any other IDS (intrusion-detection system) tool.

Summary

2010-02-04T05:29:00.013-08:00

[ Team LiB ]

Summary

In this chapter we have discussed one of the top tuning areas in DB2, Sorts. Sorts are used to return data either to online forms or applications in an ordered manner. Sometimes using a sort is the best method, but often sorts cause the biggest application performance problems. DB2 can use indexes to eliminate sorts if the columns being sorted are defined in the index in the appropriate order. DB2 v8 gives us a new DB CFG parameter, SHEAPTHRES_SHR, with which to control the amount of shared memory available for shared sorts. This gives us the ability to control shared sorts at the database level instead of at the instance level.

Database snapshots provide us with details on overall sort performance at the database level. Additional snapshots are available to provide us with additional information on sorts. Connection and statement event monitors are the primary means available to us for gathering data on sort consumption and aid us in tuning and eliminating sorts.

The Design Advisor and Visual Explain are primary tools for us to use in tuning and eliminating sorts. Examples were provided where significant performance improvements were made, simply by using Design Advisor and knowledge of the application, to create or modify indexes to eliminate sorts.

Sort performance is probably a problem at your workplace. You can use the procedures and techniques outlined in this chapter to eliminate sorts and significantly enhance the performance of databases under your control.

[ Team LiB ]

Recipe 10.1. Using DBM Databases

2010-02-04T05:29:00.011-08:00

Recipe 10.1. Using DBM Databases

10.1.1. Problem

You have

data that can be easily represented as key/value pairs, want to store it safely, and have very fast lookups based on those keys.

10.1.2. Solution

Use the DBA abstraction layer to access a DBM-style database, as shown in Example 10-3.

Using a DBM database

<?php
$dbh = dba_open('fish.db','c','gdbm') or die($php_errormsg);

// retrieve and change values
if (dba_exists('flounder',$dbh)) {
  $flounder_count = dba_fetch('flounder',$dbh);
  $flounder_count++;
  dba_replace('flounder',$flounder_count, $dbh);
  print "Updated the flounder count.";
} else {
  dba_insert('flounder',1, $dbh);
  print "Started the flounder count.";
}

// no more tilapia
dba_delete('tilapia',$dbh);

// what fish do we have?
for ($key = dba_firstkey($dbh);  $key !== false; $key = dba_nextkey($dbh)) {
   $value = dba_fetch($key, $dbh);
   print "$key: $value\n";
}

dba_close($dbh);
?>

10.1.3. Discussion

PHP can support a few different kinds of DBM backends:
GDBM, NDBM,
DB2
, DB3,
DBM, and
CDB. The DBA abstraction layer lets you use the same functions on any DBM backend. All these backends store key/value pairs. You can iterate through all the keys in a database, retrieve the value associated with a particular key, and find if a particular key exists. Both the keys and the values are strings.

The program in Example 10-4 maintains a list of usernames and passwords in a DBM database. The username is the first command-line argument, and the password is the second argument. If the given username already exists in the database, the password is changed to the given password; otherwise, the user and password combination are added to the database.

Tracking users and passwords with a DBM database

<?php
$user = $_SERVER['argv'][1];
$password = $_SERVER['argv'][2];

$data_file = '/tmp/users.db';

$dbh = dba_open($data_file,'c','gdbm') or die("Can't open db $data_file");

if (dba_exists($user,$dbh)) {
    print "User $user exists. Changing password.";
} else {
    print "Adding user $user.";
}

dba_replace($user,$password,$dbh) or die("Can't write to database $data_file");

dba_close($dbh);
?>

The dba_open( )
function returns a handle to a DBM file (or false on error). It takes three arguments. The first is the filename of the DBM file. The second argument is the mode for opening the file. A mode of r opens an existing database for read-only access, and w opens an existing database for read-write access. The c mode opens a database for read-write access and creates the database if it doesn't already exist. Last, n does the same thing as c, but if the database already exists, n empties it. The third argument to dba_open( ) is which DBM handler to use; this example uses 'gdbm'. To find what DBM handlers are compiled into your PHP installation, look at the "DBA" section of the output from phpinfo( ). The "Supported handlers" line gives you your choices.

To find if a key has been set in a DBM database, use
dba_exists( ). It takes two arguments: a string key and a DBM filehandle. It looks for the key in the DBM file and returns true if it finds the key (or false if it doesn't). The dba_replace( )
function takes three arguments: a string key, a string value, and a DBM filehandle. It puts the key/value pair into the DBM file. If an entry already exists with the given key, it overwrites that entry with the new value.

To close a database, call dba_close( )
. A DBM file opened with dba_open( ) is automatically closed at the end of a request, but you need to call dba_close( ) explicitly to close persistent connections created with
dba_open( ).

You can use dba_firstkey( )

and dba_nextkey( ) to iterate through all the keys in a DBM file and dba_fetch( ) to retrieve the values associated with each key. The program in Example 10-5 calculates the total length of all passwords in a DBM file.

Calculating password length with DBM

<?php
$data_file = '/tmp/users.db';
$total_length = 0;
if (! ($dbh = dba_open($data_file,'r','gdbm'))) {
    die("Can't open database $data_file");
}

$k = dba_firstkey($dbh);
while ($k) {
    $total_length += strlen(dba_fetch($k,$dbh));
    $k = dba_nextkey($dbh);
}

print "Total length of all passwords is $total_length characters.";

dba_close($dbh);

The dba_firstkey( ) function initializes $k to the first key in the DBM file. Each time through the while loop, dba_fetch( ) retrieves the value associated with key $k and $total_length is incremented by the length of the value (calculated with strlen( )). With dba_nextkey( ), $k is set to the next key in the file.

One way to store complex data in a DBM database is with serialize( ). Example 10-6 stores structured user information in a DBM database by serializing the structure before storing it and unserializing when retrieving it.

Storing structured data in a DBM database

<?php
$dbh = dba_open('users.db','c','gdbm') or die($php_errormsg);

// read in and unserialize the data
if ($exists = dba_exists($_POST['username'], $dbh)) {
    $serialized_data = dba_fetch($_POST['username'], $dbh) or die($php_errormsg);
    $data = unserialize($serialized_data);
} else {
    $data = array();
}

// update values
if ($_POST['new_password']) {
    $data['password'] = $_POST['new_password'];
}
$data['last_access'] = time();

// write data back to file
if ($exists) {
    dba_replace($_POST['username'],serialize($data), $dbh);
} else {
    dba_insert($_POST['username'],serialize($data), $dbh);
}

dba_close($dbh);
?>

While Example 10-6 can store multiple users' data in the same file, you can't search for, for example, a user's last access time, without looping through each key in the file. If you need to do those kinds of searches, put your data in an SQL database.

Each DBM handler has different behavior in some areas. For example, GDBM provides internal locking. If one process has opened a GDBM file in read-write mode, other calls to dba_open( ) to open the same file in read-write mode will fail. For other DBM handlers, add an l to the mode you pass to dba_open( ) to lock the database with a separate .lck file
or a d to lock the database file itself. Two DBA functions are also database-specific: dba_optimize( ) and dba_sync( ). The dba_optimize( ) function calls a handler-specific DBM file-optimization function. Currently, this is implemented only for GDBM, for which its gdbm_reorganize( ) function is called. The dba_sync( ) function calls a handler-specific DBM file synchronizing function. For DB2 and DB3, their sync( ) function is called. For GDBM, its gdbm_sync( ) function is called. Nothing happens for other DBM handlers.

Using a DBM database is a step up from a plain text file but it lacks most features of an SQL database. Your data structure is limited to key/value pairs, and locking robustness varies greatly depending on the DBM handler. Still, DBM handlers can be a good choice for heavily accessed read-only data.

10.1.4. See Also

Recipe 5.7 discusses serializing data; documentation on the DBA functions at http://www.php.net/dba; for more information on the DB2 and DB3 DBM handlers, see http://www.sleepycat.com/products/bdb.html (note that these handlers are not generally free for commercial use); for GDBM, check out http://www.gnu.org/directory/gdbm.html or http://www.mit.edu:8001/afs/athena.mit.edu/project/gnu/doc/html/gdbm_toc.html

.

Audio Effects on Sampled Audio

2010-02-04T05:29:00.009-08:00

Audio Effects on Sampled Audio

There are three approaches for affecting sampled audio:

Precalculation: Using this approach, you create the audio effect at development time and play the resulting sound clip at execution time.
Byte array manipulation: Here, you store the sound in a byte array at runtime, permitting it to be modified using array-based operations.
Mixer controls: A mixer control, such as gain or panning, affects the sound signal passing through the mixer's audio line.

Precalculation

Manipulating audio inside Java can be time-consuming and complicated. If a sound effect is going to be used regularly (e.g., a fading scream, an echoing explosion), then it will probably be better to create it when the game is being developed and save the finished audio to a file for playing at runtime. This moves the overheads associated with sound effect generation out of the application. I've found WavePad useful for various editing, format conversion, and effects tasks (http://nch.com.au/wavepad/). Its supported effects include amplification, reverberation, echoing, noise reduction, fading, and sample rate conversion. It offers recording and CD track ripping. It's small (320 KB), free, and has a decent manual.

Many tools are out there: Do a search for "audio editor" at Google or visit a software site such as tucows (http://www.tucows.com/search).

Byte Array Manipulation

The most versatile manipulation approach in Java (but potentially tricky to get right) is to load the audio file as a byte array. Audio effects then become a matter of changing byte values, rearranging blocks of data, or perhaps adding new data. Once completed, the resulting array can be passed through a SourceDataLine into the mixer. The EchoSamplesPlayer.java application that follows shows how this can be done.

A variant of this approach is to employ streaming. Instead of reading in the entire file as a large byte array, the audio file can be incrementally read, changed, and sent to the mixer. However, this coding style is restricted to effects that only have to examine the sound fragment currently in memory. For example, amplification of the array's contents doesn't require a consideration of the other parts of the sound.

Making a sound clip echo

EchoSamplesPlayer.java completely loads a sound clip into a byte array via an AudioInputStream. Then an echoing effect is applied by creating a new byte array and adding five copies of the original sound to it; each copy is softer than the one before it. The resulting array is passed in small chunks to the SourceDataLine and to the mixer.

EchoSamplesPlayer is an extended version of the BufferedPlayer application described in Chapter 7. The main addition is a getSamples( ) method: This method applies the effect implemented in echoSamples( ). An isRequiredFormat( ) method exists for checking the input is suitable for modification. The program is stored in SoundExamps/SoundPlayer/.

To simplify the implementation, the echo effect is only applied to 8-bit PCM signed or unsigned audio. The choice of PCM means that the amplitude information is stored unchanged in the byte and isn't compressed as in the ULAW or ALAW formats. The 8-bit requirement means a single byte is used per sample, so I don't have to deal with big- or little-endian issues. PCM unsigned data stores values between 0 and 28 - 1 (255), and the signed range is -27 to 27 - 1 (-128 to 127). This becomes a concern when I cast a byte into a short prior to changing it.

The main( ) method in EchoSamplesPlayer is similar to the one in BufferedPlayer:


    public static void main(String[] args)
    { if (args.length != 1) {
        System.out.println("Usage: java EchoSamplesPlayer <clip>");
        System.exit(0);
      }

      createInput("Sounds/" + args[0]);

      if (!isRequiredFormat( )) {    // not in SamplesPlayer
        System.out.println("Format unsuitable for echoing");
        System.exit(0);
      }

      createOutput( );

      int numBytes=(int)(stream.getFrameLength( )*format.getFrameSize( ));
      System.out.println("Size in bytes: " + numBytes);

      byte[] samples = getSamples(numBytes);
      play(samples);

      System.exit(0);   // necessary in J2SE 1.4.2 and earlier
    }

The createInput( ) and createOutput( ) methods are unchanged from BufferedPlayer.

isRequiredFormat( ) tests the AudioFormat object that was created in createInput( ):


    private static boolean isRequiredFormat( )
    // Only 8-bit PCM signed or unsigned audio can be echoed
    {
      if (((format.getEncoding( )==AudioFormat.Encoding.PCM_UNSIGNED) ||
           (format.getEncoding( ) == AudioFormat.Encoding.PCM_SIGNED))&&
           (format.getSampleSizeInBits( ) == 8))
        return true;
      else
        return false;
    }

AudioFormat has a selection of get( ) methods for examining different aspects of the audio data. For example, AudioFormat.getChannels( ) returns the number of channels used (1 for mono, 2 for stereo). The echoing effect doesn't need this information; all the frames, independent of the number of channels, will be amplified. Typically, channel information is required if an effect will differentiate between the stereo outputs, as when a sound is panned between speakers.

getSamples( ) adds the echoes after it has extracted the complete samples[] array from the AudioInputStream:


    private static byte[] getSamples(int numBytes)
    {
       // read the entire stream into samples[]
       byte[] samples = new byte[numBytes];
       DataInputStream dis = new DataInputStream(stream);
       try {
         dis.readFully(samples);
       }
       catch (IOException e)
       { System.out.println( e.getMessage( ));
         System.exit(0);
       }
       return echoSamples(samples, numBytes);
    }

echoSamples( ) returns a modified byte array, which becomes the result of getSamples( ).

Different audio effects could replace the call to echoSamples( ) at this point in the code.

echoSamples( ) creates a new byte array, newSamples( ), big enough to hold the original sound and ECHO_NUMBER (4) copies. The volume of each one is reduced (decayed) (which is set to by DECAY (0.5) over its predecessor:


    private static byte[] echoSamples(byte[] samples, int numBytes)
    {
      int numTimes = ECHO_NUMBER + 1;
      double currDecay = 1.0;
      short sample, newSample;
      byte[] newSamples = new byte[numBytes*numTimes];

      for (int j=0; j < numTimes; j++) {
        for (int i=0; i < numBytes; i++)  // copy the sound's bytes
          newSamples[i + (numBytes*j)] = echoSample(samples[i], currDecay);
        currDecay *= DECAY;
      }
      return newSamples;
    }

The nested for loop makes the required copies one byte at a time. echoSample( ) utilizes a byte in the original data to create an "echoed" byte for newSamples[]. The amount of echoing is determined by the currDecay double, which shrinks for each successive copy of the original sound.

echoSample( ) does different tasks depending on if the input data are unsigned or signed PCM. In both cases, the supplied byte is translated into a short so it can be manipulated easily; then, the result is converted back to a byte:


    private static byte echoSample(byte sampleByte, double currDecay)
    {
      short sample, newSample;
      if (format.getEncoding( ) == AudioFormat.Encoding.PCM_UNSIGNED) {
        sample = (short)(sampleByte & 0xff);  // unsigned 8 bit -> short
        newSample = (short)(sample * currDecay);
        return (byte) newSample;
      }
      else if (format.getEncoding( )==AudioFormat.Encoding.PCM_SIGNED){
        sample = (short)sampleByte;   // signed 8 bit -> short
        newSample = (short)(sample * currDecay);
        return (byte) newSample;
      }
      else
        return sampleByte;    //no change; this branch should be unused
    }

This byte-to-short conversion must be done carefully. An unsigned byte needs masking as it's converted since Java stores shorts in signed form. A short is two bytes long, so the masking ensures that the bits in the high-order byte are all set to 0s. Without the mask, the conversion would add in 1s when it saw a byte value above 127.

No masking is required for the signed byte to signed short conversion since the translation is correct by default.

Playing

play( ) is similar to the one in BufferedPlayer.java in Chapter 7. The difference is that the byte array must be passed through an input stream before it can be sent to the SourceDataLine:


    private static void play(byte[] samples)
    {
      // byte array --> stream
      InputStream source = new ByteArrayInputStream(samples);
      int numRead = 0;
      byte[] buf = new byte[line.getBufferSize( )];

      line.start( );
      // read and play chunks of the audio
      try {
        while ((numRead = source.read(buf, 0, buf.length)) >= 0) {
          int offset = 0;
          while (offset < numRead)
            offset += line.write(buf, offset, numRead-offset);
        }
      }
      catch (IOException e)
      {  System.out.println( e.getMessage( )); }

      // wait until all data is played, then close the line
      line.drain( );
      line.stop( );
      line.close( );
    }  // end of play( )

Utilizing Mixer Controls

The mixer diagram in Figure 9-1 includes a grayish box labeled "Controls." Controls, such as gain and panning, affect the sound signal passing through an audio line. They can be accessed through Clip or SourceDataLine via a getControls( ) method that returns an array of available Control objects. Each object, suitably subclassed, allows its associated audio control to be manipulated.

Figure 9-1. Audio I/O to/from the mixer

The bad news is that the default mixer in J2SE 5.0 offers fewer controls than were present in J2SE 1.4.2 since controls tend to have an adverse effect on speed even when they're not being used. However, if a control is present, then it's much easier to apply than the byte array technique.

Adjusting a clip's volume and pan values

PlaceClip plays a clip, allowing its volume and pan settings to be adjusted via command-line parameters. It's called with the following format:


    java PlaceClip <clip file> [ <volume value> [<pan value>] ]

The volume and pan values are optional; if they are both left out, then the clip will play normally.

The volume setting should be between 0.0f (the quietest) and 1.0f (the loudest); -1.0f means that the volume is left unchanged. The pan value should be between -1.0f and 1.0f; -1.0f causes all the sound to be set to the left speaker, 1.0f focuses only on the right speaker, and values in between will send the sound to both speakers with varying weights, as in this example:


    java PlaceClip dog.wav 0.8f -1.0f

This will make the left speaker bark loudly. This mixing of volume and speaker placement is a rudimentary way of placing sounds at different locations in a game.

PlaceClip is an extended version of PlayClip, which was described in Chapter 7. The changes in PlaceClip are in the extra methods for reading the volume and pan settings from the command line and in the setVolume( ) and setPan( ) methods for adjusting the clip controls. The program is stored in SoundExamps/SoundPlayer/.PlaceClip's main( ) method is similar to the one in PlayClip.java:


    // globals
    private float volume, pan;   // settings from the command line


    public PlaceClip(String[] args)
    {
      df = new DecimalFormat("0.#");  // 1 dp

    getSettings(args);   // get the volume and pan settings
                           // from the command line
      loadClip(SOUND_DIR + args[0]);

      // clip control methods
      showControls( );
      setVolume(volume);
      setPan(pan);

      play( );
      try {
        Thread.sleep(600000);   // 10 mins in ms
      }
      catch(InterruptedException e)
      { System.out.println("Sleep Interrupted"); }
    }

loadClip( ) and play( ) are almost unchanged from PlayClip. (loadClip( ) uses a globally defined AudioFormat variable and has some extra println( )'s.) loadClip( ) includes a call to checkDuration( ), which issues a warning if the clip is one second or less in length. In that case, the clip won't be heard in J2SE 5.0 due to a Java Sound bug.

What controls are available?

showControls( ) displays all the controls available for the clip, which will vary depending on the clip's audio format and the mixer:


    private void showControls( )
    { if (clip != null) {
        Control cntls[] = clip.getControls( );
        for(int i=0; i<cntls.length; i++)
          System.out.println( i + ".  " + cntls[i].toString( ) );
      }
    }

getControls( ) returns information once the clip the class represents has been opened.

For the dog.wav example, executed using the J2SE 1.4.2 default mixer, showControls( )'s output is given in Example 9-1.

Example 9-1. showControls( )'s output


0.  Master Gain with current calue: 0.0 dB (range: -80.0 - 13.9794)
1.  Mute Control with current value: Not Mute
2.  Pan with current value: 0.0 (range: -1.0 - 1.0)
3.  Sample Rate with current value: 22000.0 FPS (range: 0.0 - 48000.0)

In this case, four controls are available: gain (volume), mute, panning, and sample rate.

Reverberation and balance controls may be available for some types of clips and mixers. In J2SE 5.0, panning, sample rate, and reverberation are no longer supported, and the balance control is only available for audio files using stereo.

In real-world audio gadgets, a pan control distributes mono input (input on a single channel) between stereo output lines (e.g., the lines going to the speakers). So, the same signal is sent to both output lines. A balance control does a similar job but for stereo input, sending two channels of input to two output lines.

In J2SE 1.4.2 and before, the pan and balance controls could be used with mono or stereo input, i.e., there was no distinction between them. Output lines were always opened in stereo mode. The default J2SE 1.4.2 mixer is the Java Sound Audio Engine.

The default mixer in J2SE 5.0 is the Direct Audio Device, with resulting changes to the controls. If the mixer receives mono input it will open a mono output line and not a stereo one. This means there's no pan control since there's no way to map mono to stereo. There is a balance control, but that's for mapping stereo input to stereo output.

In J2SE 5.0, the example will report that panning is unavailable since dog.wav was recorded in mono. The simplest solution is to convert it to stereo using WavePad (http://nch.com.au/wavepad/) or similar software. The balance controls will then be available, and setPan( ) can carry out panning by adjusting the balance.

Java audio controls

The various controls are represented by subclasses of the Control class: BooleanControl, FloatControl, EnumControl, and CompoundControl.

BooleanControl is used to adjust binary settings, such as mute on/off. FloatControl is employed for controls that range over floating point values, such as volume, panning, and balance. EnumControl permits a choice between several settings, as in reverberation. CompoundControl groups controls.

All these controls will function only if the clip is open.

As an example, here's a code fragment that turns mute on and off with a BooleanControl:


    BooleanControl muteControl =
         (BooleanControl) clip.getControl( BooleanControl.Type.MUTE );
    muteControl.setValue(true);     // mute on; sound is switched off
         : // later on
    muteControl.setValue(false);    // mute off; sound is audible again

Here's another that plays a clip at 1.5 times its normal speed via a FloatControl:


    FloatControl rateControl =
         (FloatControl) clip.getControl( FloatControl.Type.SAMPLE_RATE );
    rateControl.setValue( 1.5f * format.getSampleRate( ) );
            // format is the AudioFormat object for the audio file

Setting the volume in PlaceClip

PlaceClip offers a volume parameter, ranging from 0.0f (off) to 1.0f (on). Additionally, no change to the volume is represented internally by the NO_VOL_CHANGE constant (the float -1.0f).

Unfortunately, the mixer's gain controls use the logarithmic decibel scale (related to the square of the distance from the sound source). Rather than grappling with a realistic mapping from my linear scale (0-1) to the decibel range, I use a linear equation to calculate the new gain:


    gain = ((range_max - range_min) * input_volume) + range_min

range_min and range_max are the minimum and maximum possible gain values; input_volume is the float obtained from the command line.

The drawback to this approach is that the logarithmic gain scale is being treated like a linear one. In practice, this means that the sound becomes inaudible when the supplied volume setting is 0.5f or less. On balance, this is a small price to pay for greatly simplified code.

setVolume( ) uses isControlSupported( ) to check for the volume control's presence before attempting to access/change its setting:


    private void setVolume(float volume)
    {
      if ((clip != null) && (volume != NO_VOL_CHANGE)) {
        if (clip.isControlSupported(FloatControl.Type.MASTER_GAIN)) {
          FloatControl gainControl = (FloatControl)
                clip.getControl(FloatControl.Type.MASTER_GAIN);

          float range = gainControl.getMaximum( ) - gainControl.getMinimum( );
          float gain = (range * volume) + gainControl.getMinimum( );
          System.out.println("Volume: " + volume + "; New gain: " + gain);
          gainControl.setValue(gain);
        }
        else
          System.out.println("No Volume controls available");
      }
    }

FloatControl has several potentially useful methods, like shift( ), which is meant to change the control value gradually over a specified time period and returns without waiting for the shift to finish. Unfortunately, this particular method has never been fully implemented and currently modifies the control value in one step without any incremental changes in between.

Panning between the speakers in PlaceClip

setPan( ) is supplied with a pan value between -1.0f and 1.0fwhich will position the output somewhere between the left and right speakersor with NO_PAN_CHANGE (0.0f). The method pans first, looks for the balance control if panning is unavailable, and finally gives up if both are unsupported:


    private void setPan(float pan)
    {
      if ((clip == null) || (pan == NO_PAN_CHANGE))
        return;   // do nothing

      if (clip.isControlSupported(FloatControl.Type.PAN)) {
        FloatControl panControl =
           (FloatControl) clip.getControl(FloatControl.Type.PAN);
        panControl.setValue(pan);
      }
      else if (clip.isControlSupported(FloatControl.Type.BALANCE)) {
        FloatControl balControl =
           (FloatControl) clip.getControl(FloatControl.Type.BALANCE);
        balControl.setValue(pan);
      }
      else {
        System.out.println("No Pan or Balance controls available");
        if (format.getChannels( ) == 1)   // mono input
          System.out.println("Your audio file is mono;
                                  try converting it to stereo");
      }
    }

Section 6.3. Buffered Streams

2010-02-04T05:29:00.007-08:00

6.3. Buffered Streams

Buffered input streams read more data than they initially need into a buffer (an internal array of bytes). When one of the stream's read( ) methods is invoked, data is removed from the buffer rather than from the underlying stream. When the buffer runs out of data, the buffered stream refills its buffer from the underlying stream. Likewise, buffered output streams store data in an internal byte array until the buffer is full or the stream is flushed; then the data is written out to the underlying output stream in one swoop. In situations where it's almost as fast to read or write several hundred bytes from the underlying stream as it is to read or write a single byte, a buffered stream can provide a significant performance boost.

There are two BufferedInputStream constructors and two BufferedOutputStream constructors:


public BufferedInputStream(InputStream in)
public BufferedInputStream(InputStream in, int size)
public BufferedOutputStream(OutputStream out)
public BufferedOutputStream(OutputStream out, int size)

The first argument is the underlying stream from which data will be read or to which data will be written. The size argument is the number of bytes in the buffer. If a size isn't specified, a 2048-byte buffer is used. The best size for the buffer depends on the platform and is generally related to the block size of the disk (at least for file streams). Less than 512 bytes is probably too small and more than 8,192 bytes is probably too large. Ideally, you want an integral multiple of the block size of the disk. However, you might want to use smaller buffer sizes for unreliable network connections. For example:


URL u = new URL("http://java.sun.com");
BufferedInputStream bis = new BufferedInputStream(u.openStream( ), 256);

Example 6-4 copies files named on the command line to System.out with buffered reads and writes.

Example 6-4. A BufferedStreamCopier


package com.elharo.io;
import java.io.*;
public class BufferedStreamCopier {
  public static void main(String[] args) {
    try {
      copy(System.in, System.out);
    }
    catch (IOException ex) {
      System.err.println(ex);
    }
  }

  public static void copy(InputStream in, OutputStream out)
   throws IOException {
    BufferedInputStream 
 bin = new BufferedInputStream(in);
    BufferedOutputStream bout = new BufferedOutputStream(out);
    while (true) {
      int datum = bin.read( );
      if (datum == -1) break;
      bout.write(datum);
    }
    bout.flush( );
  }
}

This copy( ) method copies byte by byte, which is normally not very efficient. However, almost all the copies take place in memory, because the input stream and the output stream are buffered. Therefore, this is reasonably quick.

The output stream is deliberately flushed. The data reaches its eventual destination in the underlying stream out only when the stream is flushed or the buffer fills up. Therefore, it's important to call flush( ) explicitly before the method returns.

6.3.1. BufferedInputStream Details

BufferedInputStream only overrides and inherits methods from InputStream. It does not declare any new methods of its own. Marking and resetting are supported.

In Java 1.2 and later, the two multibyte read( ) methods try to fill the specified array or subarray completely by reading repeatedly from the underlying input stream. They return only when the requested number of bytes have been read, the end of stream is reached, or the underlying stream would block. Most other input streams attempt only one read from the underlying stream or data source before returning.

The buffer and the current state of the buffer are stored in protected fields. The buffer itself is a byte array called buf; the number of bytes in the buffer is an int named count; the index of the next byte that will be returned by read( ) is an int called pos; the mark, if any, is an int called markpos; the read-ahead limit before the mark is invalidated is an int called marklimit. Subclasses of BufferedInputStream can directly access all these fields, which can be important for performance.


protected byte[] buf
protected int    count
protected int    pos
protected int    markpos
protected int    marklimit

6.3.2. BufferedOutputStream Details

BufferedOutputStream stores the buffered data in a protected byte array named buf and the index of the next place in the array where a byte will be stored in an int field named pos. BufferedOutputStream does not expose the number of bytes in the buffer.


protected byte buf[]
protected int  pos

Otherwise, BufferedOutputStream has the same write( ), flush( ), and close( ) methods every OutputStream has. These methods are invoked exactly as they would be for any output stream. The only difference is that writes place data in the buffer rather than directly on the underlying output stream. BufferedOutputStream does not declare any new methods.

The range_error Class

2010-02-04T05:29:00.005-08:00


Class Name            range_error

Header File           <stdexcept>

Classification      Exception

Class Relationship Diagram

Class Description

Member Classes

None

Methods



range_error(const string &What_Arg)

Example

Class Description

The range_error class is derived from the runtime_error class.
The range_error class represents exceptions that are occur because
some piece of the software component that causes the exception is attempting
to work with a value that is either to large or to small to represent in
the current environment. The value is a legitimate value but beyond the
representation capabilities of the current machine. This is in contrast
to the out_of_range exception which represents values that are not legitimate
for operation they are involved in. This class represents
a node class and can therefore be used as a base class for user defined classes.



Method            range_error()

Access            Public

Classification    Constructor

Syntax            range_error(const string &What_Arg)      

Parameters        The What_Arg parameter should contain a description of the kind of exception
                  that has occurred.

Return            None

Description

The range_error() method constructs an object of type range_error. The What_Arg parameter
can be used to set a description of the kind of error that this exception represents.
A set possible solutions is sometimes supplied with the exception description in addition
to the type of error.

The Class Relationship Diagram of range_error


    1   
    2   #include <stdexcept>
    3   
    4   
    5   void main(void)
    6   {
    7   
    8   
    9      try{
   10   
   11            exception X;
   12            throw(X);
   13      }
   14      catch(const exception &X)
   15      {
   16          cout << X.what() << endl;
   17   
   18      }
   19   
   20      try
   21      {      
   22          range_error RangeError("Value To Large For Display");
   23          throw(RangeError);
   24      }
   25      catch(const exception &X)
   26      {
   27          cout << X.what() << endl;
   28      }     
   29      
   30   
   31   
   32   }
   33

Create Event Monitor Options

2010-02-04T05:29:00.003-08:00

[ Team LiB ]

Create Event Monitor Options

Options can be specified on the CREATE EVENT MONITOR statement to control the amount of information collected, to determine how the event monitor stops and starts, to specify the location and size of output files or pipes, types and size of buffers, and scope of the event monitor (local or global).

We have already discussed the various types of event monitors that can be created. We will now focus on major event monitor options and associated details.

`WHERE` `event condition`

WHERE event condition is used to specify one of three possible event conditions as follows:

APPL_ID�
Specifies that the application ID of each connection should be compared with the comparison-string in order to determine if the connection should generate CONNECTION, STATEMENT, or TRANSACTION events, if specified.

This option can also be used for specific AUTH_IDs or APPL_NAMES. The comparison-string is a character string that is compared with the APPL_ID, AUTH_ID, or APPL_NAME of each application that connects to the database. If the specific event condition is met, event data is captured.

`WRITE TO`

WRITE TO identifies the target output mechanism that will hold the event monitor data. An event monitor can write to a table, pipe, or file. I will briefly describe how DB2 event monitors write to files and pipes, and then go into much more detail using DB2 event monitors that write to the new event monitor WRITE TO TABLE capability in DB2 v8. When writing event monitors to a PIPE, the event monitor writes the data to the pipe in a single stream, as if it were a single, infinitely long file. When writing data to a pipe, an event monitor does not perform blocked writes. This is important because if there is no room in the pipe buffer, the event monitor will discard the data. The monitoring application using the pipe must read the data without delay to ensure no loss of data.

NOTE

It is uncommon for DBAs to use pipes for event monitors. This is because an application is required to read the data from a pipe; and the application must be started in advance of writing data to a pipe. However, it is common for ISV tools to use pipes, as they provide an application as part of the tool to read the pipe and process the data.

Using a pipe is very efficient and incurs the lowest amount of overhead on the database. However, as indicated, an application is required to read and process the data.

When writing event monitor data to a file (or set of files), the event data streams to files, which follow the following naming convention:

00000000.evt, 00000001.evt, 00000002.evt … nnnnnnn.evt

unless limited by the MAXFILES option.

Even though multiple files may be used, the data is treated as one logical file.

[ Team LiB ]

MPP Configuration Variables

2010-02-04T05:29:00.001-08:00

[ Team LiB ]

MPP Configuration Variables

Variable name	Operating system	Values
`DB2ATLD_PWFILE`	DB2 UDB ESE on AIX, Solaris, and Windows NT	Default = `null` Value: a file path expression
Specifies a path to a file that contains a password used during AutoLoader authentication. If not set, AutoLoader either extracts the password from its configuration file or prompts you interactively. Using this variable addresses password security concerns and allows the separation of AutoLeader configuration information from authentication information. This registry variable is no longer needed, but is retained for backward compatibility.
`DB2CHGPWD_ESE`	DB2 UDB ESE on AIX and Windows NT	Default = `null` Values: `YES` or `NO`
Specifies whether you allow other users to change passwords on AIX or Windows NT ESE systems. You must ensure that the passwords for all partitions or nodes are maintained centrally using either a Windows NT domain controller on Windows NT, or NIS on AIX. If not maintained centrally, passwords may not be consistent across all partitions or nodes. This could result in a password being changed only at the database partition to which the user connects to make the change. In order to modify this global registry variable, you must be at the root directory and on the DAS instance. This variable is required only if you use the old `db2atld` utility instead of the new `LOAD` utility.
`DB2_FORCE_FCM_BP`	AIX	Default = `NO` Values: `YES` or `NO`
This registry variable is applicable to DB2 UDB ESE for AIX with multiple logical partitions. When `DB2START` is issued, DB2 allocates the FCM buffers either from the database global memory or from a separate shared memory segment, if there is not enough global memory available. These buffers are used by all FCM daemons for that instance on the same physical machine. The kind of memory allocated is largely dependent on the number of FCM buffers to be created, as specified by the `fcm_num_buffers` database manger configuration parameter. If the `DB2_FORCE_FCM_BP` variable is set to Yes, the FCM buffers are always created in a separate memory segment so that communication between FCM daemons of different logical partitions on the same physical node occur through shared memory. Otherwise, FCM daemons on the same node communicate through UNIX sockets. Communicating through shared memory is faster, but there is one fewer shared memory segment available for other uses, particularly for database bufferpools. Enabling the `DB2_FORCE_FCM_BP` registry variable thus reduces the maximum size of database bufferpools.
`DB2_NUM_FAILOVER_NODES`	All	Default: `2` Values: `0` to the number of logical nodes
Specifies the number of nodes that can be used as failover nodes in a high availability environment. With high availability, if a node fails, then the node can be restarted as a second logical node on a different host. The number used with this variable determines how much memory is reserved for FCM resources for failover nodes. For example, host A has two logical nodes: `1` and `2`; and host B has two logical nodes: `3` and `4`. Assume `DB2_NUM_FAILOVER_NODES` is set to 2. During `DB2START`, both host A and B will reserve enough memory for FCM so that up to four logical nodes could be managed. Then if one host fails, the logical nodes for the failing host could be restarted on the other host.
`DB2_PARTITIONEDLOAD_DEFAULT`	All supported ESE platforms	Default: `YES` Range of values: `YES/NO`
The `DB2_PARTITIONEDLOAD_DEFAULT` registry variable lets users change the default behavior of the Load utility in an ESE environment when no ESE-specific Load options are specified. The default value is `YES`, which specifies that in an ESE environment if you do not specify ESE-specific Load options, loading is attempted on all partitions on which the target table is defined. When the value is `NO`, loading is attempted only on the partition to which the Load utility is currently connected.
`DB2PORTRANGE`	Windows NT	Values: `nnnn:nnnn`
This value is set to the TCP/IP port range used by FCM so that any additional partitions created on another machine will also have the same port range.

[ Team LiB ]

Using and Modifying the Project

2010-02-04T05:28:00.017-08:00

Using and Modifying the Project

This section explains how to modify the hFinder project for other applications. You see how to modify hFinder in the following ways:

Implement Windows Details view

Modify hFinder so that it resembles a Save As dialog

Create a directory picker dialog from the tree view

As mentioned earlier in this chapter, one of the goals of the hFinder application is to make it reusable for various other aspects of a content management system, and flexible enough to support multiple methods of viewing a directory's contents. The first way you'll modify hFinder is to see what an implementation of Windows Details view looks like.

Windows Details View

This section describes how to implement a new view in the hFinder application, a true-to-Windows Details view. Windows Details view is essentially nothing more than data organized in columns in a table. You can see this in Figure 9-12, which is a screenshot of Windows Details view.

Figure 9-12

As you can see from Figure 9-12 there isn't much to do to implement a Windows-style Details view. It's merely a restructuring of the data into tabular form, and the inclusion of some additional information about a file. To implement the Windows Details view, follow these steps:

Make the following modifications to hFinder.html:


                        </li>
                    </ul>
                </li>
            </ul>
        </div>
        <div id='hfinder-files'>
            <table class='file-wdetails'>
                <colgroup>
                    <col style='width: 16px;' />
                    <col />
                    <col style='width: 10%;' />
                    <col style='width: 20%;' />
                    <col style='width: 20%;' />
                </colgroup>
                <thead>
                    <tr>
                        <th></td>
                        <th>Name</th>
                        <th>Size</th>
                        <th>Type</th>
                        <th>Last Modified</th>
                    </tr>
                </thead>
                <tbody>
                    <tr id='dir-3645' class='file-directory' title='account'>
                        <td>
                         <img src='images/16x16/MacOSXAqua_012.png' alt='folder' />
                        </td>
                        <td class='file-name'>account</td>
                        <td class='file-size'></td>
                        <td class='file-type'>Directory</td>
                        <td class='file-last-modified'>11/26/2005 4:28 PM</td>
                    </tr>
                    <tr id='dir-31' class='file-directory' title='cp'>
                        <td>
                         <img src='images/16x16/MacOSXAqua_012.png' alt='folder' />
                        </td>
                        <td class='file-name'>cp</td>
                        <td class='file-size'></td>
                        <td class='file-type'>Directory</td>
                        <td class='file-last-modified'>11/26/2005 4:30 PM</td>
                    </tr>
                    <tr id='dir-3785' class='file-directory' title='daemons'>
                        <td>
                         <img src='images/16x16/MacOSXAqua_012.png' alt='folder' />
                        </td>
                        <td class='file-name'>daemons</td>
                        <td class='file-size'></td>
                        <td class='file-type'>Directory</td>
                        <td class='file-last-modified'>11/26/2005 4:33 PM</td>

                    </tr>
                    <tr id='dir-3677' class='file-directory' title='file'>
                        <td>
                         <img src='images/16x16/MacOSXAqua_012.png' alt='folder' />
                        </td>
                        <td class='file-name'>file</td>
                        <td class='file-size'></td>
                        <td class='file-type'>Directory</td>
                        <td class='file-last-modified'>11/26/2005 4:34 PM</td>
                    </tr>
                    <tr id='dir-26' class='file-directory' title='forum'>
                        <td>
                         <img src='images/16x16/MacOSXAqua_012.png' alt='folder' />
                        </td>
                        <td class='file-name'>forum</td>
                        <td class='file-size'></td>
                        <td class='file-type'>Directory</td>
                        <td class='file-last-modified'>11/26/2005 4:35 PM</td>
                    </tr>
                    <tr id='dir-3651' class='file-directory' title='home'>
                        <td>
                         <img src='images/16x16/MacOSXAqua_012.png' alt='folder' />
                        </td>
                        <td class='file-name'>home</td>
                        <td class='file-size'></td>
                        <td class='file-type'>Directory</td>
                        <td class='file-last-modified'>11/26/2005 4:37 PM</td>
                    </tr>
                    <tr id='dir-3681' class='file-directory' title='images'>
                        <td>
                         <img src='images/16x16/MacOSXAqua_012.png' alt='folder' />
                        </td>
                        <td class='file-name'>images</td>
                        <td class='file-size'></td>
                        <td class='file-type'>Directory</td>
                        <td class='file-last-modified'>11/26/2005 4:38 PM</td>
                    </tr>
                    <tr id='dir-3690' class='file-directory' title='js'>
                        <td>
                         <img src='images/16x16/MacOSXAqua_012.png' alt='folder' />
                        </td>
                        <td class='file-name'>js</td>
                        <td class='file-size'></td>
                        <td class='file-type'>Directory</td>
                        <td class='file-last-modified'>11/26/2005 4:39 PM</td>
                    </tr>
                    <tr id='dir-30' class='file-directory' title='listener'>
                        <td>
                         <img src='images/16x16/MacOSXAqua_012.png' alt='folder' />
                        </td>
                        <td class='file-name'>listener</td>
                        <td class='file-size'></td>
                        <td class='file-type'>Directory</td>
                        <td class='file-last-modified'>11/26/2005 4:40 PM</td>
                    </tr>

                    <tr id='dir-29' class='file-directory' title='logout'>
                        <td>
                         <img src='images/16x16/MacOSXAqua_012.png' alt='folder' />
                        </td>
                        <td class='file-name'>logout</td>
                        <td class='file-size'></td>
                        <td class='file-type'>Directory</td>
                        <td class='file-last-modified'>11/26/2005 4:41 PM</td>
                    </tr>
                    <tr id='dir-3682' class='file-directory' title='media'>
                        <td>
                         <img src='images/16x16/MacOSXAqua_012.png' alt='folder' />
                        </td>
                        <td class='file-name'>media</td>
                        <td class='file-size'></td>
                        <td class='file-type'>Directory</td>
                        <td class='file-last-modified'>11/26/2005 4:42 PM</td>
                    </tr>
                    <tr id='dir-3667' class='file-directory' title='network'>
                        <td>
                         <img src='images/16x16/MacOSXAqua_012.png' alt='folder' />
                        </td>
                        <td class='file-name'>network</td>
                        <td class='file-size'></td>
                        <td class='file-type'>Directory</td>
                        <td class='file-last-modified'>11/26/2005 4:44 PM</td>
                    </tr>
                    <tr id='dir-3735' class='file-directory' title='products'>
                        <td>
                         <img src='images/16x16/MacOSXAqua_012.png' alt='folder' />
                        </td>
                        <td class='file-name'>products</td>
                        <td class='file-size'></td>
                        <td class='file-type'>Directory</td>
                        <td class='file-last-modified'>11/26/2005 4:45 PM</td>
                    </tr>
                    <tr id='dir-28' class='file-directory' title='register'>
                        <td>
                         <img src='images/16x16/MacOSXAqua_012.png' alt='folder' />
                        </td>
                        <td class='file-name'>register</td>
                        <td class='file-size'></td>
                        <td class='file-type'>Directory</td>
                        <td class='file-last-modified'>11/26/2005 4:46 PM</td>
                    </tr>
                    <tr id='dir-3784' class='file-directory' title='search'>
                        <td>
                         <img src='images/16x16/MacOSXAqua_012.png' alt='search' />
                        </td>
                        <td class='file-name'>search</td>
                        <td class='file-size'></td>
                        <td class='file-type'>Directory</td>
                        <td class='file-last-modified'>11/26/2005 4:47 PM</td>
                    </tr>
                    <tr id='reg-112' class='file-registry-doc'

                        title='File Not Found'>
                        <td>
                            <img src='images/16x16/21.png' alt='text/html' />
                        </td>
                        <td class='file-name' id='freg-112'>404.html</td>
                        <td class='file-size'>900 Bytes</td>
                        <td class='file-type'>text/html</td>
                        <td class='file-last-modified'>11/26/2005 4:49 PM</td>
                    </tr>
                    <tr id='reg-1' class='file-registry-doc' title='Welcome'>
                        <td>
                            <img src='images/16x16/21.png' alt='text/html' />
                        </td>
                        <td class='file-name'>index.html</td>
                        <td class='file-size'>10 KB</td>
                        <td class='file-type'>text/html</td>
                        <td class='file-last-modified'>11/26/2005 4:50 PM</td>
                    </tr>
                </tbody>
           </table>
        </div>
        <div id='hfinder-contextmenu'>
            <ul>
                <li id='context-open' class='sep'>
                    <span style='font-weight: bold;'>Open</span>
                </li>

Save the modifications you made in a new file called hFinder.wDetails.html.

Make the following modifications to views.css:


div.file-highlight-on,
div.file-details.file-highlight-on {
    background: url('images/stripes_darker.png');
    padding: 4px;
}
div.file-highlight-off,
div.file-details.file-highlight-off {
    background: transparent;
    padding: 4px;
    border: none;
}
table.file-wdetails {
    font: 12px sans-serif;
    width: 100%;
}
table.file-wdetails th {
    text-align: left;
}

Save views.css.

The modifications you made result in the output you see in Figure 9-13.

Figure 9-13

The CSS modifications you made were very simple: specify the font, make the <table> housing the file details take up all of the space available to it, and align the <th> fields to the left.

The next section discusses how to modify hFinder to make a Save As dialog.

Save As Dialog

To make a Save As dialog, the modifications are also relatively simple. To see how it's done, follow these steps:

Using the hFinder.list.html file on the source CD-ROM, make the following modifications:


<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
"http://www.w3.org/TR/2002/REC-xhtml1-20020801/DTD/xhtml1-transitional.dtd">
<html xmlns='http://www.w3.org/1999/xhtml' xml:lang='en'>
    <head>
        <meta http-equiv='content-type' content='text/html; charset=utf-8' />
        <meta http-equiv='content-language' content='en-us' />
        <title>hFinder File Management Application</title>

            <!-- compliance patch for microsoft browsers -->
            <!--[if lt IE 7]>
                <link rel='stylesheet'
                      type='text/css'
                      href='styles/hFinder.ie.css' />
                <link rel='stylesheet'
                      type='text/css'
                      href='styles/tree.ie.css' />
                <script type='text/javascript'
                        src='scripts/cssQuery/cssQuery-p.js'></script>
                <script type='text/javascript'
                        src='scripts/png.js'></script>
                <script src="/ie7/ie7-standard-p.js" type="text/javascript">
                </script>
            <![endif]-->
            <link rel='stylesheet' type='text/css' href='styles/hFinder.css' />
          </head>
    <body id='hfinder-dialog'>
        <div id='hfinder-toolbar'>
            <table style='width: 100%; border-collapse: collapse;'>
                <tbody>
                    <tr>
                        <td style='width: 35px;'>
                            <img src='images/back.png'
                                 alt='Back'
                                 title='Back'
                                 class='hfinder-toolbar-control'
                                 id='hfinder-back' />
                        </td>
                        <td style='width: 35px;'>
                            <img src='images/forward.png'
                                 alt='Forward'
                                 title='Forward'
                                 class='hfinder-toolbar-control'
                                 id='hfinder-forward' />
                        </td>
                        <td style='width: 35px;'>
                            <img src='images/refresh.png'
                                 alt='Refresh'
                                 title='Refresh'
                                 class='hfinder-toolbar-control'
                                 id='hfinder-refresh' />
                        </td>
                        <td style='width: 35px;'>
                            <img src='images/home.png'
                                 alt='Home'
                                 title='Home'
                                 class='hfinder-toolbar-control'
                                 id='hfinder-home' />
                        </td>
                        <td>
                           <div id='file-location'>
                               <div id='file-location-inner'>
                                   <img src='images/drop-arrow.png'
                                        id='file-location-arrow'
                                        alt='arrow' />

                                  <ul>
                                      <li title='/'>
                                          <span>Hard drive</span>
                                      </li>
                                      <!--
                                          You may want to test what happens
                                          when multiple directories are included
                                          to do so, remove the comments around
                                          the following <li> element
                                      <li title='/account'>
                                          <span>account</span>
                                      </li>
                                      -->
                                  </ul>
                               </div>
                           </div>
                       </td>
                       <td style='width: 35px;'>
                           <img src='images/views.png'
                                alt='Change Views'
                                title='Change Views'
                                class='hfinder-toolbar-control'
                                id='hfinder-location-change-views' />
                       </td>
                       <td style='width: 35px;'>
                           <img src='images/directory.png'
                                alt='New Directory'
                                title='New Directory'
                                class='hfinder-toolbar-control'
                                id='hfinder-new-directory' />
                       </td>
                       <td style='width: 35px;'>
                           <img src='images/file.png'
                                alt='New File'
                                title='New File'
                                class='hfinder-toolbar-control'
                                id='hfinder-new-file' />
                       </td>
                   </tr>
               </tbody>
           </table>
       </div>
       <div id='hfinder-files'>
           <div id='dir-3645'
                class='file-list file-directory'
                title='account'>
               <div>
                   <div class='file-icon-wrapper'>
                       <img src='images/16x16/MacOSXAqua_012.png'
                            class='file-list-img'
                            alt='folder' />
                   </div>
                   <div class='file-list-caption file-caption-wrapper'>
                       <span class='file-name'>account</span>
                   </div>

           </div>
       </div>
       <div id='dir-31'
            class='file-list file-directory'
            title='cp'>
           <div>
               <div class='file-icon-wrapper'>
                   <img src='images/16x16/MacOSXAqua_012.png'
                        class='file-list-img'
                        alt='folder' />
               </div>
               <div class='file-list-caption file-caption-wrapper'>
                   <span class='file-name'>cp</span>
               </div>
           </div>
       </div>
       <div id='dir-3785'
            class='file-list file-directory'
            title='daemons'>
           <div>
               <div class='file-icon-wrapper'>
                   <img src='images/16x16/MacOSXAqua_012.png'
                        class='file-list-img'
                        alt='folder' />
               </div>
               <div class='file-list-caption file-caption-wrapper'>
                   <span class='file-name'>daemons</span>
               </div>
           </div>
       </div>
       <div id='dir-3677'
            class='file-list file-directory'
            title='file'>
           <div>
               <div class='file-icon-wrapper'>
                   <img src='images/16x16/MacOSXAqua_012.png'
                        class='file-list-img'
                        alt='folder' />
               </div>
               <div class='file-list-caption file-caption-wrapper'>
                   <span class='file-name'>file</span>
               </div>
           </div>
       </div>
       <div id='dir-26'
            class='file-list file-directory'
            title='forum'>
           <div>
               <div class='file-icon-wrapper'>
                   <img src='images/16x16/MacOSXAqua_012.png'
                        class='file-list-img'
                        alt='folder' />
               </div>
               <div class='file-list-caption file-caption-wrapper'>
                   <span class='file-name'>forum</span>
               </div>

           </div>
       </div>
       <div id='dir-3651'
            class='file-list file-directory'
            title='home'>
           <div>
               <div class='file-icon-wrapper'>
                   <img src='images/16x16/MacOSXAqua_012.png'
                        class='file-list-img'
                        alt='folder' />
               </div>
               <div class='file-list-caption file-caption-wrapper'>
                   <span class='file-name'>home</span>
               </div>
           </div>
       </div>
       <div id='dir-3681'
            class='file-list file-directory'
            title='images'>
           <div>
               <div class='file-icon-wrapper'>
                   <img src='images/16x16/MacOSXAqua_012.png'
                        class='file-list-img'
                        alt='folder' />
               </div>
               <div class='file-list-caption file-caption-wrapper'>
                   <span class='file-name'>images</span>
               </div>
           </div>
       </div>
       <div id='dir-3690'
            class='file-list file-directory'
            title='js'>
           <div>
               <div class='file-icon-wrapper'>
                   <img src='images/16x16/MacOSXAqua_012.png'
                        class='file-list-img'
                        alt='folder' />
               </div>
               <div class='file-list-caption file-caption-wrapper'>
                   <span class='file-name'>js</span>
               </div>
           </div>
       </div>
       <div id='dir-30'
            class='file-list file-directory'
            title='listener'>
           <div>
               <div class='file-icon-wrapper'>
                   <img src='images/16x16/MacOSXAqua_012.png'
                        class='file-list-img'
                        alt='folder' />
               </div>
               <div class='file-list-caption file-caption-wrapper'>
                   <span class='file-name'>listener</span>
               </div>

           </div>
       </div>
       <div id='dir-29'
            class='file-list file-directory'
            title='logout'>
           <div>
               <div class='file-icon-wrapper'>
                   <img src='images/16x16/MacOSXAqua_012.png'
                        class='file-list-img'
                        alt='folder' />
               </div>
               <div class='file-list-caption file-caption-wrapper'>
                   <span class='file-name'>logout</span>
               </div>
           </div>
       </div>
       <div id='dir-3682'
            class='file-list file-directory'
            title='media'>
           <div>
               <div class='file-icon-wrapper'>
                   <img src='images/16x16/MacOSXAqua_012.png'
                        class='file-list-img'
                        alt='folder' />
               </div>
               <div class='file-list-caption file-caption-wrapper'>
                   <span class='file-name'>media</span>
               </div>
           </div>
       </div>
       <div id='dir-3667'
            class='file-list file-directory'
            title='network'>
           <div>
               <div class='file-icon-wrapper'>
                   <img src='images/16x16/MacOSXAqua_012.png'
                        class='file-list-img'
                        alt='folder' />
               </div>
               <div class='file-list-caption file-caption-wrapper'>
                   <span class='file-name'>network</span>
               </div>
           </div>
       </div>
       <div id='dir-3735'
            class='file-list file-directory'
            title='products'>
           <div>
               <div class='file-icon-wrapper'>
                   <img src='images/16x16/MacOSXAqua_012.png'
                        class='file-list-img'
                        alt='folder' />
               </div>
               <div class='file-list-caption file-caption-wrapper'>
                   <span class='file-name'>products</span>
               </div>

           </div>
       </div>
       <div id='dir-28'
            class='file-list file-directory'
            title='register'>
           <div>
               <div class='file-icon-wrapper'>
                   <img src='images/16x16/MacOSXAqua_012.png'
                        class='file-list-img'
                        alt='folder' />
               </div>
               <div class='file-list-caption file-caption-wrapper'>
                   <span class='file-name'>register</span>
               </div>
           </div>
       </div>
       <div id='dir-3784'
            class='file-list file-directory'
            title='search'>
           <div>
               <div class='file-icon-wrapper'>
                   <img src='images/16x16/MacOSXAqua_012.png'
                        class='file-list-img'
                        alt='search' />
               </div>
               <div class='file-list-caption file-caption-wrapper'>
                   <span class='file-name'>search</span>
               </div>
           </div>
       </div>
       <div id='reg-112'
            class='file-list file-registry-doc'
            title='File Not Found'>
           <div>
               <div class='file-icon-wrapper'>
                   <img src='images/16x16/21.png'
                        title='text/html'
                        alt='text/html'
                        class='file-list-img' />
               </div>
               <div class='file-list-caption file-caption-wrapper'>
                   <span class='file-name' id='freg-112'>404.html</span>
               </div>
           </div>
       </div>
       <div id='reg-1'
            class='file-list file-registry-doc'
            title='Welcome'>
           <div>
               <div class='file-icon-wrapper'>
                   <img src='images/16x16/21.png'
                        alt='text/html'
                        title='text/html'
                        class='file-list-img' />
               </div>
               <div class='file-list-caption file-caption-wrapper'>

                       <span class='file-name' id='freg-1'>index.html</span>
                   </div>
               </div>
           </div>
       </div>
       <div id='hfinder-dialog-controls'>
           <form action='javascript:void(0);' method='post'>
               <table>
                   <colgroup>
                       <col />
                       <col style='width: 5%;' />
                       <col style='width: 5%;' />
                   </colgroup>
                   <tbody>
                       <tr>
                           <td><input type='text'
                                      name='fname' value='' id='file-name' /></td>
                           <td><input type='submit'
                                      name='save' value='Save' /></td>
                           <td><input type='submit'
                                      name='cancel' value='Cancel' /></td>
                       </tr>
                   </tbody>
               </table>
           </form>
       </div>
       <div id='hfinder-contextmenu'>
           <ul>
               <li id='context-open' class='sep'>
                   <span style='font-weight: bold;'>Open</span>
               </li>
               <li id='context-control-panel'>
                   <span>Control Panel</span>
               </li>
               <li id='context-title-description' class='sep'>
                   <span>Modify Title and Description</span>
               </li>
               <li id='context-delete'>
                   <span>Delete</span>
               </li>
               <li id='context-rename' class='sep'>
                   <span>Rename</span>
               </li>
               <li id='context-properties'>
                   <span>Properties</span>
               </li>
               <li id='context-permissions'>
                   <span>Permissions</span>
               </li>
           </ul>
       </div>

Save the preceding modifications as hFinder.saveas.html.

Make the following modifications to hFinder.css:


div#hfinder-tree {
    position: absolute;
    top: 0;
    bottom: 0;
    left: 0;
    margin: 73px 0 10px 10px;
    width: 190px;
    background: white;
    overflow: auto;
    border: 1px solid rgb(128, 128, 128);
    z-index: 1;
}
div#hfinder-files {
    margin: 73px 10px 10px 210px;
    position: absolute;
    top: 0;
    bottom: 0;
    left: 0;
    right: 0;
    border: 1px solid rgb(128, 128, 128);
    background: white url('../images/stripes.png');
    z-index: 1;
    overflow: auto;
}
body#hfinder-dialog div#hfinder-toolbar {
    margin: 10px 10px 0 10px;
}
body#hfinder-dialog div#hfinder-files {
    margin: 53px 10px 53px 10px;
}
div#hfinder-dialog-controls {
    position: absolute;
    bottom: 0;
    left: 0;
    right: 0;
    margin: 0 7px 0 7px;
}
div#hfinder-dialog-controls input#file-name {
    background: white url('../images/stripes.png');
    width: 98%;
}
div#hfinder-dialog-controls table {
    width: 100%;
}
div#file-location {
    height: 30px;
    position: relative;
    z-index: 2;
}
div#file-location-inner {
    background: white url('../images/stripes.png');
    height: 30px;

    overflow: hidden;
    border: 1px solid rgb(128, 128, 128);
    font: 12px sans-serif;
    position: absolute;
    top: 0;
    left: 0;
    right: 0;
}
div#file-location ul {
    list-style: none;
    margin: 0;
    padding: 0;
    position: absolute;
    bottom: 0;
    left: 0;
}
div#file-location ul li {
    height: 30px;
    white-space: nowrap;
    overflow: hidden;
    background: url('../images/24x24/MacOSXAqua_012.png') no-repeat 10px center;
    padding-left: 40px;
}
div#file-location ul li span {
    line-height: 30px;
    vertical-align: middle;
}
div#file-location ul li:first-child {
    background: url('../images/24x24/MacOSXAqua_037.png') no-repeat 10px center;
}
img#file-location-arrow {
    position: absolute;
    top: 5px;
    right: 5px;
}

Save hFinder.css.

The result of the modifications is shown in Figure 9-14.

Figure 9-14

This series of modifications was quite a bit more complicated than implementing Windows-style Details view. In the Save As dialog you've removed the menus and the tree view, where the file location input was. A <div> and <ul> were added, which are intended to be the drop-down menu functionality that you find in a Save As dialog. This can be seen in Figure 9-15.

Figure 9-15

Figure 9-16 shows the same dialog with the drop-down dialog closed.

Figure 9-16

The drop-down navigation in hFinder is more simplified than that used by Windows. Because for this application there are not multiple drives to display, the drop-down navigation in hFinder is intended to show only the file path to the directory the user is currently viewing, and provide an easy method to jump to the other directories in that hierarchy.

When the user is browsing the file system, this box can be populated with the current file path. To the right of the drop-down navigation, a new icon for changing file views is added, and the Go icon was removed. Beneath the <div> element containing files and directories is a new form, which would be used to enter the new file name for the file you're saving.

In hFinder.css, you made some modifications to accommodate the Save As dialog. The first rule you applied takes advantage of the id name you applied to the <body> element. The addition of the id name to the <body> element allows you to override other style sheet rules via the cascade. In that first rule, you override the margin applied to the <div> with an hfinder-toolbar id name; its margin is reduced in response to removing the top menus File, View, Admin, and Help:


body#hfinder-dialog div#hfinder-toolbar {
    margin: 10px 10px 0 10px;
}

As was the case in the previous rule, the margin for the <div> with an hfinder-files id name also needed a margin adjustment to facilitate the removal of the tree view and the menus from the top. The bottom margin also needed to be larger to make room for the new form at the bottom of the document:


body#hfinder-dialog div#hfinder-files {
    margin: 53px 10px 53px 10px;
}

Because the <div> containing the files and directories is positioned absolutely, any element inserted after it must be positioned absolutely as well. The <div> housing the form at the bottom of the hFinder document (which provides controls for a user to enter a new file name to save a document) is positioned absolutely to the bottom of the viewport, and stretched from the left to the right border of the viewport. Then left and right margins are adjusted to line up the form with the <div> housing directories and files above it:


div#hfinder-dialog-controls {
    position: absolute;
    bottom: 0;
    left: 0;
    right: 0;
    margin: 0 7px 0 7px;
}

The <input /> element for new file names is given a width of 98% and a pinstripe background:


div#hfinder-dialog-controls input#file-name {
    background: white url('../images/stripes.png');
    width: 98%;
}

The <table> housing the <input /> for a new file name and the Save and Cancel buttons is then given a width of 100%:


div#hfinder-dialog-controls table {
    width: 100%;
}

The <div> at the top of the document that houses the new drop-down navigation control is next to be styled. It receives an explicit height of 30 pixels; a relative position so that descendant elements positioned absolutely will position relative to it, and a position along the z-axis:


div#file-location {
    height: 30px;
    position: relative;
    z-index: 2;
}

The following rule is for the <div> nested within the "file-location" <div> element. It has a file-location-inner id name. A nested <div> is required for purposes of layering. Because a position: relative; declaration has no effect when applied to a <td> element, a nested <div> element allows you to circumvent the need to apply position: relative; to the <td> element. Now armed with an element to position relative to, the nested file-location-inner <div> element is positioned absolutely, relative to its parent. It receives a pinstripe background and a height of 30 pixels. The overflow: hidden; declaration prevents descendant content that is larger than the boundaries of the file-location-inner <div> element from being seen, and plays a large role in developing a drop-down menu that displays only the last directory in the current file path. More on that when you get to the next rule. A 12-pixel, generic sans-serif font is specified. Finally, the <div> is stretched for the entire width of the element it is positioned relative to, its parent. Stretching the element lets it resize with the width of the window:


div#file-location-inner {
    background: white url('../images/stripes.png');
    height: 30px;
    overflow: hidden;
    border: 1px solid rgb(128, 128, 128);
    font: 12px sans-serif;
    position: absolute;
    top: 0;
    left: 0;
    right: 0;
}

Within the drop-down navigation <div>, the current file path is housed in a <ul> element, which would be changed by a JavaScript to reflect the file path for whatever directory the user is currently viewing. As would be the case in a Windows Save As dialog, only the very last directory in the path is visible when the drop-down navigation is inactive. To make this work with CSS, the parent file-location-inner <div> element is given an explicit height of 30 pixels, and the overflow: hidden; declaration. When those properties are applied with those of the <ul> element and its children, the result is a drop-down navigation system in which only the last directory in the file path is visible. Ancestor directories in the current file path that exist in the markup are invisible to the user until the user accesses the drop-down navigation, which would be done by attaching a JavaScript onclick event to the file-location-inner <div>. On clicking the file-location-inner <div>, the <div>'s height is adjusted so that all of the directories in the path are visible, thereby giving the user a method to easily navigate to directories in the current file path:


div#file-location ul {
    list-style: none;
    margin: 0;
    padding: 0;
    position: absolute;
    bottom: 0;
    left: 0;
}

To hide the ancestor directories that exist in the markup but must be invisible until the drop-down navigation is accessed, the <ul> element is positioned absolutely to the left and bottom of the file-location-inner <div>. Then its children <li> elements are each given a height of 30 pixels, and some properties to ensure that height is always honored. Though most browsers honor an explicit height, Explorer does not always honor an explicit height if an element has more content than the height allows. The height is forced to be honored by the white-space: nowrap; and overflow: hidden; declarations. Now if a directory's name is too long to fit, it will be clipped at the width of the <li> element. Then each directory needs an icon; MacOSXAqua_012.png is the folder icon. It is positioned 10 pixels offset from the left of the <li> element and centered vertically. The padding-left: 40px; declaration prevents the text of the directory name from overlapping the icon. One essential element of a Save As dialog drop-down navigation is not accomplished with the CSS as it is written here, and that is indenting the directories in the path to show their relationship with one another. This is another aspect of the application that must be done with the JavaScript. In the completed application, the offset of the background image and the padding-left property would be adjusted in the JavaScript to indent each descendant directory a little further to the right:


div#file-location ul li {
    height: 30px;
    white-space: nowrap;
    overflow: hidden;
    background: url('../images/24x24/MacOSXAqua_012.png') no-repeat 10px center;
    padding-left: 40px;
}

Next the text of the directory name must be adjusted so that it is centered vertically just as the icon was in the preceding rule. The text is centered vertically by adjusting the line-height of the <span> element to 30 pixels (same height as the parent <li> element), and then applying the vertical-align: middle; declaration. A nested <span> element is required here because the vertical-align property only applies to inline or <tr>, <th>, or <td> elements. Because the purpose of the vertical-align property is to align text vertically relative to a line's baseline (as applied to inline elements), the line-height must be first adjusted to match the height of the parent <li> element for the vertical-align property to provide the desired results:


div#file-location ul li span {
    line-height: 30px;
    vertical-align: middle;
}

The topmost directory is always the first in the list. This directory is special because it is the root directory. It receives a different icon than the other directories, and this is done via the :first-child pseudo-class. The image, MacOSXAqua_037.png, is a Mac hard drive icon:


div#file-location ul li:first-child {
    background: url('../images/24x24/MacOSXAqua_037.png') no-repeat 10px center;
}

The last rule positions the arrow for the drop-down navigation. It places the arrow 5 pixels from the top and right of the file-location <div> element:


img#file-location-arrow {
    position: absolute;

    top: 5px;
    right: 5px;
}

The last alternative implementation of hFinder is how to make a Choose a Directory dialog.

Choose a Directory Dialog

As you've seen throughout this project, hFinder is a complex application that can serve many different functions relating to file management. In fact, I could have spent the entire book on just hFinder alone. Although hFinder is by no means a complete application, you see what's required to handle the presentational aspects of such an application, and what's required to alter such an application to fit different purposes.

In the final alternative implementation of hFinder, you see what goes into creating a Choose a Directory dialog. This time you use the tree view, not the directory view. A Choose a Directory dialog, also known as a Browse for Folder dialog, looks like the one in Figure 9-17, which happens to be from the Windows version of iTunes.

Figure 9-17

To make a Choose a Directory dialog, follow these steps:

Make the following alterations to hFinder.html:


<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
"http://www.w3.org/TR/2002/REC-xhtml1-20020801/DTD/xhtml1-transitional.dtd">
<html xmlns='http://www.w3.org/1999/xhtml' xml:lang='en'
      id='hfinder-directory-dialog'>
    <head>
        <meta http-equiv='content-type' content='text/html; charset=utf-8' />
        <meta http-equiv='content-language' content='en-us' />
        <title>hFinder File Management Application</title>
        <link rel='stylesheet' type='text/css' href='styles/hFinder.css' />
    </head>
    <body>
        <h4>Choose a Directory...</h4>
        <div id='hfinder-tree'>
            <ul class='file-tree'>
                <li>
                    <div class='file-tree-directory file-tree-root'
                         id='tree-dir-1'>
                        <span>Hard drive</span>
                    </div>
                    <ul id='directory-1' class='file-tree-dir-list'>
                        <li>
                            <div class='file-tree-directory'
                                 id='tree-dir-3645'>
                                <span>account</span>
                            </div>
                            <img src='images/right.png'
                                 class='file-has-children'
                                 id='tree-3645'
                                 alt='+'
                                 title='Click to expand.' />
                        </li>
                        <li>
                            <div class='file-tree-directory'
                                 id='tree-dir-31'>
                                <span>cp</span>
                            </div>
                        </li>
                        <li>
                            <div class='file-tree-directory'
                                 id='tree-dir-3785'>
                                <span>daemon</span>
                            </div>
                        </li>
                        <li>
                            <div class='file-tree-directory'
                                 id='tree-dir-3677'>
                                <span>file</span>
                            </div>
                       </li>
                       <li>
                            <div class='file-tree-directory'
                                 id='tree-dir-26'>
                                <span>forum</span>
                            </div>

                       </li>
                       <li>
                           <div class='file-tree-directory'
                                id='tree-dir-3651'>
                               <span>home</span>
                           </div>
                           <img src='images/right.png'
                                class='file-has-children'
                                id='tree-3651'
                                alt='+'
                                title='Click to expand.' />
                       </li>
                       <li>
                           <div class='file-tree-directory'
                                id='tree-dir-3681'>
                               <span>images</span>
                           </div>
                           <img src='images/right.png'
                                class='file-has-children'
                                id='tree-3681'
                                alt='+'
                                title='Click to expand.' />
                       </li>
                       <li>
                           <div class='file-tree-directory'
                                id='tree-dir-3690'>
                               <span>js</span>
                           </div>
                           <img src='images/right.png'
                                class='file-has-children'
                                id='tree-3690'
                                alt='+'
                                title='Click to expand.' />
                       </li>
                       <li>
                           <div class='file-tree-directory'
                                id='tree-dir-30'>
                               <span>listener</span>
                           </div>
                       </li>
                       <li>
                           <div class='file-tree-directory'
                                id='tree-dir-29'>
                               <span>logout</span>
                            </div>
                       </li>
                       <li>
                            <div class='file-tree-directory'
                                 id='tree-dir-3682'>
                                <span>media</span>
                            </div>
                            <img src='images/right.png'
                                 class='file-has-children'
                                 id='tree-3682'
                                 alt='+'
                                 title='Click to expand.' />

                       </li>
                       <li>
                           <div class='file-tree-directory'
                                id='tree-dir-3667'>
                               <span>network</span>
                           </div>
                       </li>
                       <li>
                           <div class='file-tree-directory'
                                id='tree-dir-3735'>
                               <span>products</span>
                           </div>
                           <img src='images/right.png'
                                class='file-has-children'
                                id='tree-3735'
                                alt='+'
                                title='Click to expand.' />
                       </li>
                       <li>
                           <div class='file-tree-directory'
                                id='tree-dir-28'>
                               <span>register</span>
                           </div>
                       </li>
                       <li>
                           <div class='file-tree-directory'
                                id='tree-dir-3784'>
                               <span>search</span>
                           </div>
                       </li>
                   </ul>
               </li>
           </ul>
        </div>
        <div id='hfinder-dialog-controls'>
            <form action='javascript:void(0);' method='post'>
                <table>
                    <colgroup>
                        <col />
                        <col style='width: 5%;' />
                        <col style='width: 5%;' />
                    </colgroup>
                    <tbody>
                        <tr>
                            <td><input type='submit'
                                       name='new_directory'
                                       value='New Directory' /></td>
                            <td><input type='submit' name='ok' value='Ok' /></td>
                            <td><input type='submit'
                                       name='cancel' value='Cancel' /></td>
                        </tr>
                    </tbody>
                </table>
            </form>
        </div>
    </body>
</html>

Save the altered file as hFinder.chooseDirectory.html.

Using the version of hFinder.css you created to make a Save As dialog in the previous section, make the following modifications:


@import 'menus.css';
@import 'views.css';
@import 'tree.css';
@import 'popup.css';

body,
html {
    width: 100%;
    height: 100%;
    min-width: 500px;
    min-height: 300px;
}
body {
    padding: 0;
    margin: 0;
    background: url('../images/brushed_metal.png');
    -moz-user-select: none;
}
html#hfinder-directory-dialog,
html#hfinder-directory-dialog body {
    min-width: 200px;
}
div#hfinder-toolbar {
    position: absolute;
    top: 0;
    left: 0;
    right: 0;
    margin: 28px 10px 0 10px;
}
html#hfinder-directory-dialog h4 {
    font: normal 12px sans-serif;
    position: absolute;
    margin: 0;
    top: 15px;
    left: 10px;
}
html#hfinder-directory-dialog div#hfinder-tree {
    margin: 43px 10px 53px 10px;
    right: 0;
    width: auto;
}
div#hfinder-tree {
    position: absolute;
    top: 0;
    bottom: 0;
    left: 0;
    margin: 73px 0 10px 10px;
    width: 190px;
    background: white;

    overflow: auto;
    border: 1px solid rgb(128, 128, 128);
    z-index: 1;
}

Save hFinder.css.

The result of the modifications is shown in Figure 9-18.

Figure 9-18

The modifications required to create a Choose a Directory dialog are few. In hFinder.html, you removed the menus, toolbar, popups, and directory view window, then added a button for the creation of a new directory, and OK and Cancel buttons. These controls are housed in a <div> named hfinder-dialog-controls, which was the same name used for the <div> element housing controls in the Save As dialog of the last section. The relevant CSS you applied for the Save As dialog for the hfinder-dialog-controls <div> is reused for the Choose a Directory dialog.

The CSS you applied to create the Choose a Directory dialog was only a few lines, and most of it was used to override, via the cascade, the default rules used for the original hFinder application. To facilitate this you added an id name to the <html> element, hfinder-directory-dialog. The first rule you added in hFinder.css overrides the default minimum width. The default minimum width was too large for a Choose a Directory dialog, which need not be very wide to be usable:


html#hfinder-directory-dialog,
html#hfinder-directory-dialog body {
    min-width: 200px;
}

Then, in the markup you added a new <h4> element with the text "Choose a Directory…". This element is styled in hFinder.css with the following rule:


html#hfinder-directory-dialog h4 {
    font: normal 12px sans-serif;
    position: absolute;
    margin: 0;
    top: 15px;
    left: 10px;
}

The <h4> element's font is set to remove the bold face, with the normal keyword, and then set to 12-pixel, generic sans-serif. The default margin is removed, and then the element is positioned absolutely 15 pixels from the top and 10 pixels from the left of the viewport.

The last rule added to hFinder.css overrides the margin and width for the hfinder-tree <div> and sets the right offset property to zero so that the hfinder-tree <div> is stretched for the whole width of the window:


html#hfinder-directory-dialog div#hfinder-tree {
    margin: 43px 10px 53px 10px;
    right: 0;
    width: auto;
}

With the presentation of the hFinder set in place, it can now go on to become a much more complex application with the help of JavaScript, and a server-side language such as PHP, Java, Perl, and so on.

12.5 Conclusion

2010-02-04T05:28:00.015-08:00

< Day Day Up >

12.5 Conclusion

In this chapter we looked at some of the critical administrative functions that database administrators perform in their day-to-day work schedule. Backing up a database protects against potential loss or corruption of the data due to various reasons that may or may not be within human control. To provide this solution, we looked at the various types of backup options in Oracle and focused on RMAN. RMAN provides a comprehensive solution leading towards a 24 hours a day, 7 days a week operation, where no downtime is required for backing up the data. RMAN provides this functionality through the various backup strategies such as full, cumulative, and incremental backups. Incremental backups allow the opportunity for frequent backups, because Oracle only backs up data blocks that have changed since the previous backup.

We discussed the fact that while developing a compressive backup and recovery strategy is important, it is equally important to schedule testing of the backup and recovery strategy to ensure that the changes in business conditions and economic conditions have not invalidated this strategy.

Backups are taken to help recover the database from failures. Under this subject we discussed the various kinds of failures in a stand-alone Oracle configuration and the additional kinds of failures in a RAC configuration, for example the GCS failures. During these failure scenarios we also discussed how the data is recovered under these circumstances.

Recovery is not always done from backups and not always done by Oracle. There are certain features available in Oracle where a database administrator could perform operations by going back into the past and retrieving database activities. Tools such as flashback queries and LogMiner provide this opportunity.

In Chapter 15, we will start discussions on performance tuning of a RAC configuration. However, before we dive into this subject, let us discuss the various tools that would help make the performance tuning activity easy. The next chapter will discuss the tools and utilities used in performance tuning.

< Day Day Up >

Program 110: Short Time III

2010-02-04T05:28:00.013-08:00

Program 110: Short Time III

Program 109 has been fixed. Now the delay is closer to what we expect. Not exactly what we expect, but close. What's happening now?


  1 /***********************************************
  2  * bit_delay -- Delay one bit time for         *
  3  *      serial output,                         *
  4  *                                             *
  5  * Note: This function is highly system        *
  6  *      dependent.  If you change the          *
  7  *      processor or clock it will go bad.     *
  8  ***********************************************/
  9 void bit_delay(void)
 10 {
 11     int i;      // Loop counter
 12     volatile int result;// Result of the multiply
 13
 14     // Factors for multiplication
 15     int factorl = 12;
 16     int factor2 = 34;
 17
 18     // We know that 1863 multiplies
 19     // delay the proper amount
 20     for (i = 0; i < 1863; ++i)
 21     {
 22         result = factor1 * factor2;
 23     }
 24 }

(Next Hint 95. Answer 39.)

2.7 Disk configuration

2010-02-04T05:28:00.011-08:00

< Day Day Up >

2.7 Disk configuration

We looked at the benefits of clustered systems and clustered interconnects in the previous sections. What good are those without the storage systems? Under the hardware configuration, we have seen through evolution of the various technologies like SMP, MPP, etc.; similarly, under the storage tier also we have some details and choices of configurations that should be discussed, like the SAN, NAS, or the traditional direct access architectures. Prior to discussing these configurations, let us look at the basic disk configurations. A disk by itself, like any other equipment, is prone to failures and can have performance issues, especially when many users are accessing one disk. There could be a large amount of I/O contention/ backlogging of user requests, which in turn would create a replicated effect on performance of the system. So the option is to combine multiple disks so that the files could be spread across the disks.

Having multiple disks would not directly solve the issues with I/O contention. It does improve I/O compared to a single disk configuration; however, the contention could still exist and performance issues on the system with a large number of users would remain significantly high.

The next alternative would be to combine these disks and stripe them across all the disks, creating volumes and files that could reside in each volume or stripe. What this means is that multiple users accessing these files could potentially be accessing the files at different locations, thus accessing different disks and reducing performance bottlenecks. In general, striping offers a performance gain by spreading out the I/Os across many channels and devices. This reduces contention and enables throughput beyond the capacity of a single channel or device. The performance gain depends on the database layout, workload, and access patterns. Performance gains should be compared to the costs associated with setting up, managing, and maintaining (extending and reducing) striped volumes.

While striping helps provide distribution of I/O, spreading it across multiple spindles, how about availability? When one disk fails, then data for that stripe probably will not be available. As we discussed in Section 2.4.3 (High Availability), redundancy should be provided at every tier, which includes the storage subsystem. The technology that provides redundancy at the disk level is called mirroring, where every time information is recorded onto one disk it is immediately copied over to another disk. Mirroring functionality could be done either via a software process or through hardware configuration.

An ideal solution would be a combination of both, i.e., a disk configuration that has both options of striping and mirroring because proper storage configuration is vital to the performance of the data tier. The industry has various configuration options available today, and each configuration is used for a specific type of implementation. While most of the scenarios work properly, some of them are better for specific implementation categories over the others. Let us look at some details in this area of disk configuration and elaborate on some of the options available in this tier.

2.7.1 RAID

RAID is the technology for expanding the capacity of the I/O system and providing the capability for data redundancy. RAID stands for redundant array of inexpensive disks. It is the use of two or more physical disks to create one logical disk, where the physical disks operate in tandem to provide greater size and more bandwidth. RAID provides scalability and high availability in the context of I/O and system performance.

RAID implementations can be made at the hardware level or at the software level. Software-based RAID implementations have considerable overhead and consume resources, including CPU and memory. Hardware RAID implementations are more popular than software RAID implemen tations because they have less resource overhead.

RAID 0

RAID 0 provides striping, where a single data partition is physically spread across all the disks in the stripe bank, effectively giving that partition the aggregate performance of all the component disks combined. The unit of granularity for spreading the data across the drives is called the stripe size or chunk size. Typical settings for the stripe size are 32 KB, 64 KB, and 128 KB.

The following are benefits that striping provides:

Load balancing: In a database environment some files are always busier than other files; therefore, I/O load on the system needs to be balanced. In a non-striped environment this causes a hot spot on the disk and results in poor response times. The exposure to hot spots is significantly reduced using a striped disk array, because each file is very thinly spread across all the disks in the stripe bank. The result of this spreading of files is random load balancing. This is very effective in a high-volume, high-transactional, very large online transaction processing system (OLTP).

Concurrency: In a random access environment the overall concurrency of each file is increased. For example, if a file exists on a single disk, only one read or write can be executed against that file at any one time. The reason for this is physical, because the disk drive has only one set of read/write heads. By striping (RAID 0 configuration), many reads and writes can be active at any one time, up to the number of disks in the stripe set.

The effects of striping in both sequential and random access environments make it very attractive from a performance standpoint. However, the downside of this is that RAID 0 configuration has no built in redundancy and is highly exposed to failure. If a single disk in a stripe set fails, the whole stripe set is effectively disabled.

In the scenario shown in Figure 2.17 where there are eight disks all striped across in d different stripes or partitions, the MTBF for each disk is now divided by eight, and the amount of data that is not available is eight times that of a single disk.

Figure 2.17: RAID 0.

RAID 1

RAID 1 is known as mirroring and is where all the writes issued to a given disk are duplicated to another disk. This provides for disk availability; if there is a failure of the first disk, the second disk or mirror can take over without any data loss.

The write operation to both disks happens in parallel. When the write is ready to be issued, it is set up and sent to DISK A. Without waiting for that write process to complete (as in a sequential write), the write to DISK B is initiated. However, when the host wants to read from the disk (in a mirrored configuration) it takes advantage of the two disks. Depending on the implementation, the host will elect to round-robin (100% gain in read capacity) all read requests to alternate disks in the mirrored set or to send the request to the drive that has its head closest to the required track.

The biggest advantage in mirrored configuration (RAID 1) is the benefit when one disk or one side of the mirror fails, causing the system to start using exclusively the other side of the mirror for all read/write requests. As a result of this failure the read capability is reduced by 50%. Once replacing or repairing the failed component restores the failed side of the mirror, bringing a disk back online will involve physically copying the surviving mirrored disk onto the replaced peer. This process is called resilvering. These mirrored disks can be placed independent of each other or can be placed in a disk array.

In an Oracle environment, RAID 1 is good for both online and archived redo logs. Writing to these files is performed in a sequential fashion. The write head of the disk is located near the last write operation giving performance enhancements. However, more than one RAID 1 volume is required to allow continuous read and write operations to the redo logs and to allow archive logs to read the previous redo logs. This allows for optimal performance, and it is also required to eliminate contention between LGWR and ARCH background processes.

RAID 0 + 1

RAID 0 + 1 (or RAID 01) is a combination of levels 0 and 1. RAID 0 + 1 does exactly what its name implies, that is, stripes and mirrors disks; for example, it stripes first, then mirrors what was just striped. RAID 0 + 1 provides good write and read performance and redundancy without the overhead of parity calculations. Parity is a term for error checking. Parity algorithms contain error correction code (ECC) capabilities, which calculate parity for a given stripe or chunk of data within a RAID volume.

The advantages of both RAID level 0 and RAID level 1 apply in this situation and are illustrated in Figure 2.18, which shows a four-way striped mirrored volume with eight disks (A–H). A given stripe of data (Data 01) in a file is split/striped across disks A–D with the stripe first and then mirrored across disks E–H. The drawback in this RAID configuration/scenario is that when one of the pieces, for example, Data 01 on Disk A, becomes unavailable due to a disk failure on Disk A, the entire mirror member becomes unavailable. The entire mirror member is lost, which reduces the I/O capacity during reads on the volume by 50%.

Figure 2.18: RAID 01.

RAID 1 + 0

RAID 1 + 0 (or RAID 10) is also a combination of the RAID levels 0 and 1 discussed in the previous sections. This combination is also true for RAID 0 + 1. However, in RAID 10 the disks are mirrored and then striped; for example, mirror first, then stripe what was mirrored. All the advantages that apply to the previous RAID configuration apply to this RAID configuration. However, the organization of mirrored sets is different from the previous configuration.

In Figure 2.19, Data 01 is mirrored on the adjoining disks (A and B) and Data 02 is mirrored on the subsequent two disks (C and D), etc. This configuration also contains eight mirrored and striped disks.

Figure 2.19: RAID 10.

The advantage in the RAID 10 configuration over the RAID 01 configuration is, if there is a loss of one disk in a mirrored member, the entire member of the mirrored volume does not become unavailable. This configuration is better suited for high availability. The I/O capacity that results from the failure of a mirror member does not reduce its I/O capacity by 50%. RAID 10 configurations must be the preferred implementation choice for an OLTP implementation.

RAID 5

Under RAID 5, parity calculations provide data redundancy, and the parity is stored with the data. This means that the parity is distributed across the number of drives configured in the volume.

Figure 2.20 illustrates the physical placement of stripes (Data 01 through Data 04) with their corresponding parities distributed across the five disks in the volume. This is a four-way, striped RAID 5 volume where data and parity are distributed.

Figure 2.20: RAID 5.

RAID 5 is unsuitable for OLTP because of extremely poor performance of small writes at high concurrency levels. This is because the continuous processes of reading a stripe, calculating the new parity, and writing the stripe back to the disk (with new parity) will make writing significantly slower.

In an Oracle environment, rollback segments and redo logs are accessed sequentially (usually for writes) and are not suitable candidates for being placed on a RAID 5 device. Also, data files belonging to temporary tablespaces are not suitable for placement on a RAID 5 device. Another reason the redo logs should not be placed on RAID 5 devices is related to the type of caching (if any) being done by the RAID system. Given the critical nature of the contents of the redo logs, catastrophic loss of data could ensue if the contents of the cache are not written to the disk, for example, because of a power failure, when Oracle was notified that they had been written. This is particularly true of write-back caching, where the write is assumed to have been written to the disk when it has only been written to the cache. Write-through caching, where the write is assumed to have completed when it has reached the disk, is much safer but still not recommended for redo logs for the reason mentioned earlier.

RAID 5 configurations should be preferred where the read patterns are random and are not very bulky in nature. This is because the spindles in a RAID 5 volume work in an independent fashion. For example, all the disks in a given volume can potentially service multiple I/O requests from different disk locations. RAID 5 should be considered for data warehouse (DW), data mining (DM), and operational data store (ODS) applications where data refreshes occur in the off-hours.

2.7.2 Stripe and mirror everything

The ''stripe and mirror everything'' concept for disk configuration is more commonly known as SAME. This model is based on two key proposals, (1) stripe all files across all disks using a 1 megabyte stripe width, and (2) mirror data for high availability.

2.8 Storage system architectures

Striping all files across all disks ensures that full bandwidth of all the disks is available for any operation. This equalizes load across disk drives and eliminates hot spots. The recommendation of using a stripe size of 1 megabyte is based on transfer rates and throughputs of modern disks. If the stripe size is very small, more time is spent positioning the disk head on the data, than in the actual transfer of data. Based on internal studies, we have determined that a size of 1 megabyte achieves reasonably good throughput, while anything smaller does not provide adequate throughput.

Mirroring data at the storage subsystem level is the best way to avoid data loss. The only way to lose data in a mirrored environment is to lose multiple disks simultaneously. Given that current disk drives are highly reliable, simultaneous multiple disk failure is a very low probability event.

The primary benefit of the SAME model is that it makes storage configuration very easy and suitable for all workloads. It works equally well for OLTP, data warehouse, and batch workloads. It eliminates I/O hot spots and maximizes bandwidth. Finally, the SAME model is not tied to any storage management solution in the market today and can be implemented with the technology available today.

< Day Day Up >

Introduction

2010-02-04T05:28:00.009-08:00

Introduction

Oracle9i is the major relational database management system (RDBMS) for developing and running a wide variety of applications, starting from creating and maintaining simple databases in client/server environments to conducting e-business on the Web. PL/SQL is the primary procedural component of Oracle9i's server-side programming and is regarded as the primary language for developing applications on the database and middle tiers using Oracle9i. PL/SQL in Releases 1 and 2 of Oracle9i has incorporated new features that take programmers to a higher level of coding, especially with its true object-relational capabilities. Also, Oracle9i provides for support of Java in the database, and PL/SQL 9i provides this capability by means of Java stored procedures and their new functionality in 9i, to build highly scalable applications.

What This Book Covers

This book covers the techniques of using PL/SQL in Oracle9i Releases 1 and 2 for server-side applications. It covers PL/SQL 9i in exhaustive detail and provides the methodology for implementing robust applications of exceptional quality. This book will assist programmers in implementing techniques that are effective for real-world and code-centric Oracle applications. This saves time and effort on the part of the PL/SQL developer in addition to increasing his or her level to that of an advanced developer. Also, PL/SQL is widely used by many organizations, and the combination of Oracle9i and PL/SQL provides a robust and effective environment for development of mission-critical applications. This book is a source for development of such applications by companies incorporating these technologies as well as those organizations migrating from earlier versions.

SYSCAT.TYPEMAPPINGS

2010-02-04T05:28:00.007-08:00

[ Team LiB ]

SYSCAT.TYPEMAPPINGS

Each row contains a user-defined mapping of a remote built-in data type to a local built-in data type.

Column Name	Data Type	Nullable	Description
`TYPE_MAPPING`	`VARCHAR(18)`		Name of the type mapping (may be system-generated).
`TYPESCHEMA`	`VARCHAR(128)`	Yes	Schema name of the type. Null for system built-in types.
`TYPENAME`	`VARCHAR(18)`		Name of the local type in a data type mapping.
`TYPEID`	`SMALLINT`		Type identifier.
`SOURCETYPEID`	`SMALLINT`		Source type identifier.
`DEFINER`	`VARCHAR(128)`		Authorization ID under which this type mapping was created.
`LENGTH`	`INTEGER`	Yes	Maximum length or precision of the data type. If null, the system determines the best length/precision.
`SCALE`	`SMALLINT`	Yes	Scale for `DECIMAL` fields. If null, the system determines the best scale attribute.
`BIT_DATA`	`CHAR(1)`	Yes	`Y` = Type is for bit data `N` = Type is not for bit data `NULL` = This is not a character data type or that the system determines the bit data attribute
`WRAPNAME`	`VARCHAR(128)`	Yes	Mapping applies to this data access protocol.
`SERVERNAME`	`VARCHAR(128)`	Yes	Name of the data source.
`SERVERTYPE`	`VARCHAR(30)`	Yes	Mapping applies to this type of data source.
`SERVERVERSION`	`VARCHAR(18)`	Yes	Mapping applies to this version of `SERVERTYPE`
`REMOTE_TYPESCHEMA`	`VARCHAR(128)`	Yes	Schema name of the remote type.
`REMOTE_TYPENAME`	`VARCHAR(128)`		Name of the data type as defined on the data source(s).
`REMOTE_META_TYPE`	`CHAR(1)`	Yes	`S` = Remote type is a system built-in type `T` = Remote type is a distinct type
`REMOTE_LOWER_LEN`	`INTEGER`	Yes	Lower bound of the length/precision of the remote decimal type. For character data types, this field indicates the number of characters.
`REMOTE_UPPER_LEN`	`INTEGER`	Yes	Upper bound of the length/precision of the remote decimal type. For character data types, this field indicates the number of characters.
`REMOTE_LOWER_SCALE`	`SMALLINT`	Yes	Lower bound of the scale of the remote type.
`REMOTE_UPPER_SCALE`	`SMALLINT`	Yes	Upper bound of the scale of the remote type.
`REMOTE_S_OPR_P`	`CHAR(2)`	Yes	Relationship between remote scale and remote precision. Basic comparison operators can be used. A null indicated that no specific relationship is required.
`REMOTE_BIT_DATA`	`CHAR(1)`	Yes	`Y` = Type is for bit data `N` = Type is not for bit data `NULL` = This is not a character data type or the system determines the bit data attribute
`USER_DEFINED`	`CHAR(1)`		Definition supplied by user.
`CREATE_TIME`	`TIMESTAMP`		Time when this mapping was created.
`REMARKS`	`VARCHAR(254)`	Yes	User-supplied comments, or null.

[ Team LiB ]

11.2 Create Windows NT/2000 Groups

2010-02-04T05:28:00.005-08:00

[ Team LiB ]

11.2 Create Windows NT/2000 Groups

Windows 2000 recognizes individual users as well as functional groups. You can, for instance, set up a group called Marketing or Sales, and then add new users to the computer. In addition, each user can be added to any of the groups that you've created. Therefore, you might have a marketing manager who belongs to both the Marketing and Management groups.

One advantage of using groups is that SQL Server automatically recognizes the registered Windows users. SQL Server is tightly integrated with Windows security, and you are able to use this integration as you set up SQL Server security. This means, for instance, that you can provide the marketing group with access to tables and stored procedures that are related to marketing data, yet deny the salespeople access to those same tables and procedures. The marketing manager mentioned earlier in this chapter is able to work with marketing and management data (such as employee human resources data).

Because you are treating multiple users as a single group, the administrative effort is considerably less than if you had gone to the trouble of providing access to each individual user. As you'll soon see, treating users as members of groups greatly simplifies the security administration task.

Handling individual users is a real hassle. In large installations with hundreds of users, you spend inordinate amounts of time managing SQL Server security on a user-by-user basis. Instead, you'd like to use Windows groups to add groups of users to the database.

Technique

Use the Administrative Tools in the Control Panel to create groups and add the users you've created to those groups.

Steps

Most often, users are arranged into logical groupings. For instance, all the people in the marketing department are likely to belong to a group named Marketing. Similarly, managers probably belong to a Management group. In this section, you'll learn how to specify the groups on your computer and add the user accounts you've created to those groups.

Later, as users log in to SQL Server, they'll be able to log in as themselves or as a group. Although this might sound a bit strange, to SQL Server, an individual user is the same as a group of users. All that SQL Server sees is an identifier ("TonyS" or "Marketing"), and it matches that identity with a Windows network login.

Choose Start, Settings, Control Panel to open the Control Panel.
Double-click on the Administrative Tools applet to access the Windows 2000 administration options.
Select the security settings by double-clicking on the Computer Management option and opening the dialog box you see in Figure 11.5.

Figure 11.5. Each Windows group usually contains a number of individual users.
Use the + next to Local Users and Groups to reveal the Users and Groups icons. Right-click on the Groups icon and select New Group from the shortcut menu that appears. (Alternatively, use the New Group menu item under the Action menu). You'll see the New Group dialog box as shown in Figure 11.6. Provide a name for the new group, such as Shift Supervisors, in the Group Name text box at the top of the New Group dialog box.

Figure 11.6. Fill in the Group name and Description text boxes. You'll add users to this Windows group in a minute.
Provide a verbose description for the group in the Description text box.

Near the bottom left of the New Group dialog box, you'll see two buttons labeled Add and Check Names (see Figure 11.7). Click on the Add button to open the list of all users who are registered on this computer.

Figure 11.7. This list shows all the users within the local Windows domain. The red X indicates disabled Windows accounts.
The top half of the Select Users or Groups dialog box contains an alphabetically sorted list of all the users in the local domain. Use the scrollbar if necessary to locate the user you want to add to the group. Select the user and use the Add button (or double-click on the user) to add the user to the group. As users are added to the group, their names appear in the lower half of the Select Users or Groups dialog box. When you have completed the selection process, click the OK button.

You'll be returned to the New Group dialog box. You should see the users you've added to the group displayed in the list at the middle of the dialog box.
When you're finished adding groups to the computer, click the Close button to dismiss the New Group dialog box.

Comments

Normally, as a database developer, you won't be creating Windows 2000 groups. However, in many small environments, developers are required to take on more than a single role. Also, you might find it useful to create a group login just for the applications you write.

[ Team LiB ]

Day 2

2010-02-04T05:28:00.003-08:00

[ Team LiB ]

Day 2

1:	What's the advantage of using a view?
A1:	By using views, you can set up different presentations of the same data. Each view is derived from the actual table data, but each user will see a subset of the data. The main benefit to using views is that they allow you to control the access your users have to restricted data.
2:	Give some reasons why you would want to define a primary key for a table.
A2:	Defining a primary key on a table allows you to guarantee that each row in the table is unique. Defining a primary key can improve performance as well, because table access is quicker if each row is uniquely identified. If you're using an ODBC application to update your data, you need to have a primary key defined for the table. An index created automatically for the primary key helps DB2 find an efficient path to the data.
3:	What is the difference between unique keys and primary keys?
A3:	Unique keys are optional; no two of its values are the same or null. This constraint is enforced by the database manager when data is inserted or updated. A table can have multiple unique keys. Unique keys are defined when the table is created or altered. A primary key is a special kind of unique key that uniquely identifies a row of a table. The columns of a primary key can't contain null values. A table can have only one primary key.
4:	What's an instance? What's the advantage of using an instance?
A4:	An instance is a logical database manager environment. Having an instance allows you to catalog databases and set specific configuration parameters to the environment. For example, you can set up a test environment and a production environment by creating two instances. You can change the catalog information and the configuration parameters in the test instance without affecting the data in the production instance. Using instances can also help you protect access to sensitive information, because each instance has a separate assignment of authorized users.
5:	What's the difference between static and dynamic SQL?
A5:	When you write a SQL statement for an application program and know the entire statement, including the SQL statement type (`UPDATE`, `INSERT`, and so on) and the table and column names that the statement acts on, you're using static SQL. Static SQL is a SQL statement that's fully written in an application program before the program is compiled. Dynamic SQL is a statement that the application builds and executes at runtime. Generally dynamic SQL is used in an interactive program where the user is prompted for key parts of the SQL statement.

[ Team LiB ]

6.1 Retrieve Unique Records Using Only a Select Query

2010-02-04T05:28:00.001-08:00

[ Team LiB ]

6.1 Retrieve Unique Records Using Only a Select Query

I need to figure out which customers have invoices. The problem is that when I join the Customers with the Orders tables, I get the customers listed for each order. I only want each customer listed once. How do I return only those customers who have orders, but only once?

Technique

For this How-To, you will be using the DISTINCT clause on a SQL SELECT statement to limit the data to unique values. When you include the DISTINCT clause, SQL Server uses the columns that are returned to determine how to limit the data.

For the opposite affect, you can include the ALL clause, although it is not necessary because this is the default. You will create two SELECT statements for this task. The first one is for all records:


SELECT Customers.CompanyName FROM Customers INNER JOIN Orders ON Customers .CustomerID = 
Orders.CustomerID

To limit the records, use the DISTINCT clause:


SELECT DISTINCT Customers.CompanyName
FROM Customers
INNER JOIN Orders ON Customers.CustomerID = Orders.CustomerID

Steps

Open and run the Visual Basic .NET�Chapter 6 solution. From the main form, click on the button with the caption How-To 6.1. When the form loads, you will see two option buttons, Show All and Distinct, with Show All selected. The SELECT statement showing an inner join between customers and order is displayed in a Label control. You will also see a DataGrid control filled with multiple entries of customers displayed (see Figure 6.1).

Figure 6.1. A common problem with inner joins is retrieving multiple records when you want to see just one per occurrence.

If you click on the option button labeled Use Distinct, then the DataGrid control will be refreshed, but only one customer per set of orders will be displayed.

Create a Windows Form. Then place the controls listed in Table 6.1 with the following properties set, as displayed in Figures 6.1 and 6.2.

Figure 6.2. Using the `DISTINCT` clause gives you control over displaying unique records.

Table 6.1. Control Property Settings for How-To 6.1
Object	Property	Setting
`RadioButton`	`Name`	`rbShowAll`
	`Checked`	`True`
`RadioButton`	`Name`	`rbDistinct`
`Label`	`Text`	`SQL Statement`
`Label`	`Name`	`lblSQLString`
`Label`	`Text`	`Results`
`DataGrid`	`Name`	`dgResults`

As with some of the other chapters' projects, you need to build a support routine to create the Connection string. Called BuildCnnStr, the function can been seen in Listing 6.1. This function takes a server and database name passed to it and creates a connection string.

Listing 6.1 modGeneralRoutines.vb: Creating a Connection String
```
Function BuildCnnStr(ByVal strServer As String, _
          ByVal strDatabase As String) As String

        Dim strTemp As String
        strTemp = "Provider=SQLOleDB; Data Source=" & strServer & ";"
        strTemp &= "Initial Catalog=" & strDatabase & ";"
        strTemp &= "Integrated Security=SSPI"

        Return strTemp
    End Function
```
Although you could create a routine that would pass back a Connection object, a more versatile method would be to pass back a string. The reason for this is that for some objects, you are asked only for a Connection object, but other objects want just a string.

Add the code in Listing 6.2 to the Load event of the form. (Double-click on the form to bring up the code.)

Listing 6.2 `frmHowTo6_1.vb`: Loading the Form


Private Sub frmHowTo6_1_Load(ByVal sender As System.Object,
                    ByVal e As System.EventArgs) Handles MyBase.Load

        GenerateData(Me.rbDistinct.Checked)

End Sub

Add the code in Listing 6.3 to the class module of the page, creating the GenerateData routine. This routine creates the necessary SQL SELECT statement based on whether blnUseDistinct is true or false. If you look back at Listing 6.2, you will see that this is the value of option button rbDistinct. After the SQL string is created, it is assigned to lblSQLString to display the string, and then it is used in a data adapter to fill a dataset. Last, the SQL string is assigned as the data source for the data grid dgResults.

Listing 6.3 `frmHowTo6_1.vb`: Building the SQL String for Retrieving the Data


Sub GenerateData(ByVal blnUseDistinct As Boolean)

        '-- Build the SQL String
        Dim strSQL As String

        strSQL = "SELECT "

        If blnUseDistinct Then
            strSQL += "DISTINCT "
        End If

        strSQL += "Customers.CompanyName FROM Customers "
        strSQL += "INNER JOIN Orders ON Customers.CustomerID = Orders.CustomerID"

        '-- Store the SQL String
        Me.lblSQLString.Text = strSQL

        '-- Use the SQL String to build the data adapter and fill the data table.
        Dim odaResults As New OleDb.OleDbDataAdapter(Me.lblSQLString.Text, _
                                  BuildCnnStr("(local)", "Northwind"))
        Dim dtResults As New DataTable()

        odaResults.Fill(dtResults)

        '-- Assign the data table to the data grid's DataSource property
        Me.dgResults.DataSource = dtResults

End Sub

Add the code in Listing 5.4 to the CheckChanged event of the rbDistinct Radio Button control.

Listing 6.4 `frmHowTo6_1.vb`: Regenerating the Data Based on the Radio Button That Is Checked


Private Sub rbDistinct_CheckedChanged(ByVal sender As System.Object, _
                ByVal e As System.EventArgs) Handles rbDistinct.CheckedChanged


        GenerateData(Me.rbDistinct.Checked)

End Sub

Tip

You might have noticed that besides the loading of the form, I only call the GenerateData routine when the rbDistinct option button is changed, and not when the rbShowAll option button is changed. Because only two buttons are available, you only have to program one of the control's events. If you put it on both, you will have the routine called twice, which is not a good thing in this case.

Comments

It is hard to believe that just one word can affect the data that a SQL statement returns. For the most part, you will want to see all of the records that a SELECT statement returns, but it is nice to have the DISTINCT clause when you need to limit the data.

[ Team LiB ]

Recipe 3.13. Generating a High-Precision Time

2010-02-04T05:27:00.023-08:00

Recipe 3.13. Generating a High-Precision Time

3.13.1. Problem

You need

to measure time with finer than one-second resolution'for example, to generate a unique ID or benchmark a function call.

3.13.2. Solution

Use
microtime(true) to get the current time in seconds and microseconds. Example 3-37 uses microtime(true) to time how long it takes to do 1,000 regular expression matches.

Timing with microtime( )

<?php
$start = microtime(true);
for ($i = 0; $i < 1000; $i++) {
    preg_match('/age=\d+/',$_SERVER['QUERY_STRING']);
}
$end = microtime(true);
$elapsed = $end - $start;

3.13.3. Discussion

Support for the optional argument microtime( ) was added in PHP 5.0.0. Without that argument, with an argument that doesn't evaluate to true, or in an earlier version of PHP, microtime( ) returns a string that contains the microseconds part of elapsed time since the epoch, a space, and seconds since the epoch. For example, a return value of 0.41644100 1026683258 means that 1026683258.41644100 seconds have elapsed since the epoch.

Time including microseconds is useful for generating unique IDs. When combined with the current process ID, it guarantees a unique ID, as long as a process doesn't generate more than one ID per microsecond. Example 3-38 uses microtime( ) (with its string return format) to generate just such an ID.

Generating an ID with microtime( )

<?php
[list($microseconds,$seconds) = explode(' ',microtime());
$id = $seconds.$microseconds.getmypid();
?>

Note that the method in Example 3-38 is not as foolproof on multithreaded systems, where there is a non-zero (but very tiny) chance that two threads of the same process could call microtime( ) during the same microsecond.

3.13.4. See Also

Documentation on microtime( ) at http://www.php.net/microtime. The uniqid( ) function is good for generating unique IDs.

1.6 Managed Resource Responsibilities

2010-02-04T05:27:00.021-08:00

Ru-Brd

1.6 Managed Resource Responsibilities

In order for management systems to manage software resources, they must have information (i.e., management data) about the resources they're managing, along with the ability to control or update those resources via management operations. This information and operations are provided by management instrumentation from inside and outside the resource itself. This section will explain management data, management operations, and management instrumentation.

1.6.1 Management Data

Management data is the information about a software resource that a management system uses. The management system must be able to determine the identity of the resource, how it has been defined to run, and what statistics are available to monitor it. The management data that management systems need access to generally falls into four categories:

Identification data.
Identification data uniquely identifies the resource to be managed. This data must include the name of the resource and an identifier that allows a specific instance of the resource to be distinguished from other instances of the same type. Other data that is usually included is resource type, vendor, version, serial number, location, contact, installation date, last updated date, and address. This data is used by management systems with discovery, inventory, topology, and configuration components. If the management system cannot find this data for the resource, the resource must be manually defined to the discovery, inventory, topology, and configuration management systems.

Configuration data.
Configuration data may include the complete configuration of the resource or a subset thereof. Read access alone is valuable for problem determination and dynamic management policy. It gives the management system real-time management guidance about data for which thresholds should be established, logs and components that should be managed, and so on. If the configuration data can be set by the management system, an update to this data may cause the resource to dynamically update and behave in accordance with the new configuration values.

Statistical data.
Statistical data is numerical data that generally represents the current state of the resource. Most management systems use resource statistics as the data to be monitored to determine resource health. Depending on the quality and quantity of statistical data available from the resource, management systems may also be able to use this data for load and resource balancing, tuning, trend analysis, capacity forecasting, billing, and understanding application usage. Service-level agreements and the systems that report and enforce them use statistical data to define the expectations, thresholds, and responses for the service-level agreements for an application.

Status data.
Status data is information about the resource that indicates its health and current operational state. Typically status data is reported by enumerated values, like Active, Degraded, Stopped, DependencyDown, Down, or Failed. A resource may have status substates indicating the health and state of its components.

Some of this information (e.g., configuration data) can be obtained from logs and files. Some of this information must be obtained directly from the managed resource.

1.6.2 Management Operations

Management operations are used to control, locally or remotely, all components of a managed resource. Operations can be categorized as lifecycle control (start, stop, restart, refresh, and so on), query, configure, and custom. Some of these operations (e.g., start and stop) are provided by the platform that is hosting the managed resource. Some must be provided directly by the managed resource as commands or APIs. The management system will invoke these APIs and commands from scripts, programs, remote connections, command prompts, and agents in response to events, schedules, and user requests.

It is interesting to note that although user-driven interfaces like administration applications can be used to drive management operations, it is difficult for management systems to use them. Software resources should supply a user interface and command or APIs for the management operations.

1.6.3 Management Instrumentation

Management instrumentation is the way a resource provides its management data and operations to the management system. Resources provide two types of management instrumentation: external and internal.

Management disciplines need different kinds of instrumentation, depending on whether they need to interact directly with the executing resource. For example, the distribute discipline typically needs only external instrumentation, and operations are difficult to support without internal instrumentation. Most disciplines use a combination of both types of instrumentation, as illustrated by Figure 1.8.

Figure 1.8. Internal and External Instrumentation

JMX provides the infrastructure for Java resource developers to expose this management information. It also provides the APIs for management systems to gain access to the information and invoke the operations.

1.6.3.1 External Instrumentation

External instrumentation is management enablement that is defined and executed outside the resource itself. The external instrumentation consists of definitions describing the resource. The instrumentation is used to customize the management system so that it can effectively manage the resource. These definitions specify the directories, files, libraries, executables, installation processes, configurations, events, APIs, and policies that are required knowledge to manage the resource. The external instrumentation of the resource includes special files, programs, or utilities that may be necessary for the management system to access the data for or control the resource. The management disciplines of distribute, install, configure, monitor, and operate can be supported by this type of instrumentation.

Tivoli uses its Application Management Specification (AMS)^[44] files as its external instrumentation. AMS files are generically defined as a software resource's management "definition file." Some management system vendors provide tools to facilitate the creation of a resource's management definition files. For SNMP, the MIB file represents this type of instrumentation. For CIM/WBEM, the instrumentation is defined as a schema in a MOF (Managed Object Format) file.^[45]

1.6.3.2 Internal Instrumentation

Internal instrumentation is management enablement that is developed and executed directly as part of the resource by the vendor or developer. It consists of code specifically engineered to meet a management system's requirements. Basic instrumentation includes the provision of a command tool or a management agent that can invoke or perform the operations and that can obtain the application status and statistics. The monitor and control management disciplines may require this type of instrumentation. Extensive internal instrumentation may be required for communication with a single management system.

Monitoring and operating an executing application requires that the application support instrumentation for several different types of management data and functions. For example, an SNMP subagent must be developed for each application that supports a defined SNMP MIB. Likewise, with WBEM, a CIM provider may need to be developed to support the management schema for an application. There is currently no standard instrumentation data or API approach for applications to adhere to or take advantage of. This may not be true in the future, however, because a management model defining the data for managing executing applications is currently being developed in the DMTF.

In reality, a combination of external and internal instrumentation methodologies, as illustrated in Figure 1.8, is optimal. There are at least three good arguments for this:

External instrumentation is rarely sufficient in and of itself. Generally the resource will need to expose some specific metrics, operations, and events. You then have internal instrumentation.

Internal instrumentation is rarely sufficient in and of itself. There are frequently management tasks to perform within a system to keep it healthy for the application to continue to function. Data space management by the rotation or clipping of logs, the compression of backup data, and the deletion of obsolete logs and data is an example of the second case for external instrumentation.

You will need to advertise the internal instrumentation's capabilities in external instrumentation used by the management system. Defining an SNMP MIB is an example. You are advertising your management data to an SNMP manager.

A single common application management API simplifies and minimizes the internal instrumentation required. This is the essence of the requirement for a common management system application-level API, as defined by the JMX API set and as described in this book.

JMX is designed to satisfy the requirements of managing the executing application from the resource developer's point of view, as well as the management vendor's point of view. JMX is an internal instrumentation API. It is used to expose and and provide access to the execution-time management information that is necessary for an application to be manageable by an arbitrary management system. Tools can be used to generate the external instrumentation for a specific management system from the information available through the JMX APIs.

Ru-Brd

Section 5.23. Take myPod for another test drive

2010-02-04T05:27:00.019-08:00

5.23. Take myPod for another test drive

Ahhh... much better. Visitors can see all the available pictures at a glance. They can also tell which photos go with each city more easily. Now we need to find a way to link from each thumbnail to the corresponding large image.

Wait a sec, don't you think you're pulling a fast one? The images used to be on top of each other; now they're side by side.

5.23.1. Right; but remember the <img> element is an inline element.

In other words, we didn't "pull anything." Because <img> is an inline element, it doesn't cause linebreaks to be inserted before and after the element is displayed. So, if there are several images together in your HTML, the browser will fit them side by side if the browser window is wide enough.

The reason the larger photos weren't side by side is because the browser didn't have room to display them next to each other. Instead, it displayed them on top of each other. A browser always displays vertical space before and after a block element, and if you look back at the screenshots, you'll see the images are right on top of each other with no space in between. That's another sign <img> is an inline element.

Section 3.3. Self Joins

2010-02-04T05:27:00.017-08:00

3.3 Self Joins

There are situations

in which one row of a table is related

to another row of the same table. The EMPLOYEE table is a good

example. The manager of one employee is also an employee. The rows

for both are in the same EMPLOYEE table. This relationship is

indicated in the MANAGER_EMP_ID column:

CREATE TABLE EMPLOYEE (

EMP_ID          NUMBER (4) NOT NULL PRIMARY KEY,

FNAME           VARCHAR2 (15), 

LNAME           VARCHAR2 (15), 

DEPT_ID         NUMBER (2),

MANAGER_EMP_ID  NUMBER (4) REFERENCES EMPLOYEE(EMP_ID),

SALARY          NUMBER (7,2),

HIRE_DATE       DATE, 

JOB_ID          NUMBER (3));

To get information about an employee and his manager, you have to

join the EMPLOYEE table with itself. This is achieved by specifying

the EMPLOYEE table twice in the FROM clause and using two different

table

aliases,

thereby treating EMPLOYEE as if it were two separate tables. The

following example lists the name of each employee and his manager:

SELECT E.NAME EMPLOYEE, M.NAME MANAGER

FROM EMPLOYEE E, EMPLOYEE M

WHERE E.MANAGER_EMP_ID = M.EMP_ID;



EMPLOYEE   MANAGER

---------- ----------

SMITH      FORD

ALLEN      BLAKE

WARD       BLAKE

JONES      KING

MARTIN     BLAKE

BLAKE      KING

CLARK      KING

SCOTT      JONES

TURNER     BLAKE

ADAMS      SCOTT

JAMES      BLAKE

FORD       JONES

MILLER     CLARK



13 rows selected.

Notice the use of the EMPLOYEE table twice in the FROM clause with

two different aliases. Also notice the join condition that reads as:

"Where the employee's

MANAGER_EMP_ID is the same as his manager's

EMP_ID."

3.3.1 Self Outer Joins

Even though

the EMPLOYEE

table has 14 rows, the previous query returned only 13 rows. This is

because there is an employee without a MANAGER_EMP_ID. Oracle

excludes this row from the result set while performing the self inner

join. To include the employee(s) without a MANAGER_EMP_ID, you need

an outer join:

SELECT E.LNAME EMPLOYEE, M.LNAME MANAGER

FROM EMPLOYEE E, EMPLOYEE M

WHERE E.MANAGER_EMP_ID = M.EMP_ID (+);



EMPLOYEE   MANAGER

---------- ----------

SMITH      FORD

ALLEN      BLAKE

WARD       BLAKE

JONES      KING

MARTIN     BLAKE

BLAKE      KING

CLARK      KING

SCOTT      JONES

KING

TURNER     BLAKE

ADAMS      SCOTT

JAMES      BLAKE

FORD       JONES

MILLER     CLARK



14 rows selected.

Be careful when placing the (+) operator

in a join

condition. If you put the (+) on the wrong side, you will get an

absurd result set that makes no sense. In this case, the EMPLOYEE

table we need to make optional is the one from which we are drawing

manager names.

3.3.2 Self Non-Equi-Joins

The previous

example showed self-equi-joins.

However, there are situations when you need to perform

self-non-equi-joins. We will illustrate this by an example.

Let's assume that you are in charge of organizing

interdepartmental basket ball competition within your company. It is

your responsibility to draw the teams and schedule the competition.

You query the DEPARTMENT table and get the following result:

SELECT NAME FROM DEPARTMENT;



NAME

--------------

ACCOUNTING

RESEARCH

SALES

OPERATIONS

You find that there are four departments, and to make a fair

competition, you decide that each department plays against the other

three departments once, and at the end the department with the

maximum wins is declared the winner. You have been to an Oracle SQL

training class recently, and decide to apply the concept of self

join. You execute the following query:

SELECT D1.NAME TEAM1, D2.NAME TEAM2

FROM DEPARTMENT D1, DEPARTMENT D2;



TEAM1          TEAM2

-------------- --------------

ACCOUNTING     ACCOUNTING

RESEARCH       ACCOUNTING

SALES          ACCOUNTING

OPERATIONS     ACCOUNTING

ACCOUNTING     RESEARCH

RESEARCH       RESEARCH

SALES          RESEARCH

OPERATIONS     RESEARCH

ACCOUNTING     SALES

RESEARCH       SALES

SALES          SALES

OPERATIONS     SALES

ACCOUNTING     OPERATIONS

RESEARCH       OPERATIONS

SALES          OPERATIONS

OPERATIONS     OPERATIONS



16 rows selected.

Disappointing results. From your knowledge of high school

mathematics, you know that four teams each playing once with the

other three makes six combinations. However, your SQL query returned

16 rows. Now you realize that since you didn't

specify any join condition, you got a Cartesian product from your

query. You put in a join condition, and your query and results now

look as follows:

SELECT D1.NAME TEAM1, D2.NAME TEAM2

FROM DEPARTMENT D1, DEPARTMENT D2

WHERE D1.DEPT_ID = D2.DEPT_ID;



TEAM1          TEAM2

-------------- --------------

ACCOUNTING     ACCOUNTING

RESEARCH       RESEARCH

SALES          SALES

OPERATIONS     OPERATIONS

Oops! The equi-join returned a very unwanted result. A team

can't play against itself. You realize your mistake,

and this sparks the idea that you can use non-equi-joins in this

situation. You rewrite the query as a non-equi-join. You

don't want a team to play against itself, and

therefore replace the "=" operator

in the join condition with "!=".

Let's look at the results:

SELECT D1.NAME TEAM1, D2.NAME TEAM2

FROM DEPARTMENT D1, DEPARTMENT D2

WHERE D1.DEPT_ID != D2.DEPT_ID;



TEAM1          TEAM2

-------------- --------------

RESEARCH       ACCOUNTING

SALES          ACCOUNTING

OPERATIONS     ACCOUNTING

ACCOUNTING     RESEARCH

SALES          RESEARCH

OPERATIONS     RESEARCH

ACCOUNTING     SALES

RESEARCH       SALES

OPERATIONS     SALES

ACCOUNTING     OPERATIONS

RESEARCH       OPERATIONS

SALES          OPERATIONS



12 rows selected.

Still not done. In this result set, you have permutations such as

(RESEARCH, ACCOUNTING) and (ACCOUNTING, RESEARCH), and so on.

Therefore, each team plays against the others twice. You need to

remove these permutations, which you rightly consider to be

duplicates. You think about using DISTINCT. DISTINCT will not help here,

because the row (RESEARCH, ACCOUNTING) is different from the row

(ACCOUNTING, RESEARCH) from the viewpoint of DISTINCT; but not from

the viewpoint of your requirement. After some thought, you want to

try out an inequality operator other than

"!=". You decide to go with the

less-than (<) operator. Here are the results you get:

SELECT D1.NAME TEAM1, D2.NAME TEAM2

FROM DEPARTMENT D1, DEPARTMENT D2

WHERE D1.DEPT_ID < D2.DEPT_ID;



TEAM1          TEAM2

-------------- --------------

ACCOUNTING     RESEARCH

ACCOUNTING     SALES

RESEARCH       SALES

ACCOUNTING     OPERATIONS

RESEARCH       OPERATIONS

SALES          OPERATIONS



6 rows selected.

That's it! Now you have six combinations: each team

plays against the other three just once. Let's

examine why this version of the query works. Conceptually, when

Oracle executes this query, a Cartesian product is first formed with

16 rows. Then the less-than (<) operator

in the join condition restricts

the result set to those rows in which the DEPT_ID of Team 1 is less

than the DEPT_ID of Team 2. The less-than (<) operator eliminates

the duplicates, because for any given permutation of two departments

this condition is satisfied for only one. Using greater-than (>)

instead of less-than (<) will

also give you the required result, but the TEAM1 and TEAM2 values

will be reversed:

SELECT D1.NAME TEAM1, D2.NAME TEAM2

FROM DEPARTMENT D1, DEPARTMENT D2

WHERE D1.DEPT_ID > D2.DEPT_ID;



TEAM1          TEAM2

-------------- --------------

RESEARCH       ACCOUNTING

SALES          ACCOUNTING

OPERATIONS     ACCOUNTING

SALES          RESEARCH

OPERATIONS     RESEARCH

OPERATIONS     SALES



6 rows selected.

Don't be disheartened by the painful process you had

to go through to get this result. Sometimes you have to go through an

agonizing experience to get simple results such as these.

That's life. Now that you have the team combinations

right, go a bit further and assign a date for each match. Use

"tomorrow" as the starting date:

SELECT D1.NAME TEAM1, D2.NAME TEAM2, SYSDATE + ROWNUM MATCH_DATE

FROM DEPARTMENT D1, DEPARTMENT D2

WHERE D1.DEPT_ID < D2.DEPT_ID;



TEAM1          TEAM2          MATCH_DATE

-------------- -------------- ---------

ACCOUNTING     RESEARCH       30-APR-01

ACCOUNTING     SALES          01-MAY-01

RESEARCH       SALES          02-MAY-01

ACCOUNTING     OPERATIONS     03-MAY-01

RESEARCH       OPERATIONS     04-MAY-01

SALES          OPERATIONS     05-MAY-01



6 rows selected.

Now publish these results on the corporate intranet along with the

rules and regulations for the competition, and you are done.

front_insert_iterator

2010-02-04T05:27:00.015-08:00



Class Name            front_insert_iterator

Header File          <iterator>

Classification      abstract data type

Class Relationship Diagram

Class Description

Member Classes

Container& container

Methods


explicit front_insert_iterator(Container& x);

Operators



front_insert_iterator<Container>& operator=
(const typename Container::value_type value);

front_insert_iterator<Container>& operator*();

front_insert_iterator<Container>& operator++();

front_insert_iterator<Container>& operator++(int);

Class Description

The front_insert_iterator inserts elements at the front of a container by
using the container's push_front() method to perform the insertion.

Container& container

The container in which elements will be inserted.



Method             front_insert_iterator()

Access             Public

Classification     Constructor

Syntax             explicit front_insert_iterator(Container& x);

Paramters          x is the reference to the container in which elements
                   will be inserted.

Returns            None

Description

The constructor constructs a front_insert_iterator object and initializes
Container& container with a x.



Method             operator*()

Access             Public

Classification     Accessor

Syntax             front_insert_iterator<Container>& operator*();

Parameters         None

Returns            This operator returns a pointer to the invoking object.

Description

The dereference operator returns *this.



Method             operator++()

Access             Public

Classification     Accessor

Syntax             front_insert_iterator<Container>& operator++();

Parameters         None

Returns            This operator returns a pointer to the invoking object.

Description

This incrementation operator returns *this.



Method             operator++()

Access             Public

Classification     Accessor

Syntax             front_insert_iterator<Container> operator++(int x);

Parameters         x has no bearing on this function.

Returns            This operator returns a pointer to the invoking object.

Description

This incrementation operator returns *this.



Method             operator=()

Access             Public

Classification     Modifier

Syntax             front_insert_iterator<Container>&
                   operator=(const typename Container::value_type& value);

Parameters         value is the reference to the type value_type that
                   is inserted into the container.

Returns            This operator returns a pointer to the invoking object.

Description

The assignment operator is converted to an insertion operation using
container.push_front(value). The operator returns *this.

Programmer's Life

17.2 Advanced Function Options

17.2 Advanced Function Options

Acknowledgments

Acknowledgments

11.5 Collection of Issues for Beyond Version 1.1

11.5 Collection of Issues for Beyond Version 1.1

11.5.1 Advanced Practices

11.5.2 Generic Attributes

11.5.3 Relationship to Other Process Areas

Example Update to Relationships Section

Section 3.8. Objects

3.8. Objects

3.8.1. Object References

3.8.1.1. Immediate values

3.8.2. Object Lifetime

3.8.3. Object Identity

3.8.4. Object Class and Object Type

3.8.5. Object Equality

3.8.5.1. The equal? method

3.8.5.2. The == operator

Equality for Java Programmers

3.8.5.3. The eql? method

3.8.5.4. The === operator

3.8.5.5. The =~ operator

3.8.6. Object Order

3.8.7. Object Conversion

3.8.7.1. Explicit conversions

3.8.7.2. Implicit conversions

3.8.7.3. Conversion functions

3.8.7.4. Arithmetic operator type coercions

3.8.7.5. Boolean type conversions

3.8.8. Copying Objects

3.8.9. Marshaling Objects

3.8.10. Freezing Objects

3.8.11. Tainting Objects

Specific Practices by Goal

Specific Practices by Goal

SG 1 Provide IPPD Infrastructure

SP 1.1-1 Establish the Organization's Shared Vision

Table . Practice-to-Goal Relationship Table

Typical Work Products

Subpractices

SP 1.2-1 Establish an Integrated Work Environment

Typical Work Products

Subpractices

SP 1.3-1 Identify IPPD-Unique Skill Requirements

Typical Work Products

Subpractices

SG 2 Manage People for Integration

SP 2.1-1 Establish Leadership Mechanisms

Typical Work Products

Subpractices

SP 2.2-1 Establish Incentives for Integration

Typical Work Products

Subpractices

SP 2.3-1 Establish Mechanisms to Balance Team and Home Organization Responsibilities

Typical Work Products

Subpractices

Day 17

Day 17

The Unbearable Lightness of False Positives

The UnbearableLightness of False Positives

Summary

Summary

Recipe 10.1. Using DBM Databases

Recipe 10.1. Using DBM Databases

10.1.1. Problem

10.1.2. Solution

Using a DBM database

10.1.3. Discussion

Tracking users and passwords with a DBM database

Calculating password length with DBM

Storing structured data in a DBM database

10.1.4. See Also

Audio Effects on Sampled Audio

Audio Effects on Sampled Audio

Precalculation

Byte Array Manipulation

Making a sound clip echo

The Unbearable
Lightness of False Positives

`WHERE` `event condition`

`WRITE TO`

Figure 6.2. Using the `DISTINCT` clause gives you control over displaying unique records.

Listing 6.1 `modGeneralRoutines.vb`: Creating a Connection String

Listing 6.2 `frmHowTo6_1.vb`: Loading the Form