Expertiza_Wiki - User contributions [en]

CSC/ECE 517 Fall 2010/ch6 6b SK

2010-11-17T04:42:45Z

Kschidam:

'''Support for Assertions in Various O-O Programming Languages'''

= '''Introduction''' =

In computer language an [http://en.wikipedia.org/wiki/Assertion_(computing) assertion] is a construct that immediately terminates the execution of a program if a certain expression or a condition is evaluated to false (assertion failure). It is mainly used for code [http://en.wikipedia.org/wiki/Debugging debugging] . Programmers use assertions to check for potential errors or bugs in the application being developed. The main feature of assertions is to verify the validity of the assumptions made by chunk of code during execution. A good example to illustrate this is the use of [http://en.wikipedia.org/wiki/Dynamic_memory_allocation dynamic memory allocation] in C++, wherein we can use an assertion to check a [http://en.wikipedia.org/wiki/Pointer_(computing) pointer] and ensure that it is not null before using this pointer. If this check in not made, a reference may occur later that would cause an error. Assertions play a vital role in developing reliable object-oriented software. An early advocate of using assertions in programming was Alan Turing [5]. Assertions serve to make explicit the assumptions on which programmers rely when they write software elements that they believe are correct. Assertion-based Object-Oriented techniques produce reliable software and enable software components to be reused safely. In languages such as Eiffel, assertions form part of the design process, and in others, such as C and Java, they are used only to check assumptions at runtime. Various object oriented programming languages support assertions.

= '''Support for Assertions in Java''' =

When implementing and debugging a class in java programming language, it is a good practice to specify conditions that should be true at a particular stage in a method. These conditions, called assertions, guarantee a program’s validity by catching potential bugs and identifying possible logic errors during development. For example, if you write a module that calculates the temperature of an element, you might assert that the calculated temperature is not less than 0 degree Kelvin. The syntax for assert statements are as follows [1]:

assert Expression1;

Expression1 is a [http://en.wikipedia.org/wiki/Boolean_expression Boolean expression]. If Expression1 is evaluated to be false, then the system throws an AssertionError. This syntax for assert will not give a detail error message. Therefore second form of assert syntax can be used [1] as given below
assert Expression1: Expression2;

Expression1 is a Boolean expression. Expression2 is an expression that has a value. This version of the assert statement provides detail message for the AssertionError. The system passes the value of Expression2 to the appropriate AssertionError constructor, which uses the string representation of the value as the error's detail message. This form of the assertion statement should be used in preference to the first only when the program has some additional information that might help diagnose the failure. Below is an example code that demonstrates the functionality of assert statement. This code checks with assert that the value entered is an even number only [2].

import java.util.Scanner;

public class AssertTest
{
public static void main( String args[] )
{
Scanner input = new Scanner( System.in );

System.out.print( "Enter an even number: " );
int number = input.nextInt();

// assert that the number is even
assert ((number % 2 == 0)) : "Not an even number: " + number;

System.out.printf( "You entered an even number %d\n", number );
}
}
OUTPUT:

Enter an even number: 10
You entered an even number 10

Enter an even number: 25
Exception in thread "main" java.lang.AssertionError: Not an even number: 25
at AssertTest.main(AssertTest.java:15)

The above code prompts the user to enter an even number, then this number is read from command prompt. The assert statement then determines whether the user entered an even or odd number. If the user entered an odd number (as in second case of output), then the program throws an error. Otherwise, the program proceeds normally. Any line that executes after the assert statement can safely assume that number is not odd

One obvious question that may arise is when exceptions can do the [http://en.wikipedia.org/wiki/Exception_handling error handling] why we need another level of checking. Java exceptions are primarily used to handle unusual conditions arising during program execution. Assertions are not to replace exceptions but to augment them. Assertions are used to specify conditions that a programmer assumes are true. When programming, if a programmer can swear that the value being passed into a particular method is positive no matter what a calling client passes, it can be documented using an assertion to state it. Exceptions handle abnormal conditions arising in the course of the program; however they do not guarantee smooth or correct execution of the program. Assertions help state scenarios that ensure the program is running smoothly. Assertions can be efficient tools to ensure correct execution of a program. They improve the confidence about the program.

== '''Types of Assertions''' ==
* Preconditions - These are assertions about a program’s state when a method is invoked. Precondition refers to the parameters passed to a method in a program. Precondition asserts check the validity of parameters passed before they get used in the body of the method.
* Postconditions - These are assertions about a program’s state after a method finishes execution. Postcondition should be evaluated before the exit point in a method. Postcondition asserts can be used to check for the validity of the return values in a method that has multiple return statements.

One situation where use of assertions is helpful in Java programming language is : Internal Invariants [1]. Assertions can be used within programs to make sure the program behaves in a predetermined manner and will throw an error when violated. For instance, an assertion can be placed in the code below to declare that age will never be negative.

if (age > 0)
{
age = age + 1;
}
else
{
assert age >0:"Age cannot be negative"
}

== '''Enabling and Disabling Assertions'''==

At runtime assertions are disabled by default as they reduce performance. To enable assertions at [http://en.wikipedia.org/wiki/Run_time_(computing) runtime], use the -ea command-line option. To disable assertions, use –da command line option. To execute a code with assertions enabled use
java -ea AssertTest

The assertion status of a class (enabled or disabled) is set at the time it is initialized, and does not change. There is, however, one corner case that demands special treatment. It is possible, though generally not desirable, to execute methods or constructors prior to initialization. This can happen when a class hierarchy contains circularity in its static initialization. If an assert statement executes before its class is initialized, the execution must behave as if assertions were enabled in the class.

== '''xUnit Frameworks that support testing in Java''' ==

Some of the xUnit frameworks that support testing Java code are JUnit , SpryTest , Jtest , TestNG and JExample. Other testing frameworks supported by Java can be looked up at [9]

= '''Support for Assertions in Ruby''' =

[http://en.wikipedia.org/wiki/Unit_testing Unit testing] is a process where individual parts of [http://en.wikipedia.org/wiki/Source_code source code] are isolated and tested separately to determine if they are bug free. The idea behind unit testing is that you write a test method that makes certain assertions about your code, working against a test fixture. [http://en.wikipedia.org/wiki/Ruby_(programming_language) Ruby language] supports a module called Test::Unit::Assertions in test/unit/assertions.rb. Test::Unit::Assertions contains the standard Test::Unit assertions. Assertions is included in Test::Unit::TestCase.

=='''Public class assert methods'''==

*assert( boolean, [msg] )- This ensures that the object/expression is true
assert [10, 20].include?(50)

*assert_block(message="assert_block failed.") {|| ...} - If the block yields to true , then the assert passes
Example [3]:
def assert_block(message="assert_block failed.") # :yields:
_wrap_assertion do
if (! yield)
raise AssertionFailedError.new(message.to_s)
end
end
end

* assert_match( regexp, string, [msg] )- Ensures that a string matches the regular expression

Example [3]:
def assert_match(pattern, string, message="")
_wrap_assertion do
pattern = case(pattern)
when String
Regexp.new(Regexp.escape(pattern))
else
pattern
end
full_message = build_message(message, "<?> expected to be =~\n<?>.", string, pattern)
assert_block(full_message) { string =~ pattern }
end
end

*assert_not_equal(expected, actual, message="") - If expected != actual, then the assert passes

Example [3]:
def assert_not_equal(expected, actual, message="")
full_message = build_message(message, "<?> expected to be != to\n<?>.", expected, actual)
assert_block(full_message) { expected != actual }
end

*assert_nil(object, message="") - This assert passes if the object is nil.

Example[3]:

# File test/unit/assertions.rb, line 173
def assert_nil(object, message="")
assert_equal(nil, object, message)
end

There are a bunch of other public class methods. This can be obtained from [4]

=='''Test Method & Test Fixture'''==

Assertions must be used inside test methods within test fixtures. Related tests are grouped inside a common test class using assert. The advantage of having a separate class for all related tests is that it keeps the actual developed code to be tested uncluttered from the test code, hence making maintainability easier. It also allows these test code to be deleted from the development code before the final delivery as these test codes are needed mainly for the developer/tester and need not be part of the final product. Main advantage is it allows you to set up a common test fixture for your tests to run against. Test fixtures are a way of organizing test data; they reside in the fixtures folder. The test_helper.rb file holds the default configuration for your tests.

=='''Ruby on Rails'''==

[http://en.wikipedia.org/wiki/Ruby_on_Rails Rails] is an open source web framework for Ruby language. Rails adds some custom assertions of its own to the test/unit framework some of which are as stated below:

*assert_difference(expressions, difference = 1, message = nil) {...}
Test numeric difference between the return value of an expression as a result of what is evaluated in the yielded block.
*assert_recognizes(expected_options, path, extras={}, message=nil)
Asserts that the routing of the given path was handled correctly and that the parsed options (given in the expected_options hash) match path.
Basically, it asserts that Rails recognizes the route given by expected_options.
*assert_template(expected = nil, message=nil)
Asserts that the request was rendered with the appropriate template file.

== '''xUnit Frameworks that support testing in Ruby''' ==

The only xUnit framework that support testing Ruby code is Test::Unit. Other testing frameworks that support Ruby but that do not fall under the xUnit umbrella are RSpec , Shoulda , microtest and Bacon.

= '''Support for Assertions in C++''' =
In [http://en.wikipedia.org/wiki/C%2B%2B C++] the support for assertions is pretty limited. Assertion is mainly used for error detection during debugging. If an assertion fails ,the program would stop at that point and indicate which assertion caused the failure.

== Simple Assert ==

In C++ assertions are defined in the header file [http://en.wikipedia.org/wiki/Assert.h Assert.h].

* assert (expression);

Example:
assert(isAdmin == true);

Similar to other languages , assertions can be turned off in C++ if the NDEBUG macro is defined before the inclusion of the header Assert.h .

== '''xUnit Frameworks that support testing in C++''' ==

Some of the xUnit frameworks that support testing C++ code are API Sanity Autotest, C++test, Cantata++, CppUnit and CppTest. To see the complete list of xUnit and other testing frameworks supported by C++ please refer to [9]

= '''Support for Assertions in Python''' =
In [http://www.python.org/ Python] when the [http://docs.python.org/reference/simple_stmts.html#the-assert-statement assert] statement is encountered, the expression following the assert keyword is evaluated and the AssertionError exception is raised if the expression evaluates to false.

== Simple Assert ==

The following code would raise the [http://docs.python.org/library/exceptions.html#exceptions.AssertionError AssertionError] exception.

* assert condition

Example:
#!/usr/bin/python
assert 1 == 2

== Extended Assert ==

In addition to evaluating an expression , arguments can be passed to the assertion so that for example, the right message can be displayed based on the outcome of the assertion.

* assert Expression[, Arguments]

Example [8];
#!/usr/bin/python
def IsSenior(age):
assert (age >= 1),"Age cannot be zero or less than zero !"
return (age >= 65)
print IsSenior(15)
print IsSenior(70)
print IsSenior(-1)

Example Output;
false
true
Traceback (most recent call last):
File "test.py", line 9, in <module>
print IsSenior(-5)
File "test.py", line 4, in IsSenior
assert (age >= 1),"Age cannot be zero or less than zero !"
AssertionError: Age cannot be zero or less than zero !

One of the key feature of assertions in Python is that if python is started with -O option, then the assertions would not be evaluated. The scenario where this feature would apply is developers can write a lot of assertions for debugging and when the code is to be executed in production , if it is started with -O option , then all the assertions written by the developers for debugging would not be evaluated.

In general assertions are not the best means to test for failure cases. Instead of using an assertion exceptions would be the right way to handle scenarios like wrong user input or system/environment failures.

== '''xUnit Frameworks that support testing in Python''' ==

Some of the xUnit frameworks that support testing python code are PyUnit, Nose, py.test and TwistedTrial. Other testing frameworks supported by python can be looked up at [9]

One common used of assertions in python is for type checking. Please refer the article [http://pg-server.csc.ncsu.edu/mediawiki/index.php/CSC/ECE_517_Fall_2007/wiki3_1_sa#Python Assertion in O-O languages] for more details.

= '''Benefits of assertions''' =
*Use of assertions in the program help detect errors immediately and directly, rather than at a later stage. Assertion failure usually reports the location of failure in the code which helps in pin-pointing the error without further debugging.
*Assertions provide run time check for assumptions made by developers
*Assertions are also sometimes placed at points the execution is not supposed to reach. For example, assertions could be placed at the default clause of the switch statement in languages such as C++, and Java. Any case which the programmer does not handle intentionally will raise an error and the program will abort rather than silently continuing in an erroneous state.
*Assertions can be viewed as "dynamic documentation", since they are checked at runtime, contrary to the traditional approach of documenting assumptions via plain /* comments */.

*Assert statements are great for helping you to refactor and optimize your code with greater confidence that you have preserved correctness

= '''Limitations of assertions''' =

*Assertions rarely allow for graceful error recovery. They terminate the program abruptly and may not release some of the resources used by the program; hence it is considered bad practice to rely upon assertions for handling expected error conditions.
* Assertions sometime hinder execution time. For example, if the program has an assert that checks to see if the number to be returned is the smallest in the array, then the assertion will have to do the same amount of work that the method would have to do.

= '''Conclusion''' =

When writing program, it is a good practice to check for violations of basic assumptions in the code. These checks help in debugging code. The assertion facility in J2SE 1.4 (and later versions) provides a unified support for assertions in Java technology as well as a convenient way for developers both to turn assertions on and off as needed. Assertions are used in Test Driven Development(TDD) in Ruby programing language. The Test::Unit library in Ruby has a variety of built in assertions that makes writing tests much easier. As seen above assertions are natively supported in some languages like Ruby, whereas in languages like C++ and python it is merely used as a mechanism to track errors when debugging.

Although the use of assertions replaces the adhoc use of conditional tests with a uniform methodology, it does not allow for a repair strategy to continue program execution. This means that when an exception is detected, the program aborts with no recovery mechanism. Nevertheless, assertions play an important role in debugging and designing code with testability in mind. The assertion facility can be used to support an informal design-by-contract style of programming.

= '''Reference''' =

[http://download.oracle.com/javase/1.4.2/docs/guide/lang/assert.html] Programming with Assertions

[http://www.deitel.com/articles/java_tutorials/20060106/Assertions.html] Assertions in java

[http://ruby-doc.org/stdlib/libdoc/test/unit/rdoc/classes/Test/Unit/Assertions.html#M004514] Assertions in Ruby

[http://guides.rubyonrails.org/testing.html#assertions-available] Ruby assertions

[http://topfunky.com/clients/rails/ruby_and_rails_assertions.pdf] Ruby on Rails assertion cheat sheet

[http://www.cs.clemson.edu/~malloy/papers/prospectus/prospectus.pdf] More about assertions

[http://docs.python.org/reference/simple_stmts.html] Python simple statements documentation

[http://www.tutorialspoint.com/python/assertions_in_python.htm] Assertions in Python

[http://en.wikipedia.org/wiki/List_of_unit_testing_frameworks] Testing frameworks for programming languages

[http://en.wikipedia.org/wiki/XUnit] xUnit

Zz

2010-11-16T06:32:58Z

Kschidam:

Zz

2010-11-16T06:16:12Z

Kschidam:

'''Support for Assertions in Various O-O Programming Languages'''

= '''Introduction''' =

In computer language an [http://en.wikipedia.org/wiki/Assertion_(computing) assertion] is a construct that immediately terminates the execution of a program if a certain expression or a condition is evaluated to false (assertion failure). It is mainly used for code [http://en.wikipedia.org/wiki/Debugging debugging] . Programmers use assertions to check for potential errors or bugs in the application being developed. The main feature of assertions is to verify the validity of the assumptions made by chunk of code during execution. A good example to illustrate this is the use of [http://en.wikipedia.org/wiki/Dynamic_memory_allocation dynamic memory allocation] in C++, wherein we can use an assertion to check a [http://en.wikipedia.org/wiki/Pointer_(computing) pointer] and ensure that it is not null before using this pointer. If this check in not made, a reference may occur later that would cause an error. Assertions play a vital role in developing reliable object-oriented software. An early advocate of using assertions in programming was Alan Turing [5]. Assertions serve to make explicit the assumptions on which programmers rely when they write software elements that they believe are correct. Assertion-based Object-Oriented techniques produce reliable software and enable software components to be reused safely. In languages such as Eiffel, assertions form part of the design process, and in others, such as C and Java, they are used only to check assumptions at runtime. Various object oriented programming languages support assertions.

= '''Support for Assertions in Java''' =

When implementing and debugging a class in java programming language, it is a good practice to specify conditions that should be true at a particular stage in a method. These conditions, called assertions, guarantee a program’s validity by catching potential bugs and identifying possible logic errors during development. For example, if you write a module that calculates the temperature of an element, you might assert that the calculated temperature is not less than 0 degree Kelvin. The syntax for assert statements are as follows [1]:

assert Expression1;

Expression1 is a [http://en.wikipedia.org/wiki/Boolean_expression Boolean expression]. If Expression1 is evaluated to be false, then the system throws an AssertionError. This syntax for assert will not give a detail error message. Therefore second form of assert syntax can be used [1] as given below
assert Expression1: Expression2;

Expression1 is a Boolean expression. Expression2 is an expression that has a value. This version of the assert statement provides detail message for the AssertionError. The system passes the value of Expression2 to the appropriate AssertionError constructor, which uses the string representation of the value as the error's detail message. This form of the assertion statement should be used in preference to the first only when the program has some additional information that might help diagnose the failure. Below is an example code that demonstrates the functionality of assert statement. This code checks with assert that the value entered is an even number only [2].

import java.util.Scanner;

public class AssertTest
{
public static void main( String args[] )
{
Scanner input = new Scanner( System.in );

System.out.print( "Enter an even number: " );
int number = input.nextInt();

// assert that the number is even
assert ((number % 2 == 0)) : "Not an even number: " + number;

System.out.printf( "You entered an even number %d\n", number );
}
}
OUTPUT:

Enter an even number: 10
You entered an even number 10

Enter an even number: 25
Exception in thread "main" java.lang.AssertionError: Not an even number: 25
at AssertTest.main(AssertTest.java:15)

The above code prompts the user to enter an even number, then this number is read from command prompt. The assert statement then determines whether the user entered an even or odd number. If the user entered an odd number (as in second case of output), then the program throws an error. Otherwise, the program proceeds normally. Any line that executes after the assert statement can safely assume that number is not odd

One obvious question that may arise is when exceptions can do the [http://en.wikipedia.org/wiki/Exception_handling error handling] why we need another level of checking. Java exceptions are primarily used to handle unusual conditions arising during program execution. Assertions are not to replace exceptions but to augment them. Assertions are used to specify conditions that a programmer assumes are true. When programming, if a programmer can swear that the value being passed into a particular method is positive no matter what a calling client passes, it can be documented using an assertion to state it. Exceptions handle abnormal conditions arising in the course of the program; however they do not guarantee smooth or correct execution of the program. Assertions help state scenarios that ensure the program is running smoothly. Assertions can be efficient tools to ensure correct execution of a program. They improve the confidence about the program.

== '''Types of Assertions''' ==
* Preconditions - These are assertions about a program’s state when a method is invoked. Precondition refers to the parameters passed to a method in a program. Precondition asserts check the validity of parameters passed before they get used in the body of the method.
* Postconditions - These are assertions about a program’s state after a method finishes execution. Postcondition should be evaluated before the exit point in a method. Postcondition asserts can be used to check for the validity of the return values in a method that has multiple return statements.

One situation where use of assertions is helpful in Java programming language is : Internal Invariants [1]. Assertions can be used within programs to make sure the program behaves in a predetermined manner and will throw an error when violated. For instance, an assertion can be placed in the code below to declare that age will never be negative.

if (age > 0)
{
age = age + 1;
}
else
{
assert age >0:"Age cannot be negative"
}

== '''Enabling and Disabling Assertions'''==

At runtime assertions are disabled by default as they reduce performance. To enable assertions at [http://en.wikipedia.org/wiki/Run_time_(computing) runtime], use the -ea command-line option. To disable assertions, use –da command line option. To execute a code with assertions enabled use
java -ea AssertTest

The assertion status of a class (enabled or disabled) is set at the time it is initialized, and does not change. There is, however, one corner case that demands special treatment. It is possible, though generally not desirable, to execute methods or constructors prior to initialization. This can happen when a class hierarchy contains circularity in its static initialization. If an assert statement executes before its class is initialized, the execution must behave as if assertions were enabled in the class.

== '''xUnit Frameworks that support testing in Java''' ==

Some of the xUnit frameworks that support testing Java code are JUnit , SpryTest , Jtest , TestNG and JExample. Other testing frameworks supported by Java can be looked up at [9]

= '''Support for Assertions in Ruby''' =

[http://en.wikipedia.org/wiki/Unit_testing Unit testing] is a process where individual parts of [http://en.wikipedia.org/wiki/Source_code source code] are isolated and tested separately to determine if they are bug free. The idea behind unit testing is that you write a test method that makes certain assertions about your code, working against a test fixture. [http://en.wikipedia.org/wiki/Ruby_(programming_language) Ruby language] supports a module called Test::Unit::Assertions in test/unit/assertions.rb. Test::Unit::Assertions contains the standard Test::Unit assertions. Assertions is included in Test::Unit::TestCase.

=='''Public class assert methods'''==

*assert( boolean, [msg] )- This ensures that the object/expression is true
assert [10, 20].include?(50)

*assert_block(message="assert_block failed.") {|| ...} - If the block yields to true , then the assert passes
Example [3]:
def assert_block(message="assert_block failed.") # :yields:
_wrap_assertion do
if (! yield)
raise AssertionFailedError.new(message.to_s)
end
end
end

* assert_match( regexp, string, [msg] )- Ensures that a string matches the regular expression

Example [3]:
def assert_match(pattern, string, message="")
_wrap_assertion do
pattern = case(pattern)
when String
Regexp.new(Regexp.escape(pattern))
else
pattern
end
full_message = build_message(message, "<?> expected to be =~\n<?>.", string, pattern)
assert_block(full_message) { string =~ pattern }
end
end

*assert_not_equal(expected, actual, message="") - If expected != actual, then the assert passes

Example [3]:
def assert_not_equal(expected, actual, message="")
full_message = build_message(message, "<?> expected to be != to\n<?>.", expected, actual)
assert_block(full_message) { expected != actual }
end

*assert_nil(object, message="") - This assert passes if the object is nil.

Example[3]:

# File test/unit/assertions.rb, line 173
def assert_nil(object, message="")
assert_equal(nil, object, message)
end

There are a bunch of other public class methods. This can be obtained from [4]

=='''Test Method & Test Fixture'''==

Assertions must be used inside test methods within test fixtures. Related tests are grouped inside a common test class using assert. The advantage of having a separate class for all related tests is that it keeps the actual developed code to be tested uncluttered from the test code, hence making maintainability easier. It also allows these test code to be deleted from the development code before the final delivery as these test codes are needed mainly for the developer/tester and need not be part of the final product. Main advantage is it allows you to set up a common test fixture for your tests to run against. Test fixtures are a way of organizing test data; they reside in the fixtures folder. The test_helper.rb file holds the default configuration for your tests.

=='''Ruby on Rails'''==

[http://en.wikipedia.org/wiki/Ruby_on_Rails Rails] is an open source web framework for Ruby language. Rails adds some custom assertions of its own to the test/unit framework some of which are as stated below:

*assert_difference(expressions, difference = 1, message = nil) {...}
Test numeric difference between the return value of an expression as a result of what is evaluated in the yielded block.
*assert_recognizes(expected_options, path, extras={}, message=nil)
Asserts that the routing of the given path was handled correctly and that the parsed options (given in the expected_options hash) match path.
Basically, it asserts that Rails recognizes the route given by expected_options.
*assert_template(expected = nil, message=nil)
Asserts that the request was rendered with the appropriate template file.

== '''xUnit Frameworks that support testing in Ruby''' ==

The only xUnit framework that support testing Ruby code is Test::Unit. Other testing frameworks that support Ruby but that do not fall under the xUnit umbrella are RSpec , Shoulda , microtest and Bacon.

= '''Support for Assertions in Python''' =
In [http://www.python.org/ Python] when the [http://docs.python.org/reference/simple_stmts.html#the-assert-statement assert] statement is encountered, the expression following the assert keyword is evaluated and the AssertionError exception is raised if the expression evaluates to false.

== Simple Assert ==

The following code would raise the [http://docs.python.org/library/exceptions.html#exceptions.AssertionError AssertionError] exception.

* assert condition

Example [1]:
#!/usr/bin/python
assert 1 == 2

== Extended Assert ==

In addition to evaluating an expression , arguments can be passed to the assertion so that for example, the right message can be displayed based on the outcome of the assertion.

* assert Expression[, Arguments]

Example [2];
#!/usr/bin/python
def IsSenior(age):
assert (age >= 1),"Age cannot be zero or less than zero !"
return (age >= 65)
print IsSenior(15)
print IsSenior(70)
print IsSenior(-1)

Example [2] Output;
false
true
Traceback (most recent call last):
File "test.py", line 9, in <module>
print IsSenior(-5)
File "test.py", line 4, in IsSenior
assert (age >= 1),"Age cannot be zero or less than zero !"
AssertionError: Age cannot be zero or less than zero !

One of the key feature of assertions in Python is that if python is started with -O option, then the assertions would not be evaluated. The scenario where this feature would apply is developers can write a lot of assertions for debugging and when the code is to be executed in production , if it is started with -O option , then all the assertions written by the developers for debugging would not be evaluated.

In general assertions are not the best means to test for failure cases. Instead of using an assertion exceptions would be the right way to handle scenarios like wrong user input or system/environment failures.

== '''xUnit Frameworks that support testing in Python''' ==

Some of the xUnit frameworks that support testing python code are PyUnit, Nose, py.test and TwistedTrial. Other testing frameworks supported by python can be looked up at [9]

One common used of assertions in python is for type checking. Please refer the article [http://pg-server.csc.ncsu.edu/mediawiki/index.php/CSC/ECE_517_Fall_2007/wiki3_1_sa#Python Assertion in O-O languages] for more details.

= '''Benefits of assertions''' =
*Use of assertions in the program help detect errors immediately and directly, rather than at a later stage. Assertion failure usually reports the location of failure in the code which helps in pin-pointing the error without further debugging.
*Assertions provide run time check for assumptions made by developers
*Assertions are also sometimes placed at points the execution is not supposed to reach. For example, assertions could be placed at the default clause of the switch statement in languages such as C++, and Java. Any case which the programmer does not handle intentionally will raise an error and the program will abort rather than silently continuing in an erroneous state.
*Assertions can be viewed as "dynamic documentation", since they are checked at runtime, contrary to the traditional approach of documenting assumptions via plain /* comments */.

*Assert statements are great for helping you to refactor and optimize your code with greater confidence that you have preserved correctness

= '''Limitations of assertions''' =

*Assertions rarely allow for graceful error recovery. They terminate the program abruptly and may not release some of the resources used by the program; hence it is considered bad practice to rely upon assertions for handling expected error conditions.
* Assertions sometime hinder execution time. For example, if the program has an assert that checks to see if the number to be returned is the smallest in the array, then the assertion will have to do the same amount of work that the method would have to do.

= '''Conclusion''' =

When writing program, it is a good practice to check for violations of basic assumptions in the code. These checks help in debugging code. The assertion facility in J2SE 1.4 (and later versions) provides a unified support for assertions in Java technology as well as a convenient way for developers both to turn assertions on and off as needed. Assertions are used in Test Driven Development(TDD) in Ruby programing language. The Test::Unit library in Ruby has a variety of built in assertions that makes writing tests much easier.

Although the use of assertions replaces the ad hoc use of conditional tests with a uniform methodology, it does not allow for a repair strategy to continue program execution. This means that when an exception is detected, the program aborts with no recovery mechanism. Nevertheless, assertions play an important role in debugging and designing code with testability in mind. The assertion facility can be used to support an informal design-by-contract style of programming.

= '''Reference''' =

[http://download.oracle.com/javase/1.4.2/docs/guide/lang/assert.html] Programming with Assertions

[http://www.deitel.com/articles/java_tutorials/20060106/Assertions.html] Assertions in java

[http://ruby-doc.org/stdlib/libdoc/test/unit/rdoc/classes/Test/Unit/Assertions.html#M004514] Assertions in Ruby

[http://guides.rubyonrails.org/testing.html#assertions-available] Ruby assertions

[http://topfunky.com/clients/rails/ruby_and_rails_assertions.pdf] Ruby on Rails assertion cheat sheet

[http://www.cs.clemson.edu/~malloy/papers/prospectus/prospectus.pdf] More about assertions

[http://docs.python.org/reference/simple_stmts.html] Python simple statements documentation

[http://www.tutorialspoint.com/python/assertions_in_python.htm] Assertions in Python

[http://en.wikipedia.org/wiki/List_of_unit_testing_frameworks] Testing frameworks for programming languages

[http://en.wikipedia.org/wiki/XUnit] xUnit

Zz

2010-11-16T06:14:07Z

Kschidam:

'''Support for Assertions in Various O-O Programming Languages'''

= '''Introduction''' =

In computer language an [http://en.wikipedia.org/wiki/Assertion_(computing) assertion] is a construct that immediately terminates the execution of a program if a certain expression or a condition is evaluated to false (assertion failure). It is mainly used for code [http://en.wikipedia.org/wiki/Debugging debugging] . Programmers use assertions to check for potential errors or bugs in the application being developed. The main feature of assertions is to verify the validity of the assumptions made by chunk of code during execution. A good example to illustrate this is the use of [http://en.wikipedia.org/wiki/Dynamic_memory_allocation dynamic memory allocation] in C++, wherein we can use an assertion to check a [http://en.wikipedia.org/wiki/Pointer_(computing) pointer] and ensure that it is not null before using this pointer. If this check in not made, a reference may occur later that would cause an error. Assertions play a vital role in developing reliable object-oriented software. An early advocate of using assertions in programming was Alan Turing [5]. Assertions serve to make explicit the assumptions on which programmers rely when they write software elements that they believe are correct. Assertion-based Object-Oriented techniques produce reliable software and enable software components to be reused safely. In languages such as Eiffel, assertions form part of the design process, and in others, such as C and Java, they are used only to check assumptions at runtime. Various object oriented programming languages support assertions.

= '''Support for Assertions in Java''' =

When implementing and debugging a class in java programming language, it is a good practice to specify conditions that should be true at a particular stage in a method. These conditions, called assertions, guarantee a program’s validity by catching potential bugs and identifying possible logic errors during development. For example, if you write a module that calculates the temperature of an element, you might assert that the calculated temperature is not less than 0 degree Kelvin. The syntax for assert statements are as follows [1]:

assert Expression1;

Expression1 is a [http://en.wikipedia.org/wiki/Boolean_expression Boolean expression]. If Expression1 is evaluated to be false, then the system throws an AssertionError. This syntax for assert will not give a detail error message. Therefore second form of assert syntax can be used [1] as given below
assert Expression1: Expression2;

Expression1 is a Boolean expression. Expression2 is an expression that has a value. This version of the assert statement provides detail message for the AssertionError. The system passes the value of Expression2 to the appropriate AssertionError constructor, which uses the string representation of the value as the error's detail message. This form of the assertion statement should be used in preference to the first only when the program has some additional information that might help diagnose the failure. Below is an example code that demonstrates the functionality of assert statement. This code checks with assert that the value entered is an even number only [2].

import java.util.Scanner;

public class AssertTest
{
public static void main( String args[] )
{
Scanner input = new Scanner( System.in );

System.out.print( "Enter an even number: " );
int number = input.nextInt();

// assert that the number is even
assert ((number % 2 == 0)) : "Not an even number: " + number;

System.out.printf( "You entered an even number %d\n", number );
}
}
OUTPUT:

Enter an even number: 10
You entered an even number 10

Enter an even number: 25
Exception in thread "main" java.lang.AssertionError: Not an even number: 25
at AssertTest.main(AssertTest.java:15)

The above code prompts the user to enter an even number, then this number is read from command prompt. The assert statement then determines whether the user entered an even or odd number. If the user entered an odd number (as in second case of output), then the program throws an error. Otherwise, the program proceeds normally. Any line that executes after the assert statement can safely assume that number is not odd

One obvious question that may arise is when exceptions can do the [http://en.wikipedia.org/wiki/Exception_handling error handling] why we need another level of checking. Java exceptions are primarily used to handle unusual conditions arising during program execution. Assertions are not to replace exceptions but to augment them. Assertions are used to specify conditions that a programmer assumes are true. When programming, if a programmer can swear that the value being passed into a particular method is positive no matter what a calling client passes, it can be documented using an assertion to state it. Exceptions handle abnormal conditions arising in the course of the program; however they do not guarantee smooth or correct execution of the program. Assertions help state scenarios that ensure the program is running smoothly. Assertions can be efficient tools to ensure correct execution of a program. They improve the confidence about the program.

== '''Types of Assertions''' ==
* Preconditions - These are assertions about a program’s state when a method is invoked. Precondition refers to the parameters passed to a method in a program. Precondition asserts check the validity of parameters passed before they get used in the body of the method.
* Postconditions - These are assertions about a program’s state after a method finishes execution. Postcondition should be evaluated before the exit point in a method. Postcondition asserts can be used to check for the validity of the return values in a method that has multiple return statements.

One situation where use of assertions is helpful in Java programming language is : Internal Invariants [1]. Assertions can be used within programs to make sure the program behaves in a predetermined manner and will throw an error when violated. For instance, an assertion can be placed in the code below to declare that age will never be negative.

if (age > 0)
{
age = age + 1;
}
else
{
assert age >0:"Age cannot be negative"
}

== '''Enabling and Disabling Assertions'''==

At runtime assertions are disabled by default as they reduce performance. To enable assertions at [http://en.wikipedia.org/wiki/Run_time_(computing) runtime], use the -ea command-line option. To disable assertions, use –da command line option. To execute a code with assertions enabled use
java -ea AssertTest

The assertion status of a class (enabled or disabled) is set at the time it is initialized, and does not change. There is, however, one corner case that demands special treatment. It is possible, though generally not desirable, to execute methods or constructors prior to initialization. This can happen when a class hierarchy contains circularity in its static initialization. If an assert statement executes before its class is initialized, the execution must behave as if assertions were enabled in the class.

== '''xUnit Frameworks that support testing in Java''' ==

Some of the xUnit frameworks that support testing Java code are JUnit , SpryTest , Jtest , TestNG and JExample. Other testing frameworks supported by Java can be looked up at [9]

= '''Support for Assertions in Ruby''' =

[http://en.wikipedia.org/wiki/Unit_testing Unit testing] is a process where individual parts of [http://en.wikipedia.org/wiki/Source_code source code] are isolated and tested separately to determine if they are bug free. The idea behind unit testing is that you write a test method that makes certain assertions about your code, working against a test fixture. [http://en.wikipedia.org/wiki/Ruby_(programming_language) Ruby language] supports a module called Test::Unit::Assertions in test/unit/assertions.rb. Test::Unit::Assertions contains the standard Test::Unit assertions. Assertions is includedin Test::Unit::TestCase.

=='''Public class assert methods'''==

*assert( boolean, [msg] )- This ensures that the object/expression is true
assert [10, 20].include?(50)

*assert_block(message="assert_block failed.") {|| ...} - If the block yields to true , then the assert passes
Example [3]:
def assert_block(message="assert_block failed.") # :yields:
_wrap_assertion do
if (! yield)
raise AssertionFailedError.new(message.to_s)
end
end
end

* assert_match( regexp, string, [msg] )- Ensures that a string matches the regular expression

Example [3]:
def assert_match(pattern, string, message="")
_wrap_assertion do
pattern = case(pattern)
when String
Regexp.new(Regexp.escape(pattern))
else
pattern
end
full_message = build_message(message, "<?> expected to be =~\n<?>.", string, pattern)
assert_block(full_message) { string =~ pattern }
end
end

*assert_not_equal(expected, actual, message="") - If expected != actual, then the assert passes

Example [3]:
def assert_not_equal(expected, actual, message="")
full_message = build_message(message, "<?> expected to be != to\n<?>.", expected, actual)
assert_block(full_message) { expected != actual }
end

*assert_nil(object, message="") - This assert passes if the object is nil.

Example[3]:

# File test/unit/assertions.rb, line 173
def assert_nil(object, message="")
assert_equal(nil, object, message)
end

There are a bunch of other public class methods. This can be obtained from [4]

=='''Test Method & Test Fixture'''==

Assertions must be used inside test methods within test fixtures. Related tests are grouped inside a common test class using assert. The advantage of having a separate class for all related tests is that it keeps the actual developed code to be tested uncluttered from the test code, hence making maintainability easier. It also allows these test code to be deleted from the development code before the final delivery as these test codes are needed mainly for the developer/tester and need not be part of the final product. Main advantage is it allows you to set up a common test fixture for your tests to run against. Test fixtures are a way of organizing test data; they reside in the fixtures folder. The test_helper.rb file holds the default configuration for your tests.

=='''Ruby on Rails'''==

[http://en.wikipedia.org/wiki/Ruby_on_Rails Rails] is an open source web framework for Ruby language. Rails adds some custom assertions of its own to the test/unit framework some of which are as stated below:

*assert_difference(expressions, difference = 1, message = nil) {...}
Test numeric difference between the return value of an expression as a result of what is evaluated in the yielded block.
*assert_recognizes(expected_options, path, extras={}, message=nil)
Asserts that the routing of the given path was handled correctly and that the parsed options (given in the expected_options hash) match path.
Basically, it asserts that Rails recognizes the route given by expected_options.
*assert_template(expected = nil, message=nil)
Asserts that the request was rendered with the appropriate template file.

== '''xUnit Frameworks that support testing in Ruby''' ==

The only xUnit framework that support testing Ruby code is Test::Unit. Other testing frameworks that support Ruby but that do not fall under the xUnit umbrella are RSpec , Shoulda , microtest and Bacon.

= '''Support for Assertions in Python''' =
In [http://www.python.org/ Python] when the [http://docs.python.org/reference/simple_stmts.html#the-assert-statement assert] statement is encountered, the expression following the assert keyword is evaluated and the AssertionError exception is raised if the expression evaluates to false.

== Simple Assert ==

The following code would raise the [http://docs.python.org/library/exceptions.html#exceptions.AssertionError AssertionError] exception.

* assert condition

Example [1]:
#!/usr/bin/python
assert 1 == 2

== Extended Assert ==

In addition to evaluating an expression , arguments can be passed to the assertion so that for example, the right message can be displayed based on the outcome of the assertion.

* assert Expression[, Arguments]

Example [2];
#!/usr/bin/python
def IsSenior(age):
assert (age >= 1),"Age cannot be zero or less than zero !"
return (age >= 65)
print IsSenior(15)
print IsSenior(70)
print IsSenior(-1)

Example [2] Output;
false
true
Traceback (most recent call last):
File "test.py", line 9, in <module>
print IsSenior(-5)
File "test.py", line 4, in IsSenior
assert (age >= 1),"Age cannot be zero or less than zero !"
AssertionError: Age cannot be zero or less than zero !

One of the key feature of assertions in Python is that if python is started with -O option, then the assertions would not be evaluated. The scenario where this feature would apply is developers can write a lot of assertions for debugging and when the code is to be executed in production , if it is started with -O option , then all the assertions written by the developers for debugging would not be evaluated.

In general assertions are not the best means to test for failure cases. Instead of using an assertion exceptions would be the right way to handle scenarios like wrong user input or system/environment failures.

== '''xUnit Frameworks that support testing in Python''' ==

Some of the xUnit frameworks that support testing python code are PyUnit, Nose, py.test and TwistedTrial. Other testing frameworks supported by python can be looked up at [9]

One common used of assertions in python is for type checking. Please refer the article [http://pg-server.csc.ncsu.edu/mediawiki/index.php/CSC/ECE_517_Fall_2007/wiki3_1_sa#Python Assertion in O-O languages] for more details.

= '''Benefits of assertions''' =
*Use of assertions in the program help detect errors immediately and directly, rather than at a later stage. Assertion failure usually reports the location of failure in the code which helps in pin-pointing the error without further debugging.
*Assertions provide run time check for assumptions made by developers
*Assertions are also sometimes placed at points the execution is not supposed to reach. For example, assertions could be placed at the default clause of the switch statement in languages such as C++, and Java. Any case which the programmer does not handle intentionally will raise an error and the program will abort rather than silently continuing in an erroneous state.
*Assertions can be viewed as "dynamic documentation", since they are checked at runtime, contrary to the traditional approach of documenting assumptions via plain /* comments */.

*Assert statements are great for helping you torefactor and optimize your code with greater confidence that you have preserved correctness

= '''Limitations of assertions''' =

*Assertions rarely allow for graceful error recovery. They terminate the program abruptly and may not release some of the resources used by the program; hence it is considered bad practice to rely upon assertions for handling expected error conditions.
* Assertions sometime hinder execution time. For example, if the program has an assert that checks to see if the number to be returned is the smallest in the array, then the assertion will have to do the same amount of work that the method would have to do.

= '''Conclusion''' =

When writing program, it is a good practice to check for violations of basic assumptions in the code. These checks help in debugging code. The assertion facility in J2SE 1.4 (and later versions) provides a unified support for assertions in Java technology as well as a convenient way for developers both to turn assertions on and off as needed. Assertions are used in Test Driven Development(TDD) in Ruby programing language. The Test::Unit library in Ruby has a variety of built in assertions that makes writing tests much easier.

Although the use of assertions replaces the ad hoc use of conditional tests with a uniform methodology, it does not allow for a repair strategy to continue program execution. This means that when an exception is detected, the program aborts with no recovery mechanism. Nevertheless, assertions play an important role in debugging and designing code with testability in mind. The assertion facility can be used to support an informal design-by-contract style of programming.

= '''Reference''' =

[http://download.oracle.com/javase/1.4.2/docs/guide/lang/assert.html] Programming with Assertions

[http://www.deitel.com/articles/java_tutorials/20060106/Assertions.html] Assertions in java

[http://ruby-doc.org/stdlib/libdoc/test/unit/rdoc/classes/Test/Unit/Assertions.html#M004514] Assertions in Ruby

[http://guides.rubyonrails.org/testing.html#assertions-available] Ruby assertions

[http://topfunky.com/clients/rails/ruby_and_rails_assertions.pdf] Ruby on Rails assertion cheat sheet

[http://www.cs.clemson.edu/~malloy/papers/prospectus/prospectus.pdf] More about assertions

[http://docs.python.org/reference/simple_stmts.html] Python simple statements documentation

[http://www.tutorialspoint.com/python/assertions_in_python.htm] Assertions in Python

[http://en.wikipedia.org/wiki/List_of_unit_testing_frameworks] Testing frameworks for programming languages

[http://en.wikipedia.org/wiki/XUnit] xUnit

Zz

2010-11-16T04:45:16Z

Kschidam:

'''Support for Assertions in Various O-O Programming Languages'''

= '''Introduction''' =

In computer language an [http://en.wikipedia.org/wiki/Assertion_(computing) assertion] is a construct that immediately terminates the execution of a program if a certain expression or a condition is evaluated to false (assertion failure). It is mainly used for code [http://en.wikipedia.org/wiki/Debugging debugging] . Programmers use assertions to check for potential errors or bugs in the application being developed. The main feature of assertions is to verify the validity of the assumptions made by chunk of code during execution. A good example to illustrate this is the use of [http://en.wikipedia.org/wiki/Dynamic_memory_allocation dynamic memory allocation] in C++, wherein we can use an assertion to check a [http://en.wikipedia.org/wiki/Pointer_(computing) pointer] and ensure that it is not null before using this pointer. If this check in not made, a reference may occur later that would cause an error. Assertions play a vital role in developing reliable object-oriented software. An early advocate of using assertions in programming was Alan Turing [5]. Assertions serve to make explicit the assumptions on which programmers rely when they write software elements that they believe are correct. Assertion-based Object-Oriented techniques produce reliable software and enable software components to be reused safely. In languages such as Eiffel, assertions form part of the design process, and in others, such as C and Java, they are used only to check assumptions at runtime. Various object oriented programming languages support assertions.

= '''Support for Assertions in Java''' =

When implementing and debugging a class in java programming language, it is a good practice to specify conditions that should be true at a particular stage in a method. These conditions, called assertions, guarantee a program’s validity by catching potential bugs and identifying possible logic errors during development. For example, if you write a module that calculates the temperature of an element, you might assert that the calculated temperature is not less than 0 degree Kelvin. The syntax for assert statements are as follows [1]:

assert Expression1;

Expression1 is a [http://en.wikipedia.org/wiki/Boolean_expression Boolean expression]. If Expression1 is evaluated to be false, then the system throws an AssertionError. This syntax for assert will not give a detail error message. Therefore second form of assert syntax can be used [1] as given below
assert Expression1: Expression2;

Expression1 is a Boolean expression. Expression2 is an expression that has a value. This version of the assert statement provides detail message for the AssertionError. The system passes the value of Expression2 to the appropriate AssertionError constructor, which uses the string representation of the value as the error's detail message. This form of the assertion statement should be used in preference to the first only when the program has some additional information that might help diagnose the failure. Below is an example code that demonstrates the functionality of assert statement. This code checks with assert that the value entered is an even number only [2].

import java.util.Scanner;

public class AssertTest
{
public static void main( String args[] )
{
Scanner input = new Scanner( System.in );

System.out.print( "Enter an even number: " );
int number = input.nextInt();

// assert that the number is even
assert ((number % 2 == 0)) : "Not an even number: " + number;

System.out.printf( "You entered an even number %d\n", number );
}
}
OUTPUT:

Enter an even number: 10
You entered an even number 10

Enter an even number: 25
Exception in thread "main" java.lang.AssertionError: Not an even number: 25
at AssertTest.main(AssertTest.java:15)

The above code prompts the user to enter an even number, then this number is read from command prompt. The assert statement then determines whether the user entered an even or odd number. If the user entered an odd number (as in second case of output), then the program throws an error. Otherwise, the program proceeds normally. Any line that executes after the assert statement can safely assume that number is not odd

One obvious question that may arise is when exceptions can do the [http://en.wikipedia.org/wiki/Exception_handling error handling] why we need another level of checking. Java exceptions are primarily used to handle unusual conditions arising during program execution. Assertions are not to replace exceptions but to augment them. Assertions are used to specify conditions that a programmer assumes are true. When programming, if a programmer can swear that the value being passed into a particular method is positive no matter what a calling client passes, it can be documented using an assertion to state it. Exceptions handle abnormal conditions arising in the course of the program; however they do not guarantee smooth or correct execution of the program. Assertions help state scenarios that ensure the program is running smoothly. Assertions can be efficient tools to ensure correct execution of a program. They improve the confidence about the program.

== '''Types of Assertions''' ==
* Preconditions - These are assertions about a program’s state when a method is invoked. Precondition refers to the parameters passed to a method in a program. Precondition asserts check the validity of parameters passed before they get used in the body of the method.
* Postconditions - These are assertions about a program’s state after a method finishes execution. Postcondition should be evaluated before the exit point in a method. Postcondition asserts can be used to check for the validity of the return values in a method that has multiple return statements.

One situation where use of assertions is helpful in Java programming language is : Internal Invariants [1]. Assertions can be used within programs to make sure the program behaves in a predetermined manner and will throw an error when violated. For instance, an assertion can be placed in the code below to declare that age will never be negative.

if (age > 0)
{
age = age + 1;
}
else
{
assert age >0:"Age cannot be negative"
}

== '''Enabling and Disabling Assertions'''==

At runtime assertions are disabled by default as they reduce performance. To enable assertions at [http://en.wikipedia.org/wiki/Run_time_(computing) runtime], use the -ea command-line option. To disable assertions, use –da command line option. To execute a code with assertions enabled use
java -ea AssertTest

The assertion status of a class (enabled or disabled) is set at the time it is initialized, and does not change. There is, however, one corner case that demands special treatment. It is possible, though generally not desirable, to execute methods or constructors prior to initialization. This can happen when a class hierarchy contains circularity in its static initialization. If an assert statement executes before its class is initialized, the execution must behave as if assertions were enabled in the class.

== '''xUnit Frameworks that support testing in Java''' ==

Some of the xUnit frameworks that support testing Java code are JUnit , SpryTest , Jtest , TestNG and JExample. Other testing frameworks supported by Java can be looked up at [9]

= '''Support for Assertions in Ruby''' =

[http://en.wikipedia.org/wiki/Unit_testing Unit testing] is a process where individual parts of [http://en.wikipedia.org/wiki/Source_code source code] are isolated and tested separately to determine if they are bug free. The idea behind unit testing is that you write a test method that makes certain assertions about your code, working against a test fixture. [http://en.wikipedia.org/wiki/Ruby_(programming_language) Ruby language] supports a module called Test::Unit::Assertions in test/unit/assertions.rb. Test::Unit::Assertions contains the standard Test::Unit assertions. Assertions is includedin Test::Unit::TestCase.

=='''Public class assert methods'''==

*assert( boolean, [msg] )- This ensures that the object/expression is true
assert [10, 20].include?(50)

*assert_block(message="assert_block failed.") {|| ...} - If the block yields to true , then the assert passes
Example [3]:
def assert_block(message="assert_block failed.") # :yields:
_wrap_assertion do
if (! yield)
raise AssertionFailedError.new(message.to_s)
end
end
end

* assert_match( regexp, string, [msg] )- Ensures that a string matches the regular expression

Example [3]:
def assert_match(pattern, string, message="")
_wrap_assertion do
pattern = case(pattern)
when String
Regexp.new(Regexp.escape(pattern))
else
pattern
end
full_message = build_message(message, "<?> expected to be =~\n<?>.", string, pattern)
assert_block(full_message) { string =~ pattern }
end
end

*assert_not_equal(expected, actual, message="") - If expected != actual, then the assert passes

Example [3]:
def assert_not_equal(expected, actual, message="")
full_message = build_message(message, "<?> expected to be != to\n<?>.", expected, actual)
assert_block(full_message) { expected != actual }
end

*assert_nil(object, message="") - This assert passes if the object is nil.

Example[3]:

# File test/unit/assertions.rb, line 173
def assert_nil(object, message="")
assert_equal(nil, object, message)
end

There are a bunch of other public class methods. This can be obtained from [4]

=='''Test Method & Test Fixture'''==

Assertions must be used inside test methods within test fixtures. Related tests are grouped inside a common test class using assert. The advantage of having a separate class for all related tests is that it keeps the actual developed code to be tested uncluttered from the test code, hence making maintainability easier. It also allows these test code to be deleted from the development code before the final delivery as these test codes are needed mainly for the developer/tester and need not be part of the final product. Main advantage is it allows you to set up a common test fixture for your tests to run against. Test fixtures are a way of organizing test data; they reside in the fixtures folder. The test_helper.rb file holds the default configuration for your tests.

=='''Ruby on Rails'''==

[http://en.wikipedia.org/wiki/Ruby_on_Rails Rails] is an open source web framework for Ruby language. Rails adds some custom assertions of its own to the test/unit framework some of which are as stated below:

*assert_difference(expressions, difference = 1, message = nil) {...}
Test numeric difference between the return value of an expression as a result of what is evaluated in the yielded block.
*assert_recognizes(expected_options, path, extras={}, message=nil)
Asserts that the routing of the given path was handled correctly and that the parsed options (given in the expected_options hash) match path.
Basically, it asserts that Rails recognizes the route given by expected_options.
*assert_template(expected = nil, message=nil)
Asserts that the request was rendered with the appropriate template file.

== '''xUnit Frameworks that support testing in Ruby''' ==

The only xUnit framework that support testing Ruby code is Test::Unit. Other testing frameworks that support Ruby but that do not fall under the xUnit umbrella are RSpec , Shoulda , microtest and Bacon.

= '''Support for Assertions in Python''' =
In [http://www.python.org/ Python] when the [http://docs.python.org/reference/simple_stmts.html#the-assert-statement assert] statement is encountered, the expression following the assert keyword is evaluated and the AssertionError exception is raised if the expression evaluates to false.

== Simple Assert ==

The following code would raise the [http://docs.python.org/library/exceptions.html#exceptions.AssertionError AssertionError] exception.

* assert condition

Example [1]:
#!/usr/bin/python
assert 1 == 2

== Extended Assert ==

In addition to evaluating an expression , arguments can be passed to the assertion so that for example, the right message can be displayed based on the outcome of the assertion.

* assert Expression[, Arguments]

Example [2];
#!/usr/bin/python
def IsSenior(age):
assert (age >= 1),"Age cannot be zero or less than zero !"
return (age >= 65)
print IsSenior(15)
print IsSenior(70)
print IsSenior(-1)

Example [2] Output;
false
true
Traceback (most recent call last):
File "test.py", line 9, in <module>
print IsSenior(-5)
File "test.py", line 4, in IsSenior
assert (age >= 1),"Age cannot be zero or less than zero !"
AssertionError: Age cannot be zero or less than zero !

== '''xUnit Frameworks that support testing in Python''' ==

Some of the xUnit frameworks that support testing python code are PyUnit, Nose, py.test and TwistedTrial. Other testing frameworks supported by python can be looked up at [9]

One common used of assertions in python is for type checking. Please refer the article [http://pg-server.csc.ncsu.edu/mediawiki/index.php/CSC/ECE_517_Fall_2007/wiki3_1_sa#Python Assertion in O-O languages] for more details.

One of the key feature of assertions in Python is that if python is started with -O option, then the assertions would not be evaluated. The scenario where this feature would apply is developers can write a lot of assertions for debugging and when the code is to be executed in production , if it is started with -O option , then all the assertions written by the developers for debugging would not be evaluated.

In general assertions are not the best means to test for failure cases. Instead of using an assertion exceptions would be the right way to handle scenarios like wrong user input or system/environment failures.

= '''Benefits of assertions''' =
*Use of assertions in the program help detect errors immediately and directly, rather than at a later stage. Assertion failure usually reports the location of failure in the code which helps in pin-pointing the error without further debugging.
*Assertions provide run time check for assumptions made by developers
*Assertions are also sometimes placed at points the execution is not supposed to reach. For example, assertions could be placed at the default clause of the switch statement in languages such as C++, and Java. Any case which the programmer does not handle intentionally will raise an error and the program will abort rather than silently continuing in an erroneous state.
*Assertions can be viewed as "dynamic documentation", since they are checked at runtime, contrary to the traditional approach of documenting assumptions via plain /* comments */.

*Assert statements are great for helping you torefactor and optimize your code with greater confidence that you have preserved correctness

= '''Limitations of assertions''' =

*Assertions rarely allow for graceful error recovery. They terminate the program abruptly and may not release some of the resources used by the program; hence it is considered bad practice to rely upon assertions for handling expected error conditions.
* Assertions sometime hinder execution time. For example, if the program has an assert that checks to see if the number to be returned is the smallest in the array, then the assertion will have to do the same amount of work that the method would have to do.

= '''Conclusion''' =

When writing program, it is a good practice to check for violations of basic assumptions in the code. These checks help in debugging code. The assertion facility in J2SE 1.4 (and later versions) provides a unified support for assertions in Java technology as well as a convenient way for developers both to turn assertions on and off as needed. Assertions are used in Test Driven Development(TDD) in Ruby programing language. The Test::Unit library in Ruby has a variety of built in assertions that makes writing tests much easier.

Although the use of assertions replaces the ad hoc use of conditional tests with a uniform methodology, it does not allow for a repair strategy to continue program execution. This means that when an exception is detected, the program aborts with no recovery mechanism. Nevertheless, assertions play an important role in debugging and designing code with testability in mind. The assertion facility can be used to support an informal design-by-contract style of programming.

= '''Reference''' =

[http://download.oracle.com/javase/1.4.2/docs/guide/lang/assert.html] Programming with Assertions

[http://www.deitel.com/articles/java_tutorials/20060106/Assertions.html] Assertions in java

[http://ruby-doc.org/stdlib/libdoc/test/unit/rdoc/classes/Test/Unit/Assertions.html#M004514] Assertions in Ruby

[http://guides.rubyonrails.org/testing.html#assertions-available] Ruby assertions

[http://topfunky.com/clients/rails/ruby_and_rails_assertions.pdf] Ruby on Rails assertion cheat sheet

[http://www.cs.clemson.edu/~malloy/papers/prospectus/prospectus.pdf] More about assertions

[http://docs.python.org/reference/simple_stmts.html] Python simple statements documentation

[http://www.tutorialspoint.com/python/assertions_in_python.htm] Assertions in Python

[http://en.wikipedia.org/wiki/List_of_unit_testing_frameworks] Testing frameworks for programming languages

[http://en.wikipedia.org/wiki/XUnit] xUnit

Zz

2010-11-16T04:44:25Z

Kschidam:

'''Support for Assertions in Various O-O Programming Languages'''

= '''Introduction''' =

In computer language an [http://en.wikipedia.org/wiki/Assertion_(computing) assertion] is a construct that immediately terminates the execution of a program if a certain expression or a condition is evaluated to false (assertion failure). It is mainly used for code [http://en.wikipedia.org/wiki/Debugging debugging] . Programmers use assertions to check for potential errors or bugs in the application being developed. The main feature of assertions is to verify the validity of the assumptions made by chunk of code during execution. A good example to illustrate this is the use of [http://en.wikipedia.org/wiki/Dynamic_memory_allocation dynamic memory allocation] in C++, wherein we can use an assertion to check a [http://en.wikipedia.org/wiki/Pointer_(computing) pointer] and ensure that it is not null before using this pointer. If this check in not made, a reference may occur later that would cause an error. Assertions play a vital role in developing reliable object-oriented software. An early advocate of using assertions in programming was Alan Turing [5]. Assertions serve to make explicit the assumptions on which programmers rely when they write software elements that they believe are correct. Assertion-based Object-Oriented techniques produce reliable software and enable software components to be reused safely. In languages such as Eiffel, assertions form part of the design process, and in others, such as C and Java, they are used only to check assumptions at runtime. Various object oriented programming languages support assertions.

= '''Support for Assertions in Java''' =

When implementing and debugging a class in java programming language, it is a good practice to specify conditions that should be true at a particular stage in a method. These conditions, called assertions, guarantee a program’s validity by catching potential bugs and identifying possible logic errors during development. For example, if you write a module that calculates the temperature of an element, you might assert that the calculated temperature is not less than 0 degree Kelvin. The syntax for assert statements are as follows [1]:

assert Expression1;

Expression1 is a [http://en.wikipedia.org/wiki/Boolean_expression Boolean expression]. If Expression1 is evaluated to be false, then the system throws an AssertionError. This syntax for assert will not give a detail error message. Therefore second form of assert syntax can be used [1] as given below
assert Expression1: Expression2;

Expression1 is a Boolean expression. Expression2 is an expression that has a value. This version of the assert statement provides detail message for the AssertionError. The system passes the value of Expression2 to the appropriate AssertionError constructor, which uses the string representation of the value as the error's detail message. This form of the assertion statement should be used in preference to the first only when the program has some additional information that might help diagnose the failure. Below is an example code that demonstrates the functionality of assert statement. This code checks with assert that the value entered is an even number only [2].

import java.util.Scanner;

public class AssertTest
{
public static void main( String args[] )
{
Scanner input = new Scanner( System.in );

System.out.print( "Enter an even number: " );
int number = input.nextInt();

// assert that the number is even
assert ((number % 2 == 0)) : "Not an even number: " + number;

System.out.printf( "You entered an even number %d\n", number );
}
}
OUTPUT:

Enter an even number: 10
You entered an even number 10

Enter an even number: 25
Exception in thread "main" java.lang.AssertionError: Not an even number: 25
at AssertTest.main(AssertTest.java:15)

The above code prompts the user to enter an even number, then this number is read from command prompt. The assert statement then determines whether the user entered an even or odd number. If the user entered an odd number (as in second case of output), then the program throws an error. Otherwise, the program proceeds normally. Any line that executes after the assert statement can safely assume that number is not odd

One obvious question that may arise is when exceptions can do the [http://en.wikipedia.org/wiki/Exception_handling error handling] why we need another level of checking. Java exceptions are primarily used to handle unusual conditions arising during program execution. Assertions are not to replace exceptions but to augment them. Assertions are used to specify conditions that a programmer assumes are true. When programming, if a programmer can swear that the value being passed into a particular method is positive no matter what a calling client passes, it can be documented using an assertion to state it. Exceptions handle abnormal conditions arising in the course of the program; however they do not guarantee smooth or correct execution of the program. Assertions help state scenarios that ensure the program is running smoothly. Assertions can be efficient tools to ensure correct execution of a program. They improve the confidence about the program.

== '''Types of Assertions''' ==
* Preconditions - These are assertions about a program’s state when a method is invoked. Precondition refers to the parameters passed to a method in a program. Precondition asserts check the validity of parameters passed before they get used in the body of the method.
* Postconditions - These are assertions about a program’s state after a method finishes execution. Postcondition should be evaluated before the exit point in a method. Postcondition asserts can be used to check for the validity of the return values in a method that has multiple return statements.

One situation where use of assertions is helpful in Java programming language is : Internal Invariants [1]. Assertions can be used within programs to make sure the program behaves in a predetermined manner and will throw an error when violated. For instance, an assertion can be placed in the code below to declare that age will never be negative.

if (age > 0)
{
age = age + 1;
}
else
{
assert age >0:"Age cannot be negative"
}

== '''Enabling and Disabling Assertions'''==

At runtime assertions are disabled by default as they reduce performance. To enable assertions at [http://en.wikipedia.org/wiki/Run_time_(computing) runtime], use the -ea command-line option. To disable assertions, use –da command line option. To execute a code with assertions enabled use
java -ea AssertTest

The assertion status of a class (enabled or disabled) is set at the time it is initialized, and does not change. There is, however, one corner case that demands special treatment. It is possible, though generally not desirable, to execute methods or constructors prior to initialization. This can happen when a class hierarchy contains circularity in its static initialization. If an assert statement executes before its class is initialized, the execution must behave as if assertions were enabled in the class.

== '''xUnit Frameworks that support testing in Java''' ==

Some of the xUnit frameworks that support testing Java code are JUnit , SpryTest , Jtest , TestNG and JExample. Other testing frameworks supported by Java can be looked up at [9]

= '''Support for Assertions in Ruby''' =

[http://en.wikipedia.org/wiki/Unit_testing Unit testing] is a process where individual parts of [http://en.wikipedia.org/wiki/Source_code source code] are isolated and tested separately to determine if they are bug free. The idea behind unit testing is that you write a test method that makes certain assertions about your code, working against a test fixture. [http://en.wikipedia.org/wiki/Ruby_(programming_language) Ruby language] supports a module called Test::Unit::Assertions in test/unit/assertions.rb. Test::Unit::Assertions contains the standard Test::Unit assertions. Assertions is includedin Test::Unit::TestCase.

=='''Public class assert methods'''==

*assert( boolean, [msg] )- This ensures that the object/expression is true
assert [10, 20].include?(50)

*assert_block(message="assert_block failed.") {|| ...} - If the block yields to true , then the assert passes
Example [3]:
def assert_block(message="assert_block failed.") # :yields:
_wrap_assertion do
if (! yield)
raise AssertionFailedError.new(message.to_s)
end
end
end

* assert_match( regexp, string, [msg] )- Ensures that a string matches the regular expression

Example [3]:
def assert_match(pattern, string, message="")
_wrap_assertion do
pattern = case(pattern)
when String
Regexp.new(Regexp.escape(pattern))
else
pattern
end
full_message = build_message(message, "<?> expected to be =~\n<?>.", string, pattern)
assert_block(full_message) { string =~ pattern }
end
end

*assert_not_equal(expected, actual, message="") - If expected != actual, then the assert passes

Example [3]:
def assert_not_equal(expected, actual, message="")
full_message = build_message(message, "<?> expected to be != to\n<?>.", expected, actual)
assert_block(full_message) { expected != actual }
end

*assert_nil(object, message="") - This assert passes if the object is nil.

Example[3]:

# File test/unit/assertions.rb, line 173
def assert_nil(object, message="")
assert_equal(nil, object, message)
end

There are a bunch of other public class methods. This can be obtained from [4]

== '''xUnit Frameworks that support testing in Ruby''' ==

The only xUnit framework that support testing Ruby code is Test::Unit. Other testing frameworks that support Ruby but that do not fall under the xUnit umbrella are RSpec , Shoulda , microtest and Bacon.

=='''Test Method & Test Fixture'''==

Assertions must be used inside test methods within test fixtures. Related tests are grouped inside a common test class using assert. The advantage of having a separate class for all related tests is that it keeps the actual developed code to be tested uncluttered from the test code, hence making maintainability easier. It also allows these test code to be deleted from the development code before the final delivery as these test codes are needed mainly for the developer/tester and need not be part of the final product. Main advantage is it allows you to set up a common test fixture for your tests to run against. Test fixtures are a way of organizing test data; they reside in the fixtures folder. The test_helper.rb file holds the default configuration for your tests.

=='''Ruby on Rails'''==

[http://en.wikipedia.org/wiki/Ruby_on_Rails Rails] is an open source web framework for Ruby language. Rails adds some custom assertions of its own to the test/unit framework some of which are as stated below:

*assert_difference(expressions, difference = 1, message = nil) {...}
Test numeric difference between the return value of an expression as a result of what is evaluated in the yielded block.
*assert_recognizes(expected_options, path, extras={}, message=nil)
Asserts that the routing of the given path was handled correctly and that the parsed options (given in the expected_options hash) match path.
Basically, it asserts that Rails recognizes the route given by expected_options.
*assert_template(expected = nil, message=nil)
Asserts that the request was rendered with the appropriate template file.

= '''Support for Assertions in Python''' =
In [http://www.python.org/ Python] when the [http://docs.python.org/reference/simple_stmts.html#the-assert-statement assert] statement is encountered, the expression following the assert keyword is evaluated and the AssertionError exception is raised if the expression evaluates to false.

== Simple Assert ==

The following code would raise the [http://docs.python.org/library/exceptions.html#exceptions.AssertionError AssertionError] exception.

* assert condition

Example [1]:
#!/usr/bin/python
assert 1 == 2

== Extended Assert ==

In addition to evaluating an expression , arguments can be passed to the assertion so that for example, the right message can be displayed based on the outcome of the assertion.

* assert Expression[, Arguments]

Example [2];
#!/usr/bin/python
def IsSenior(age):
assert (age >= 1),"Age cannot be zero or less than zero !"
return (age >= 65)
print IsSenior(15)
print IsSenior(70)
print IsSenior(-1)

Example [2] Output;
false
true
Traceback (most recent call last):
File "test.py", line 9, in <module>
print IsSenior(-5)
File "test.py", line 4, in IsSenior
assert (age >= 1),"Age cannot be zero or less than zero !"
AssertionError: Age cannot be zero or less than zero !

== '''xUnit Frameworks that support testing in Python''' ==

Some of the xUnit frameworks that support testing python code are PyUnit, Nose, py.test and TwistedTrial. Other testing frameworks supported by python can be looked up at [9]

One common used of assertions in python is for type checking. Please refer the article [http://pg-server.csc.ncsu.edu/mediawiki/index.php/CSC/ECE_517_Fall_2007/wiki3_1_sa#Python Assertion in O-O languages] for more details.

One of the key feature of assertions in Python is that if python is started with -O option, then the assertions would not be evaluated. The scenario where this feature would apply is developers can write a lot of assertions for debugging and when the code is to be executed in production , if it is started with -O option , then all the assertions written by the developers for debugging would not be evaluated.

In general assertions are not the best means to test for failure cases. Instead of using an assertion exceptions would be the right way to handle scenarios like wrong user input or system/environment failures.

= '''Benefits of assertions''' =
*Use of assertions in the program help detect errors immediately and directly, rather than at a later stage. Assertion failure usually reports the location of failure in the code which helps in pin-pointing the error without further debugging.
*Assertions provide run time check for assumptions made by developers
*Assertions are also sometimes placed at points the execution is not supposed to reach. For example, assertions could be placed at the default clause of the switch statement in languages such as C++, and Java. Any case which the programmer does not handle intentionally will raise an error and the program will abort rather than silently continuing in an erroneous state.
*Assertions can be viewed as "dynamic documentation", since they are checked at runtime, contrary to the traditional approach of documenting assumptions via plain /* comments */.

*Assert statements are great for helping you torefactor and optimize your code with greater confidence that you have preserved correctness

= '''Limitations of assertions''' =

*Assertions rarely allow for graceful error recovery. They terminate the program abruptly and may not release some of the resources used by the program; hence it is considered bad practice to rely upon assertions for handling expected error conditions.
* Assertions sometime hinder execution time. For example, if the program has an assert that checks to see if the number to be returned is the smallest in the array, then the assertion will have to do the same amount of work that the method would have to do.

= '''Conclusion''' =

When writing program, it is a good practice to check for violations of basic assumptions in the code. These checks help in debugging code. The assertion facility in J2SE 1.4 (and later versions) provides a unified support for assertions in Java technology as well as a convenient way for developers both to turn assertions on and off as needed. Assertions are used in Test Driven Development(TDD) in Ruby programing language. The Test::Unit library in Ruby has a variety of built in assertions that makes writing tests much easier.

Although the use of assertions replaces the ad hoc use of conditional tests with a uniform methodology, it does not allow for a repair strategy to continue program execution. This means that when an exception is detected, the program aborts with no recovery mechanism. Nevertheless, assertions play an important role in debugging and designing code with testability in mind. The assertion facility can be used to support an informal design-by-contract style of programming.

= '''Reference''' =

[http://download.oracle.com/javase/1.4.2/docs/guide/lang/assert.html] Programming with Assertions

[http://www.deitel.com/articles/java_tutorials/20060106/Assertions.html] Assertions in java

[http://ruby-doc.org/stdlib/libdoc/test/unit/rdoc/classes/Test/Unit/Assertions.html#M004514] Assertions in Ruby

[http://guides.rubyonrails.org/testing.html#assertions-available] Ruby assertions

[http://topfunky.com/clients/rails/ruby_and_rails_assertions.pdf] Ruby on Rails assertion cheat sheet

[http://www.cs.clemson.edu/~malloy/papers/prospectus/prospectus.pdf] More about assertions

[http://docs.python.org/reference/simple_stmts.html] Python simple statements documentation

[http://www.tutorialspoint.com/python/assertions_in_python.htm] Assertions in Python

[http://en.wikipedia.org/wiki/List_of_unit_testing_frameworks] Testing frameworks for programming languages

[http://en.wikipedia.org/wiki/XUnit] xUnit

Zz

2010-11-16T04:43:38Z

Kschidam:

'''Support for Assertions in Various O-O Programming Languages'''

= '''Introduction''' =

In computer language an [http://en.wikipedia.org/wiki/Assertion_(computing) assertion] is a construct that immediately terminates the execution of a program if a certain expression or a condition is evaluated to false (assertion failure). It is mainly used for code [http://en.wikipedia.org/wiki/Debugging debugging] . Programmers use assertions to check for potential errors or bugs in the application being developed. The main feature of assertions is to verify the validity of the assumptions made by chunk of code during execution. A good example to illustrate this is the use of [http://en.wikipedia.org/wiki/Dynamic_memory_allocation dynamic memory allocation] in C++, wherein we can use an assertion to check a [http://en.wikipedia.org/wiki/Pointer_(computing) pointer] and ensure that it is not null before using this pointer. If this check in not made, a reference may occur later that would cause an error. Assertions play a vital role in developing reliable object-oriented software. An early advocate of using assertions in programming was Alan Turing [5]. Assertions serve to make explicit the assumptions on which programmers rely when they write software elements that they believe are correct. Assertion-based Object-Oriented techniques produce reliable software and enable software components to be reused safely. In languages such as Eiffel, assertions form part of the design process, and in others, such as C and Java, they are used only to check assumptions at runtime. Various object oriented programming languages support assertions.

= '''Support for Assertions in Java''' =

When implementing and debugging a class in java programming language, it is a good practice to specify conditions that should be true at a particular stage in a method. These conditions, called assertions, guarantee a program’s validity by catching potential bugs and identifying possible logic errors during development. For example, if you write a module that calculates the temperature of an element, you might assert that the calculated temperature is not less than 0 degree Kelvin. The syntax for assert statements are as follows [1]:

assert Expression1;

Expression1 is a [http://en.wikipedia.org/wiki/Boolean_expression Boolean expression]. If Expression1 is evaluated to be false, then the system throws an AssertionError. This syntax for assert will not give a detail error message. Therefore second form of assert syntax can be used [1] as given below
assert Expression1: Expression2;

Expression1 is a Boolean expression. Expression2 is an expression that has a value. This version of the assert statement provides detail message for the AssertionError. The system passes the value of Expression2 to the appropriate AssertionError constructor, which uses the string representation of the value as the error's detail message. This form of the assertion statement should be used in preference to the first only when the program has some additional information that might help diagnose the failure. Below is an example code that demonstrates the functionality of assert statement. This code checks with assert that the value entered is an even number only [2].

import java.util.Scanner;

public class AssertTest
{
public static void main( String args[] )
{
Scanner input = new Scanner( System.in );

System.out.print( "Enter an even number: " );
int number = input.nextInt();

// assert that the number is even
assert ((number % 2 == 0)) : "Not an even number: " + number;

System.out.printf( "You entered an even number %d\n", number );
}
}
OUTPUT:

Enter an even number: 10
You entered an even number 10

Enter an even number: 25
Exception in thread "main" java.lang.AssertionError: Not an even number: 25
at AssertTest.main(AssertTest.java:15)

The above code prompts the user to enter an even number, then this number is read from command prompt. The assert statement then determines whether the user entered an even or odd number. If the user entered an odd number (as in second case of output), then the program throws an error. Otherwise, the program proceeds normally. Any line that executes after the assert statement can safely assume that number is not odd

One obvious question that may arise is when exceptions can do the [http://en.wikipedia.org/wiki/Exception_handling error handling] why we need another level of checking. Java exceptions are primarily used to handle unusual conditions arising during program execution. Assertions are not to replace exceptions but to augment them. Assertions are used to specify conditions that a programmer assumes are true. When programming, if a programmer can swear that the value being passed into a particular method is positive no matter what a calling client passes, it can be documented using an assertion to state it. Exceptions handle abnormal conditions arising in the course of the program; however they do not guarantee smooth or correct execution of the program. Assertions help state scenarios that ensure the program is running smoothly. Assertions can be efficient tools to ensure correct execution of a program. They improve the confidence about the program.

== '''Types of Assertions''' ==
* Preconditions - These are assertions about a program’s state when a method is invoked. Precondition refers to the parameters passed to a method in a program. Precondition asserts check the validity of parameters passed before they get used in the body of the method.
* Postconditions - These are assertions about a program’s state after a method finishes execution. Postcondition should be evaluated before the exit point in a method. Postcondition asserts can be used to check for the validity of the return values in a method that has multiple return statements.

One situation where use of assertions is helpful in Java programming language is : Internal Invariants [1]. Assertions can be used within programs to make sure the program behaves in a predetermined manner and will throw an error when violated. For instance, an assertion can be placed in the code below to declare that age will never be negative.

if (age > 0)
{
age = age + 1;
}
else
{
assert age >0:"Age cannot be negative"
}

== '''Enabling and Disabling Assertions'''==

At runtime assertions are disabled by default as they reduce performance. To enable assertions at [http://en.wikipedia.org/wiki/Run_time_(computing) runtime], use the -ea command-line option. To disable assertions, use –da command line option. To execute a code with assertions enabled use
java -ea AssertTest

The assertion status of a class (enabled or disabled) is set at the time it is initialized, and does not change. There is, however, one corner case that demands special treatment. It is possible, though generally not desirable, to execute methods or constructors prior to initialization. This can happen when a class hierarchy contains circularity in its static initialization. If an assert statement executes before its class is initialized, the execution must behave as if assertions were enabled in the class.

== '''xUnit Frameworks that support testing in Java''' ===

Some of the xUnit frameworks that support testing Java code are JUnit , SpryTest , Jtest , TestNG and JExample. Other testing frameworks supported by Java can be looked up at [9]

= '''Support for Assertions in Ruby''' =

[http://en.wikipedia.org/wiki/Unit_testing Unit testing] is a process where individual parts of [http://en.wikipedia.org/wiki/Source_code source code] are isolated and tested separately to determine if they are bug free. The idea behind unit testing is that you write a test method that makes certain assertions about your code, working against a test fixture. [http://en.wikipedia.org/wiki/Ruby_(programming_language) Ruby language] supports a module called Test::Unit::Assertions in test/unit/assertions.rb. Test::Unit::Assertions contains the standard Test::Unit assertions. Assertions is includedin Test::Unit::TestCase.

=='''Public class assert methods'''==

*assert( boolean, [msg] )- This ensures that the object/expression is true
assert [10, 20].include?(50)

*assert_block(message="assert_block failed.") {|| ...} - If the block yields to true , then the assert passes
Example [3]:
def assert_block(message="assert_block failed.") # :yields:
_wrap_assertion do
if (! yield)
raise AssertionFailedError.new(message.to_s)
end
end
end

* assert_match( regexp, string, [msg] )- Ensures that a string matches the regular expression

Example [3]:
def assert_match(pattern, string, message="")
_wrap_assertion do
pattern = case(pattern)
when String
Regexp.new(Regexp.escape(pattern))
else
pattern
end
full_message = build_message(message, "<?> expected to be =~\n<?>.", string, pattern)
assert_block(full_message) { string =~ pattern }
end
end

*assert_not_equal(expected, actual, message="") - If expected != actual, then the assert passes

Example [3]:
def assert_not_equal(expected, actual, message="")
full_message = build_message(message, "<?> expected to be != to\n<?>.", expected, actual)
assert_block(full_message) { expected != actual }
end

*assert_nil(object, message="") - This assert passes if the object is nil.

Example[3]:

# File test/unit/assertions.rb, line 173
def assert_nil(object, message="")
assert_equal(nil, object, message)
end

There are a bunch of other public class methods. This can be obtained from [4]

== '''xUnit Frameworks that support testing in Ruby''' ===

The only xUnit framework that support testing Ruby code is Test::Unit. Other testing frameworks that support Ruby but that do not fall under the xUnit umbrella are RSpec , Shoulda , microtest and Bacon.

=='''Test Method & Test Fixture'''==

Assertions must be used inside test methods within test fixtures. Related tests are grouped inside a common test class using assert. The advantage of having a separate class for all related tests is that it keeps the actual developed code to be tested uncluttered from the test code, hence making maintainability easier. It also allows these test code to be deleted from the development code before the final delivery as these test codes are needed mainly for the developer/tester and need not be part of the final product. Main advantage is it allows you to set up a common test fixture for your tests to run against. Test fixtures are a way of organizing test data; they reside in the fixtures folder. The test_helper.rb file holds the default configuration for your tests.

=='''Ruby on Rails'''==

[http://en.wikipedia.org/wiki/Ruby_on_Rails Rails] is an open source web framework for Ruby language. Rails adds some custom assertions of its own to the test/unit framework some of which are as stated below:

*assert_difference(expressions, difference = 1, message = nil) {...}
Test numeric difference between the return value of an expression as a result of what is evaluated in the yielded block.
*assert_recognizes(expected_options, path, extras={}, message=nil)
Asserts that the routing of the given path was handled correctly and that the parsed options (given in the expected_options hash) match path.
Basically, it asserts that Rails recognizes the route given by expected_options.
*assert_template(expected = nil, message=nil)
Asserts that the request was rendered with the appropriate template file.

= '''Support for Assertions in Python''' =
In [http://www.python.org/ Python] when the [http://docs.python.org/reference/simple_stmts.html#the-assert-statement assert] statement is encountered, the expression following the assert keyword is evaluated and the AssertionError exception is raised if the expression evaluates to false.

== Simple Assert ==

The following code would raise the [http://docs.python.org/library/exceptions.html#exceptions.AssertionError AssertionError] exception.

* assert condition

Example [1]:
#!/usr/bin/python
assert 1 == 2

== Extended Assert ==

In addition to evaluating an expression , arguments can be passed to the assertion so that for example, the right message can be displayed based on the outcome of the assertion.

* assert Expression[, Arguments]

Example [2];
#!/usr/bin/python
def IsSenior(age):
assert (age >= 1),"Age cannot be zero or less than zero !"
return (age >= 65)
print IsSenior(15)
print IsSenior(70)
print IsSenior(-1)

Example [2] Output;
false
true
Traceback (most recent call last):
File "test.py", line 9, in <module>
print IsSenior(-5)
File "test.py", line 4, in IsSenior
assert (age >= 1),"Age cannot be zero or less than zero !"
AssertionError: Age cannot be zero or less than zero !

== '''xUnit Frameworks that support testing in Python''' ===

Some of the xUnit frameworks that support testing python code are PyUnit, Nose, py.test and TwistedTrial. Other testing frameworks supported by python can be looked up at [9]

One common used of assertions in python is for type checking. Please refer the article [http://pg-server.csc.ncsu.edu/mediawiki/index.php/CSC/ECE_517_Fall_2007/wiki3_1_sa#Python Assertion in O-O languages] for more details.

One of the key feature of assertions in Python is that if python is started with -O option, then the assertions would not be evaluated. The scenario where this feature would apply is developers can write a lot of assertions for debugging and when the code is to be executed in production , if it is started with -O option , then all the assertions written by the developers for debugging would not be evaluated.

In general assertions are not the best means to test for failure cases. Instead of using an assertion exceptions would be the right way to handle scenarios like wrong user input or system/environment failures.

= '''Benefits of assertions''' =
*Use of assertions in the program help detect errors immediately and directly, rather than at a later stage. Assertion failure usually reports the location of failure in the code which helps in pin-pointing the error without further debugging.
*Assertions provide run time check for assumptions made by developers
*Assertions are also sometimes placed at points the execution is not supposed to reach. For example, assertions could be placed at the default clause of the switch statement in languages such as C++, and Java. Any case which the programmer does not handle intentionally will raise an error and the program will abort rather than silently continuing in an erroneous state.
*Assertions can be viewed as "dynamic documentation", since they are checked at runtime, contrary to the traditional approach of documenting assumptions via plain /* comments */.

*Assert statements are great for helping you torefactor and optimize your code with greater confidence that you have preserved correctness

= '''Limitations of assertions''' =

*Assertions rarely allow for graceful error recovery. They terminate the program abruptly and may not release some of the resources used by the program; hence it is considered bad practice to rely upon assertions for handling expected error conditions.
* Assertions sometime hinder execution time. For example, if the program has an assert that checks to see if the number to be returned is the smallest in the array, then the assertion will have to do the same amount of work that the method would have to do.

= '''Conclusion''' =

When writing program, it is a good practice to check for violations of basic assumptions in the code. These checks help in debugging code. The assertion facility in J2SE 1.4 (and later versions) provides a unified support for assertions in Java technology as well as a convenient way for developers both to turn assertions on and off as needed. Assertions are used in Test Driven Development(TDD) in Ruby programing language. The Test::Unit library in Ruby has a variety of built in assertions that makes writing tests much easier.

Although the use of assertions replaces the ad hoc use of conditional tests with a uniform methodology, it does not allow for a repair strategy to continue program execution. This means that when an exception is detected, the program aborts with no recovery mechanism. Nevertheless, assertions play an important role in debugging and designing code with testability in mind. The assertion facility can be used to support an informal design-by-contract style of programming.

= '''Reference''' =

[http://download.oracle.com/javase/1.4.2/docs/guide/lang/assert.html] Programming with Assertions

[http://www.deitel.com/articles/java_tutorials/20060106/Assertions.html] Assertions in java

[http://ruby-doc.org/stdlib/libdoc/test/unit/rdoc/classes/Test/Unit/Assertions.html#M004514] Assertions in Ruby

[http://guides.rubyonrails.org/testing.html#assertions-available] Ruby assertions

[http://topfunky.com/clients/rails/ruby_and_rails_assertions.pdf] Ruby on Rails assertion cheat sheet

[http://www.cs.clemson.edu/~malloy/papers/prospectus/prospectus.pdf] More about assertions

[http://docs.python.org/reference/simple_stmts.html] Python simple statements documentation

[http://www.tutorialspoint.com/python/assertions_in_python.htm] Assertions in Python

[http://en.wikipedia.org/wiki/List_of_unit_testing_frameworks] Testing frameworks for programming languages

[http://en.wikipedia.org/wiki/XUnit] xUnit

Zz

2010-11-16T04:34:39Z

Kschidam:

'''Support for Assertions in Various O-O Programming Languages'''

= '''Introduction''' =

In computer language an [http://en.wikipedia.org/wiki/Assertion_(computing) assertion] is a construct that immediately terminates the execution of a program if a certain expression or a condition is evaluated to false (assertion failure). It is mainly used for code [http://en.wikipedia.org/wiki/Debugging debugging] . Programmers use assertions to check for potential errors or bugs in the application being developed. The main feature of assertions is to verify the validity of the assumptions made by chunk of code during execution. A good example to illustrate this is the use of [http://en.wikipedia.org/wiki/Dynamic_memory_allocation dynamic memory allocation] in C++, wherein we can use an assertion to check a [http://en.wikipedia.org/wiki/Pointer_(computing) pointer] and ensure that it is not null before using this pointer. If this check in not made, a reference may occur later that would cause an error. Assertions play a vital role in developing reliable object-oriented software. An early advocate of using assertions in programming was Alan Turing [5]. Assertions serve to make explicit the assumptions on which programmers rely when they write software elements that they believe are correct. Assertion-based Object-Oriented techniques produce reliable software and enable software components to be reused safely. In languages such as Eiffel, assertions form part of the design process, and in others, such as C and Java, they are used only to check assumptions at runtime. Various object oriented programming languages support assertions.

= '''Support for Assertions in java''' =

When implementing and debugging a class in java programming language, it is a good practice to specify conditions that should be true at a particular stage in a method. These conditions, called assertions, guarantee a program’s validity by catching potential bugs and identifying possible logic errors during development. For example, if you write a module that calculates the temperature of an element, you might assert that the calculated temperature is not less than 0 degree Kelvin. The syntax for assert statements are as follows [1]:

assert Expression1;

Expression1 is a [http://en.wikipedia.org/wiki/Boolean_expression Boolean expression]. If Expression1 is evaluated to be false, then the system throws an AssertionError. This syntax for assert will not give a detail error message. Therefore second form of assert syntax can be used [1] as given below
assert Expression1: Expression2;

Expression1 is a Boolean expression. Expression2 is an expression that has a value. This version of the assert statement provides detail message for the AssertionError. The system passes the value of Expression2 to the appropriate AssertionError constructor, which uses the string representation of the value as the error's detail message. This form of the assertion statement should be used in preference to the first only when the program has some additional information that might help diagnose the failure. Below is an example code that demonstrates the functionality of assert statement. This code checks with assert that the value entered is an even number only [2].

import java.util.Scanner;

public class AssertTest
{
public static void main( String args[] )
{
Scanner input = new Scanner( System.in );

System.out.print( "Enter an even number: " );
int number = input.nextInt();

// assert that the number is even
assert ((number % 2 == 0)) : "Not an even number: " + number;

System.out.printf( "You entered an even number %d\n", number );
}
}
OUTPUT:

Enter an even number: 10
You entered an even number 10

Enter an even number: 25
Exception in thread "main" java.lang.AssertionError: Not an even number: 25
at AssertTest.main(AssertTest.java:15)

The above code prompts the user to enter an even number, then this number is read from command prompt. The assert statement then determines whether the user entered an even or odd number. If the user entered an odd number (as in second case of output), then the program throws an error. Otherwise, the program proceeds normally. Any line that executes after the assert statement can safely assume that number is not odd

One obvious question that may arise is when exceptions can do the [http://en.wikipedia.org/wiki/Exception_handling error handling] why we need another level of checking. Java exceptions are primarily used to handle unusual conditions arising during program execution. Assertions are not to replace exceptions but to augment them. Assertions are used to specify conditions that a programmer assumes are true. When programming, if a programmer can swear that the value being passed into a particular method is positive no matter what a calling client passes, it can be documented using an assertion to state it. Exceptions handle abnormal conditions arising in the course of the program; however they do not guarantee smooth or correct execution of the program. Assertions help state scenarios that ensure the program is running smoothly. Assertions can be efficient tools to ensure correct execution of a program. They improve the confidence about the program.

== '''Types of Assertions''' ==
* Preconditions - These are assertions about a program’s state when a method is invoked. Precondition refers to the parameters passed to a method in a program. Precondition asserts check the validity of parameters passed before they get used in the body of the method.
* Postconditions - These are assertions about a program’s state after a method finishes execution. Postcondition should be evaluated before the exit point in a method. Postcondition asserts can be used to check for the validity of the return values in a method that has multiple return statements.

One situation where use of assertions is helpful in Java programming language is : Internal Invariants [1]. Assertions can be used within programs to make sure the program behaves in a predetermined manner and will throw an error when violated. For instance, an assertion can be placed in the code below to declare that age will never be negative.

if (age > 0)
{
age = age + 1;
}
else
{
assert age >0:"Age cannot be negative"
}

== '''Enabling and Disabling Assertions'''==

At runtime assertions are disabled by default as they reduce performance. To enable assertions at [http://en.wikipedia.org/wiki/Run_time_(computing) runtime], use the -ea command-line option. To disable assertions, use –da command line option. To execute a code with assertions enabled use
java -ea AssertTest

The assertion status of a class (enabled or disabled) is set at the time it is initialized, and does not change. There is, however, one corner case that demands special treatment. It is possible, though generally not desirable, to execute methods or constructors prior to initialization. This can happen when a class hierarchy contains circularity in its static initialization. If an assert statement executes before its class is initialized, the execution must behave as if assertions were enabled in the class.

= '''Support for Assertions in Ruby''' =

[http://en.wikipedia.org/wiki/Unit_testing Unit testing] is a process where individual parts of [http://en.wikipedia.org/wiki/Source_code source code] are isolated and tested separately to determine if they are bug free. The idea behind unit testing is that you write a test method that makes certain assertions about your code, working against a test fixture. [http://en.wikipedia.org/wiki/Ruby_(programming_language) Ruby language] supports a module called Test::Unit::Assertions in test/unit/assertions.rb. Test::Unit::Assertions contains the standard Test::Unit assertions. Assertions is includedin Test::Unit::TestCase.

=='''Public class assert methods'''==

*assert( boolean, [msg] )- This ensures that the object/expression is true
assert [10, 20].include?(50)

*assert_block(message="assert_block failed.") {|| ...} - If the block yields to true , then the assert passes
Example [3]:
def assert_block(message="assert_block failed.") # :yields:
_wrap_assertion do
if (! yield)
raise AssertionFailedError.new(message.to_s)
end
end
end

* assert_match( regexp, string, [msg] )- Ensures that a string matches the regular expression

Example [3]:
def assert_match(pattern, string, message="")
_wrap_assertion do
pattern = case(pattern)
when String
Regexp.new(Regexp.escape(pattern))
else
pattern
end
full_message = build_message(message, "<?> expected to be =~\n<?>.", string, pattern)
assert_block(full_message) { string =~ pattern }
end
end

*assert_not_equal(expected, actual, message="") - If expected != actual, then the assert passes

Example [3]:
def assert_not_equal(expected, actual, message="")
full_message = build_message(message, "<?> expected to be != to\n<?>.", expected, actual)
assert_block(full_message) { expected != actual }
end

*assert_nil(object, message="") - This assert passes if the object is nil.

Example[3]:

# File test/unit/assertions.rb, line 173
def assert_nil(object, message="")
assert_equal(nil, object, message)
end

There are a bunch of other public class methods. This can be obtained from [4]

=='''Test Method & Test Fixture'''==

Assertions must be used inside test methods within test fixtures. Related tests are grouped inside a common test class using assert. The advantage of having a separate class for all related tests is that it keeps the actual developed code to be tested uncluttered from the test code, hence making maintainability easier. It also allows these test code to be deleted from the development code before the final delivery as these test codes are needed mainly for the developer/tester and need not be part of the final product. Main advantage is it allows you to set up a common test fixture for your tests to run against. Test fixtures are a way of organizing test data; they reside in the fixtures folder. The test_helper.rb file holds the default configuration for your tests.

=='''Ruby on Rails'''==

[http://en.wikipedia.org/wiki/Ruby_on_Rails Rails] is an open source web framework for Ruby language. Rails adds some custom assertions of its own to the test/unit framework some of which are as stated below:

*assert_difference(expressions, difference = 1, message = nil) {...}
Test numeric difference between the return value of an expression as a result of what is evaluated in the yielded block.
*assert_recognizes(expected_options, path, extras={}, message=nil)
Asserts that the routing of the given path was handled correctly and that the parsed options (given in the expected_options hash) match path.
Basically, it asserts that Rails recognizes the route given by expected_options.
*assert_template(expected = nil, message=nil)
Asserts that the request was rendered with the appropriate template file.

= '''Support for Assertions in Python''' =
In [http://www.python.org/ Python] when the [http://docs.python.org/reference/simple_stmts.html#the-assert-statement assert] statement is encountered, the expression following the assert keyword is evaluated and the AssertionError exception is raised if the expression evaluates to false.

== Simple Assert ==

The following code would raise the [http://docs.python.org/library/exceptions.html#exceptions.AssertionError AssertionError] exception.

* assert condition

Example [1]:
#!/usr/bin/python
assert 1 == 2

== Extended Assert ==

In addition to evaluating an expression , arguments can be passed to the assertion so that for example, the right message can be displayed based on the outcome of the assertion.

* assert Expression[, Arguments]

Example [2];
#!/usr/bin/python
def IsSenior(age):
assert (age >= 1),"Age cannot be zero or less than zero !"
return (age >= 65)
print IsSenior(15)
print IsSenior(70)
print IsSenior(-1)

Example [2] Output;
false
true
Traceback (most recent call last):
File "test.py", line 9, in <module>
print IsSenior(-5)
File "test.py", line 4, in IsSenior
assert (age >= 1),"Age cannot be zero or less than zero !"
AssertionError: Age cannot be zero or less than zero !

One common used of assertions in python is for type checking. Please refer the article [http://pg-server.csc.ncsu.edu/mediawiki/index.php/CSC/ECE_517_Fall_2007/wiki3_1_sa#Python Assertion in O-O languages] for more details.

One of the key feature of assertions in Python is that if python is started with -O option, then the assertions would not be evaluated. The scenario where this feature would apply is developers can write a lot of assertions for debugging and when the code is to be executed in production , if it is started with -O option , then all the assertions written by the developers for debugging would not be evaluated.

In general assertions are not the best means to test for failure cases. Instead of using an assertion exceptions would be the right way to handle scenarios like wrong user input or system/environment failures.

= '''Benefits of assertions''' =
*Use of assertions in the program help detect errors immediately and directly, rather than at a later stage. Assertion failure usually reports the location of failure in the code which helps in pin-pointing the error without further debugging.
*Assertions provide run time check for assumptions made by developers
*Assertions are also sometimes placed at points the execution is not supposed to reach. For example, assertions could be placed at the default clause of the switch statement in languages such as C++, and Java. Any case which the programmer does not handle intentionally will raise an error and the program will abort rather than silently continuing in an erroneous state.
*Assertions can be viewed as "dynamic documentation", since they are checked at runtime, contrary to the traditional approach of documenting assumptions via plain /* comments */.

*Assert statements are great for helping you torefactor and optimize your code with greater confidence that you have preserved correctness

= '''Limitations of assertions''' =

*Assertions rarely allow for graceful error recovery. They terminate the program abruptly and may not release some of the resources used by the program; hence it is considered bad practice to rely upon assertions for handling expected error conditions.
* Assertions sometime hinder execution time. For example, if the program has an assert that checks to see if the number to be returned is the smallest in the array, then the assertion will have to do the same amount of work that the method would have to do.

= '''Conclusion''' =

When writing program, it is a good practice to check for violations of basic assumptions in the code. These checks help in debugging code. The assertion facility in J2SE 1.4 (and later versions) provides a unified support for assertions in Java technology as well as a convenient way for developers both to turn assertions on and off as needed. Assertions are used in Test Driven Development(TDD) in Ruby programing language. The Test::Unit library in Ruby has a variety of built in assertions that makes writing tests much easier.

Although the use of assertions replaces the ad hoc use of conditional tests with a uniform methodology, it does not allow for a repair strategy to continue program execution. This means that when an exception is detected, the program aborts with no recovery mechanism. Nevertheless, assertions play an important role in debugging and designing code with testability in mind. The assertion facility can be used to support an informal design-by-contract style of programming.

= '''Reference''' =

[http://download.oracle.com/javase/1.4.2/docs/guide/lang/assert.html] Programming with Assertions

[http://www.deitel.com/articles/java_tutorials/20060106/Assertions.html] Assertions in java

[http://ruby-doc.org/stdlib/libdoc/test/unit/rdoc/classes/Test/Unit/Assertions.html#M004514] Assertions in Ruby

[http://guides.rubyonrails.org/testing.html#assertions-available] Ruby assertions

[http://topfunky.com/clients/rails/ruby_and_rails_assertions.pdf] Ruby on Rails assertion cheat sheet

[http://www.cs.clemson.edu/~malloy/papers/prospectus/prospectus.pdf] More about assertions

[http://docs.python.org/reference/simple_stmts.html] Python simple statements documentation

[http://www.tutorialspoint.com/python/assertions_in_python.htm] Assertions in Python

Zz

2010-11-16T04:18:40Z

Kschidam:

'''Support for Assertions in Various O-O Programming Languages'''

= '''Introduction''' =

In computer language an [http://en.wikipedia.org/wiki/Assertion_(computing) assertion] is a construct that immediately terminates the execution of a program if a certain expression or a condition is evaluated to false (assertion failure). It is mainly used for code [http://en.wikipedia.org/wiki/Debugging debugging] . Programmers use assertions to check for potential errors or bugs in the application being developed. The main feature of assertions is to verify the validity of the assumptions made by chunk of code during execution. A good example to illustrate this is the use of [http://en.wikipedia.org/wiki/Dynamic_memory_allocation dynamic memory allocation] in C++, wherein we can use an assertion to check a [http://en.wikipedia.org/wiki/Pointer_(computing) pointer] and ensure that it is not null before using this pointer. If this check in not made, a reference may occur later that would cause an error. Assertions play a vital role in developing reliable object-oriented software. An early advocate of using assertions in programming was Alan Turing [5]. Assertions serve to make explicit the assumptions on which programmers rely when they write software elements that they believe are correct. Assertion-based Object-Oriented techniques produce reliable software and enable software components to be reused safely. In languages such as Eiffel, assertions form part of the design process, and in others, such as C and Java, they are used only to check assumptions at runtime. Various object oriented programming languages support assertions.

= '''Support for Assertions in java''' =

When implementing and debugging a class in java programming language, it is a good practice to specify conditions that should be true at a particular stage in a method. These conditions, called assertions, guarantee a program’s validity by catching potential bugs and identifying possible logic errors during development. For example, if you write a module that calculates the temperature of an element, you might assert that the calculated temperature is not less than 0 degree Kelvin. The syntax for assert statements are as follows [1]:

assert Expression1;

Expression1 is a [http://en.wikipedia.org/wiki/Boolean_expression Boolean expression]. If Expression1 is evaluated to be false, then the system throws an AssertionError. This syntax for assert will not give a detail error message. Therefore second form of assert syntax can be used [1] as given below
assert Expression1: Expression2;

Expression1 is a Boolean expression. Expression2 is an expression that has a value. This version of the assert statement provides detail message for the AssertionError. The system passes the value of Expression2 to the appropriate AssertionError constructor, which uses the string representation of the value as the error's detail message. This form of the assertion statement should be used in preference to the first only when the program has some additional information that might help diagnose the failure. Below is an example code that demonstrates the functionality of assert statement. This code checks with assert that the value entered is an even number only [2].

import java.util.Scanner;

public class AssertTest
{
public static void main( String args[] )
{
Scanner input = new Scanner( System.in );

System.out.print( "Enter an even number: " );
int number = input.nextInt();

// assert that the number is even
assert ((number % 2 == 0)) : "Not an even number: " + number;

System.out.printf( "You entered an even number %d\n", number );
}
}
OUTPUT:

Enter an even number: 10
You entered an even number 10

Enter an even number: 25
Exception in thread "main" java.lang.AssertionError: Not an even number: 25
at AssertTest.main(AssertTest.java:15)

The above code prompts the user to enter an even number, then this number is read from command prompt. The assert statement then determines whether the user entered an even or odd number. If the user entered an odd number (as in second case of output), then the program throws an error. Otherwise, the program proceeds normally. Any line that executes after the assert statement can safely assume that number is not odd

One obvious question that may arise is when exceptions can do the [http://en.wikipedia.org/wiki/Exception_handling error handling] why we need another level of checking. Java exceptions are primarily used to handle unusual conditions arising during program execution. Assertions are not to replace exceptions but to augment them. Assertions are used to specify conditions that a programmer assumes are true. When programming, if a programmer can swear that the value being passed into a particular method is positive no matter what a calling client passes, it can be documented using an assertion to state it. Exceptions handle abnormal conditions arising in the course of the program; however they do not guarantee smooth or correct execution of the program. Assertions help state scenarios that ensure the program is running smoothly. Assertions can be efficient tools to ensure correct execution of a program. They improve the confidence about the program.

== '''Types of Assertions''' ==
* Preconditions - These are assertions about a program’s state when a method is invoked. Precondition refers to the parameters passed to a method in a program. Precondition asserts check the validity of parameters passed before they get used in the body of the method.
* Postconditions - These are assertions about a program’s state after a method finishes execution. Postcondition should be evaluated before the exit point in a method. Postcondition asserts can be used to check for the validity of the return values in a method that has multiple return statements.

One situation where use of assertions is helpful in Java programming language is : Internal Invariants [1]. Assertions can be used within programs to make sure the program behaves in a predetermined manner and will throw an error when violated. For instance, an assertion can be placed in the code below to declare that age will never be negative.

if (age > 0)
{
age = age + 1;
}
else
{
assert age >0:"Age cannot be negative"
}

== '''Enabling and Disabling Assertions'''==

At runtime assertions are disabled by default as they reduce performance. To enable assertions at [http://en.wikipedia.org/wiki/Run_time_(computing) runtime], use the -ea command-line option. To disable assertions, use –da command line option. To execute a code with assertions enabled use
java -ea AssertTest

The assertion status of a class (enabled or disabled) is set at the time it is initialized, and does not change. There is, however, one corner case that demands special treatment. It is possible, though generally not desirable, to execute methods or constructors prior to initialization. This can happen when a class hierarchy contains circularity in its static initialization. If an assert statement executes before its class is initialized, the execution must behave as if assertions were enabled in the class.

= '''Support for Assertions in Ruby''' =

[http://en.wikipedia.org/wiki/Unit_testing Unit testing] is a process where individual parts of [http://en.wikipedia.org/wiki/Source_code source code] are isolated and tested separately to determine if they are bug free. The idea behind unit testing is that you write a test method that makes certain assertions about your code, working against a test fixture. [http://en.wikipedia.org/wiki/Ruby_(programming_language) Ruby language] supports a module called Test::Unit::Assertions in test/unit/assertions.rb. Test::Unit::Assertions contains the standard Test::Unit assertions. Assertions is includedin Test::Unit::TestCase.

=='''Public class assert methods'''==

*assert( boolean, [msg] )- This ensures that the object/expression is true
assert [10, 20].include?(50)

*assert_block(message="assert_block failed.") {|| ...} - If the block yields to true , then the assert passes
Example [3]:
def assert_block(message="assert_block failed.") # :yields:
_wrap_assertion do
if (! yield)
raise AssertionFailedError.new(message.to_s)
end
end
end

* assert_match( regexp, string, [msg] )- Ensures that a string matches the regular expression

Example [3]:
def assert_match(pattern, string, message="")
_wrap_assertion do
pattern = case(pattern)
when String
Regexp.new(Regexp.escape(pattern))
else
pattern
end
full_message = build_message(message, "<?> expected to be =~\n<?>.", string, pattern)
assert_block(full_message) { string =~ pattern }
end
end

*assert_not_equal(expected, actual, message="") - If expected != actual, then the assert passes

Example [3]:
def assert_not_equal(expected, actual, message="")
full_message = build_message(message, "<?> expected to be != to\n<?>.", expected, actual)
assert_block(full_message) { expected != actual }
end

*assert_nil(object, message="") - This assert passes if the object is nil.

Example[3]:

# File test/unit/assertions.rb, line 173
def assert_nil(object, message="")
assert_equal(nil, object, message)
end

There are a bunch of other public class methods. This can be obtained from [4]

=='''Test Method & Test Fixture'''==

Assertions must be used inside test methods within test fixtures. Related tests are grouped inside a common test class using assert. The advantage of having a separate class for all related tests is that it keeps the actual developed code to be tested uncluttered from the test code, hence making maintainability easier. It also allows these test code to be deleted from the development code before the final delivery as these test codes are needed mainly for the developer/tester and need not be part of the final product. Main advantage is it allows you to set up a common test fixture for your tests to run against. Test fixtures are a way of organizing test data; they reside in the fixtures folder. The test_helper.rb file holds the default configuration for your tests.

=='''Ruby on Rails'''==

[http://en.wikipedia.org/wiki/Ruby_on_Rails Rails] is an open source web framework for Ruby language. Rails adds some custom assertions of its own to the test/unit framework some of which are as stated below:

*assert_difference(expressions, difference = 1, message = nil) {...}
Test numeric difference between the return value of an expression as a result of what is evaluated in the yielded block.
*assert_recognizes(expected_options, path, extras={}, message=nil)
Asserts that the routing of the given path was handled correctly and that the parsed options (given in the expected_options hash) match path.
Basically, it asserts that Rails recognizes the route given by expected_options.
*assert_template(expected = nil, message=nil)
Asserts that the request was rendered with the appropriate template file.

= '''Support for Assertions in Python''' =
In [http://www.python.org/ Python] when the [http://docs.python.org/reference/simple_stmts.html#the-assert-statement assert] statement is encountered, the expression following the assert keyword is evaluated and the AssertionError exception is raised if the expression evaluates to false.

For example, the following code would raise the [http://docs.python.org/library/exceptions.html#exceptions.AssertionError AssertionError] exception.

'''Syntax: assert condition'''

Example [1]:
#!/usr/bin/python
assert 1 == 2

In addition to evaluating an expression , arguments can be passed to the assertion so that for example, the right message can be displayed based on the outcome of the assertion.

'''Syntax: assert Expression[, Arguments]'''

Example [2];
#!/usr/bin/python
def IsSenior(age):
assert (age >= 1),"Age cannot be zero or less than zero !"
return (age >= 65)
print IsSenior(15)
print IsSenior(70)
print IsSenior(-1)

Example [2] Output;
false
true
Traceback (most recent call last):
File "test.py", line 9, in <module>
print IsSenior(-5)
File "test.py", line 4, in IsSenior
assert (age >= 1),"Age cannot be zero or less than zero !"
AssertionError: Age cannot be zero or less than zero !

One common used of assertions in python is for type checking. Please refer the article [http://pg-server.csc.ncsu.edu/mediawiki/index.php/CSC/ECE_517_Fall_2007/wiki3_1_sa#Python Assertion in O-O languages] for more details.

One of the key feature of assertions in Python is that if python is started with -O option, then the assertions would not be evaluated. The scenario where this feature would apply is developers can write a lot of assertions for debugging and when the code is to be executed in production , if it is started with -O option , then all the assertions written by the developers for debugging would not be evaluated.

In general assertions are not the best means to test for failure cases. Instead of using an assertion exceptions would be the right way to handle scenarios like wrong user input or system/environment failures.

= '''Benefits of assertions''' =
*Use of assertions in the program help detect errors immediately and directly, rather than at a later stage. Assertion failure usually reports the location of failure in the code which helps in pin-pointing the error without further debugging.
*Assertions provide run time check for assumptions made by developers
*Assertions are also sometimes placed at points the execution is not supposed to reach. For example, assertions could be placed at the default clause of the switch statement in languages such as C++, and Java. Any case which the programmer does not handle intentionally will raise an error and the program will abort rather than silently continuing in an erroneous state.
*Assertions can be viewed as "dynamic documentation", since they are checked at runtime, contrary to the traditional approach of documenting assumptions via plain /* comments */.

*Assert statements are great for helping you torefactor and optimize your code with greater confidence that you have preserved correctness

= '''Limitations of assertions''' =

*Assertions rarely allow for graceful error recovery. They terminate the program abruptly and may not release some of the resources used by the program; hence it is considered bad practice to rely upon assertions for handling expected error conditions.
* Assertions sometime hinder execution time. For example, if the program has an assert that checks to see if the number to be returned is the smallest in the array, then the assertion will have to do the same amount of work that the method would have to do.

= '''Conclusion''' =

When writing program, it is a good practice to check for violations of basic assumptions in the code. These checks help in debugging code. The assertion facility in J2SE 1.4 (and later versions) provides a unified support for assertions in Java technology as well as a convenient way for developers both to turn assertions on and off as needed. Assertions are used in Test Driven Development(TDD) in Ruby programing language. The Test::Unit library in Ruby has a variety of built in assertions that makes writing tests much easier.

Although the use of assertions replaces the ad hoc use of conditional tests with a uniform methodology, it does not allow for a repair strategy to continue program execution. This means that when an exception is detected, the program aborts with no recovery mechanism. Nevertheless, assertions play an important role in debugging and designing code with testability in mind. The assertion facility can be used to support an informal design-by-contract style of programming.

= '''Reference''' =

[http://download.oracle.com/javase/1.4.2/docs/guide/lang/assert.html] Programming with Assertions

[http://www.deitel.com/articles/java_tutorials/20060106/Assertions.html] Assertions in java

[http://ruby-doc.org/stdlib/libdoc/test/unit/rdoc/classes/Test/Unit/Assertions.html#M004514] Assertions in Ruby

[http://guides.rubyonrails.org/testing.html#assertions-available] Ruby assertions

[http://topfunky.com/clients/rails/ruby_and_rails_assertions.pdf] Ruby on Rails assertion cheat sheet

[http://www.cs.clemson.edu/~malloy/papers/prospectus/prospectus.pdf] More about assertions

[http://docs.python.org/reference/simple_stmts.html] Python simple statements documentation

[http://www.tutorialspoint.com/python/assertions_in_python.htm] Assertions in Python

Zz

2010-11-16T04:18:06Z

Kschidam:

'''Support for Assertions in Various O-O Programming Languages'''

= '''Introduction''' =

In computer language an [http://en.wikipedia.org/wiki/Assertion_(computing) assertion] is a construct that immediately terminates the execution of a program if a certain expression or a condition is evaluated to false (assertion failure). It is mainly used for code [http://en.wikipedia.org/wiki/Debugging debugging] . Programmers use assertions to check for potential errors or bugs in the application being developed. The main feature of assertions is to verify the validity of the assumptions made by chunk of code during execution. A good example to illustrate this is the use of [http://en.wikipedia.org/wiki/Dynamic_memory_allocation dynamic memory allocation] in C++, wherein we can use an assertion to check a [http://en.wikipedia.org/wiki/Pointer_(computing) pointer] and ensure that it is not null before using this pointer. If this check in not made, a reference may occur later that would cause an error. Assertions play a vital role in developing reliable object-oriented software. An early advocate of using assertions in programming was Alan Turing [5]. Assertions serve to make explicit the assumptions on which programmers rely when they write software elements that they believe are correct. Assertion-based Object-Oriented techniques produce reliable software and enable software components to be reused safely. In languages such as Eiffel, assertions form part of the design process, and in others, such as C and Java, they are used only to check assumptions at runtime. Various object oriented programming languages support assertions.

= '''Support for Assertions in java''' =

When implementing and debugging a class in java programming language, it is a good practice to specify conditions that should be true at a particular stage in a method. These conditions, called assertions, guarantee a program’s validity by catching potential bugs and identifying possible logic errors during development. For example, if you write a module that calculates the temperature of an element, you might assert that the calculated temperature is not less than 0 degree Kelvin. The syntax for assert statements are as follows [1]:

assert Expression1;

Expression1 is a [http://en.wikipedia.org/wiki/Boolean_expression Boolean expression]. If Expression1 is evaluated to be false, then the system throws an AssertionError. This syntax for assert will not give a detail error message. Therefore second form of assert syntax can be used [1] as given below
assert Expression1: Expression2;

Expression1 is a Boolean expression. Expression2 is an expression that has a value. This version of the assert statement provides detail message for the AssertionError. The system passes the value of Expression2 to the appropriate AssertionError constructor, which uses the string representation of the value as the error's detail message. This form of the assertion statement should be used in preference to the first only when the program has some additional information that might help diagnose the failure. Below is an example code that demonstrates the functionality of assert statement. This code checks with assert that the value entered is an even number only [2].

import java.util.Scanner;

public class AssertTest
{
public static void main( String args[] )
{
Scanner input = new Scanner( System.in );

System.out.print( "Enter an even number: " );
int number = input.nextInt();

// assert that the number is even
assert ((number % 2 == 0)) : "Not an even number: " + number;

System.out.printf( "You entered an even number %d\n", number );
}
}
OUTPUT:

Enter an even number: 10
You entered an even number 10

Enter an even number: 25
Exception in thread "main" java.lang.AssertionError: Not an even number: 25
at AssertTest.main(AssertTest.java:15)

The above code prompts the user to enter an even number, then this number is read from command prompt. The assert statement then determines whether the user entered an even or odd number. If the user entered an odd number (as in second case of output), then the program throws an error. Otherwise, the program proceeds normally. Any line that executes after the assert statement can safely assume that number is not odd

One obvious question that may arise is when exceptions can do the [http://en.wikipedia.org/wiki/Exception_handling error handling] why we need another level of checking. Java exceptions are primarily used to handle unusual conditions arising during program execution. Assertions are not to replace exceptions but to augment them. Assertions are used to specify conditions that a programmer assumes are true. When programming, if a programmer can swear that the value being passed into a particular method is positive no matter what a calling client passes, it can be documented using an assertion to state it. Exceptions handle abnormal conditions arising in the course of the program; however they do not guarantee smooth or correct execution of the program. Assertions help state scenarios that ensure the program is running smoothly. Assertions can be efficient tools to ensure correct execution of a program. They improve the confidence about the program.

== '''Types of Assertions''' ==
* Preconditions - These are assertions about a program’s state when a method is invoked. Precondition refers to the parameters passed to a method in a program. Precondition asserts check the validity of parameters passed before they get used in the body of the method.
* Postconditions - These are assertions about a program’s state after a method finishes execution. Postcondition should be evaluated before the exit point in a method. Postcondition asserts can be used to check for the validity of the return values in a method that has multiple return statements.

One situation where use of assertions is helpful in Java programming language is : Internal Invariants [1]. Assertions can be used within programs to make sure the program behaves in a predetermined manner and will throw an error when violated. For instance, an assertion can be placed in the code below to declare that age will never be negative.

if (age > 0)
{
age = age + 1;
}
else
{
assert age >0:"Age cannot be negative"
}

== '''Enabling and Disabling Assertions'''==

At runtime assertions are disabled by default as they reduce performance. To enable assertions at [http://en.wikipedia.org/wiki/Run_time_(computing) runtime], use the -ea command-line option. To disable assertions, use –da command line option. To execute a code with assertions enabled use
java -ea AssertTest

The assertion status of a class (enabled or disabled) is set at the time it is initialized, and does not change. There is, however, one corner case that demands special treatment. It is possible, though generally not desirable, to execute methods or constructors prior to initialization. This can happen when a class hierarchy contains circularity in its static initialization. If an assert statement executes before its class is initialized, the execution must behave as if assertions were enabled in the class.

= '''Support for Assertions in Ruby''' =

[http://en.wikipedia.org/wiki/Unit_testing Unit testing] is a process where individual parts of [http://en.wikipedia.org/wiki/Source_code source code] are isolated and tested separately to determine if they are bug free. The idea behind unit testing is that you write a test method that makes certain assertions about your code, working against a test fixture. [http://en.wikipedia.org/wiki/Ruby_(programming_language) Ruby language] supports a module called Test::Unit::Assertions in test/unit/assertions.rb. Test::Unit::Assertions contains the standard Test::Unit assertions. Assertions is includedin Test::Unit::TestCase.

=='''Public class assert methods'''==

*assert( boolean, [msg] )- This ensures that the object/expression is true
assert [10, 20].include?(50)

*assert_block(message="assert_block failed.") {|| ...} - If the block yields to true , then the assert passes
Example [3]:
def assert_block(message="assert_block failed.") # :yields:
_wrap_assertion do
if (! yield)
raise AssertionFailedError.new(message.to_s)
end
end
end

* assert_match( regexp, string, [msg] )- Ensures that a string matches the regular expression

Example [3]:
def assert_match(pattern, string, message="")
_wrap_assertion do
pattern = case(pattern)
when String
Regexp.new(Regexp.escape(pattern))
else
pattern
end
full_message = build_message(message, "<?> expected to be =~\n<?>.", string, pattern)
assert_block(full_message) { string =~ pattern }
end
end

*assert_not_equal(expected, actual, message="") - If expected != actual, then the assert passes

Example [3]:
def assert_not_equal(expected, actual, message="")
full_message = build_message(message, "<?> expected to be != to\n<?>.", expected, actual)
assert_block(full_message) { expected != actual }
end

*assert_nil(object, message="") - This assert passes if the object is nil.

Example[3]:

# File test/unit/assertions.rb, line 173
def assert_nil(object, message="")
assert_equal(nil, object, message)
end

There are a bunch of other public class methods. This can be obtained from [4]

=='''Test Method & Test Fixture'''==

Assertions must be used inside test methods within test fixtures. Related tests are grouped inside a common test class using assert. The advantage of having a separate class for all related tests is that it keeps the actual developed code to be tested uncluttered from the test code, hence making maintainability easier. It also allows these test code to be deleted from the development code before the final delivery as these test codes are needed mainly for the developer/tester and need not be part of the final product. Main advantage is it allows you to set up a common test fixture for your tests to run against. Test fixtures are a way of organizing test data; they reside in the fixtures folder. The test_helper.rb file holds the default configuration for your tests.

=='''Ruby on Rails'''==

[http://en.wikipedia.org/wiki/Ruby_on_Rails Rails] is an open source web framework for Ruby language. Rails adds some custom assertions of its own to the test/unit framework some of which are as stated below:

*assert_difference(expressions, difference = 1, message = nil) {...}
Test numeric difference between the return value of an expression as a result of what is evaluated in the yielded block.
*assert_recognizes(expected_options, path, extras={}, message=nil)
Asserts that the routing of the given path was handled correctly and that the parsed options (given in the expected_options hash) match path.
Basically, it asserts that Rails recognizes the route given by expected_options.
*assert_template(expected = nil, message=nil)
Asserts that the request was rendered with the appropriate template file.

= '''Support for Assertions in python''' =
In [http://www.python.org/ Python] when the [http://docs.python.org/reference/simple_stmts.html#the-assert-statement assert] statement is encountered, the expression following the assert keyword is evaluated and the AssertionError exception is raised if the expression evaluates to false.

For example, the following code would raise the [http://docs.python.org/library/exceptions.html#exceptions.AssertionError AssertionError] exception.

'''Syntax: assert condition'''

Example [1]:
#!/usr/bin/python
assert 1 == 2

In addition to evaluating an expression , arguments can be passed to the assertion so that for example, the right message can be displayed based on the outcome of the assertion.

'''Syntax: assert Expression[, Arguments]'''

Example [2];
#!/usr/bin/python
def IsSenior(age):
assert (age >= 1),"Age cannot be zero or less than zero !"
return (age >= 65)
print IsSenior(15)
print IsSenior(70)
print IsSenior(-1)

Example [2] Output;
false
true
Traceback (most recent call last):
File "test.py", line 9, in <module>
print IsSenior(-5)
File "test.py", line 4, in IsSenior
assert (age >= 1),"Age cannot be zero or less than zero !"
AssertionError: Age cannot be zero or less than zero !

One common used of assertions in python is for type checking. Please refer the article [http://pg-server.csc.ncsu.edu/mediawiki/index.php/CSC/ECE_517_Fall_2007/wiki3_1_sa#Python Assertion in O-O languages] for more details.

One of the key feature of assertions in Python is that if python is started with -O option, then the assertions would not be evaluated. The scenario where this feature would apply is developers can write a lot of assertions for debugging and when the code is to be executed in production , if it is started with -O option , then all the assertions written by the developers for debugging would not be evaluated.

In general assertions are not the best means to test for failure cases. Instead of using an assertion exceptions would be the right way to handle scenarios like wrong user input or system/environment failures.

= '''Benefits of assertions''' =
*Use of assertions in the program help detect errors immediately and directly, rather than at a later stage. Assertion failure usually reports the location of failure in the code which helps in pin-pointing the error without further debugging.
*Assertions provide run time check for assumptions made by developers
*Assertions are also sometimes placed at points the execution is not supposed to reach. For example, assertions could be placed at the default clause of the switch statement in languages such as C++, and Java. Any case which the programmer does not handle intentionally will raise an error and the program will abort rather than silently continuing in an erroneous state.
*Assertions can be viewed as "dynamic documentation", since they are checked at runtime, contrary to the traditional approach of documenting assumptions via plain /* comments */.

*Assert statements are great for helping you torefactor and optimize your code with greater confidence that you have preserved correctness

= '''Limitations of assertions''' =

*Assertions rarely allow for graceful error recovery. They terminate the program abruptly and may not release some of the resources used by the program; hence it is considered bad practice to rely upon assertions for handling expected error conditions.
* Assertions sometime hinder execution time. For example, if the program has an assert that checks to see if the number to be returned is the smallest in the array, then the assertion will have to do the same amount of work that the method would have to do.

= '''Conclusion''' =

When writing program, it is a good practice to check for violations of basic assumptions in the code. These checks help in debugging code. The assertion facility in J2SE 1.4 (and later versions) provides a unified support for assertions in Java technology as well as a convenient way for developers both to turn assertions on and off as needed. Assertions are used in Test Driven Development(TDD) in Ruby programing language. The Test::Unit library in Ruby has a variety of built in assertions that makes writing tests much easier.

Although the use of assertions replaces the ad hoc use of conditional tests with a uniform methodology, it does not allow for a repair strategy to continue program execution. This means that when an exception is detected, the program aborts with no recovery mechanism. Nevertheless, assertions play an important role in debugging and designing code with testability in mind. The assertion facility can be used to support an informal design-by-contract style of programming.

= '''Reference''' =

[http://download.oracle.com/javase/1.4.2/docs/guide/lang/assert.html] Programming with Assertions

[http://www.deitel.com/articles/java_tutorials/20060106/Assertions.html] Assertions in java

[http://ruby-doc.org/stdlib/libdoc/test/unit/rdoc/classes/Test/Unit/Assertions.html#M004514] Assertions in Ruby

[http://guides.rubyonrails.org/testing.html#assertions-available] Ruby assertions

[http://topfunky.com/clients/rails/ruby_and_rails_assertions.pdf] Ruby on Rails assertion cheat sheet

[http://www.cs.clemson.edu/~malloy/papers/prospectus/prospectus.pdf] More about assertions

[http://docs.python.org/reference/simple_stmts.html] Python simple statements documentation

[http://www.tutorialspoint.com/python/assertions_in_python.htm] Assertions in Python

Zz

2010-11-16T03:38:20Z

Kschidam:

'''Support for Assertions in Various O-O Programming Languages'''

= '''Introduction''' =

In computer language an [http://en.wikipedia.org/wiki/Assertion_(computing) assertion] is a construct that immediately terminates the execution of a program if a certain expression or a condition is evaluated to false (assertion failure). It is mainly used for code [http://en.wikipedia.org/wiki/Debugging debugging] . Programmers use assertions to check for potential errors or bugs in the application being developed. The main feature of assertions is to verify the validity of the assumptions made by chunk of code during execution. A good example to illustrate this is the use of [http://en.wikipedia.org/wiki/Dynamic_memory_allocation dynamic memory allocation] in C++, wherein we can use an assertion to check a [http://en.wikipedia.org/wiki/Pointer_(computing) pointer] and ensure that it is not null before using this pointer. If this check in not made, a reference may occur later that would cause an error. Assertions play a vital role in developing reliable object-oriented software. An early advocate of using assertions in programming was Alan Turing [5]. Assertions serve to make explicit the assumptions on which programmers rely when they write software elements that they believe are correct. Assertion-based Object-Oriented techniques produce reliable software and enable software components to be reused safely. In languages such as Eiffel, assertions form part of the design process, and in others, such as C and Java, they are used only to check assumptions at runtime. Various object oriented programming languages support assertions.

= '''Support for Assertions in java''' =

When implementing and debugging a class in java programming language, it is a good practice to specify conditions that should be true at a particular stage in a method. These conditions, called assertions, guarantee a program’s validity by catching potential bugs and identifying possible logic errors during development. For example, if you write a module that calculates the temperature of an element, you might assert that the calculated temperature is not less than 0 degree Kelvin. The syntax for assert statements are as follows [1]:

assert Expression1;

Expression1 is a [http://en.wikipedia.org/wiki/Boolean_expression Boolean expression]. If Expression1 is evaluated to be false, then the system throws an AssertionError. This syntax for assert will not give a detail error message. Therefore second form of assert syntax can be used [1] as given below
assert Expression1: Expression2;

Expression1 is a Boolean expression. Expression2 is an expression that has a value. This version of the assert statement provides detail message for the AssertionError. The system passes the value of Expression2 to the appropriate AssertionError constructor, which uses the string representation of the value as the error's detail message. This form of the assertion statement should be used in preference to the first only when the program has some additional information that might help diagnose the failure. Below is an example code that demonstrates the functionality of assert statement. This code checks with assert that the value entered is an even number only [2].

import java.util.Scanner;

public class AssertTest
{
public static void main( String args[] )
{
Scanner input = new Scanner( System.in );

System.out.print( "Enter an even number: " );
int number = input.nextInt();

// assert that the number is even
assert ((number % 2 == 0)) : "Not an even number: " + number;

System.out.printf( "You entered an even number %d\n", number );
}
}
OUTPUT:

Enter an even number: 10
You entered an even number 10

Enter an even number: 25
Exception in thread "main" java.lang.AssertionError: Not an even number: 25
at AssertTest.main(AssertTest.java:15)

The above code prompts the user to enter an even number, then this number is read from command prompt. The assert statement then determines whether the user entered an even or odd number. If the user entered an odd number (as in second case of output), then the program throws an error. Otherwise, the program proceeds normally. Any line that executes after the assert statement can safely assume that number is not odd

One obvious question that may arise is when exceptions can do the [http://en.wikipedia.org/wiki/Exception_handling error handling] why we need another level of checking. Java exceptions are primarily used to handle unusual conditions arising during program execution. Assertions are not to replace exceptions but to augment them. Assertions are used to specify conditions that a programmer assumes are true. When programming, if a programmer can swear that the value being passed into a particular method is positive no matter what a calling client passes, it can be documented using an assertion to state it. Exceptions handle abnormal conditions arising in the course of the program; however they do not guarantee smooth or correct execution of the program. Assertions help state scenarios that ensure the program is running smoothly. Assertions can be efficient tools to ensure correct execution of a program. They improve the confidence about the program.

== '''Types of Assertions''' ==
* Preconditions - These are assertions about a program’s state when a method is invoked. Precondition refers to the parameters passed to a method in a program. Precondition asserts check the validity of parameters passed before they get used in the body of the method.
* Postconditions - These are assertions about a program’s state after a method finishes execution. Postcondition should be evaluated before the exit point in a method. Postcondition asserts can be used to check for the validity of the return values in a method that has multiple return statements.

One situation where use of assertions is helpful in Java programming language is : Internal Invariants [1]. Assertions can be used within programs to make sure the program behaves in a predetermined manner and will throw an error when violated. For instance, an assertion can be placed in the code below to declare that age will never be negative.

if (age > 0)
{
age = age + 1;
}
else
{
assert age >0:"Age cannot be negative"
}

== '''Enabling and Disabling Assertions'''==

At runtime assertions are disabled by default as they reduce performance. To enable assertions at [http://en.wikipedia.org/wiki/Run_time_(computing) runtime], use the -ea command-line option. To disable assertions, use –da command line option. To execute a code with assertions enabled use
java -ea AssertTest

The assertion status of a class (enabled or disabled) is set at the time it is initialized, and does not change. There is, however, one corner case that demands special treatment. It is possible, though generally not desirable, to execute methods or constructors prior to initialization. This can happen when a class hierarchy contains circularity in its static initialization. If an assert statement executes before its class is initialized, the execution must behave as if assertions were enabled in the class.

= '''Support for Assertions in Ruby''' =

[http://en.wikipedia.org/wiki/Unit_testing Unit testing] is a process where individual parts of [http://en.wikipedia.org/wiki/Source_code source code] are isolated and tested separately to determine if they are bug free. The idea behind unit testing is that you write a test method that makes certain assertions about your code, working against a test fixture. [http://en.wikipedia.org/wiki/Ruby_(programming_language) Ruby language] supports a module called Test::Unit::Assertions in test/unit/assertions.rb. Test::Unit::Assertions contains the standard Test::Unit assertions. Assertions is includedin Test::Unit::TestCase.

=='''Public class assert methods'''==

*assert( boolean, [msg] )- This ensures that the object/expression is true
assert [10, 20].include?(50)

*assert_block(message="assert_block failed.") {|| ...} - If the block yields to true , then the assert passes
Example [3]:
def assert_block(message="assert_block failed.") # :yields:
_wrap_assertion do
if (! yield)
raise AssertionFailedError.new(message.to_s)
end
end
end

* assert_match( regexp, string, [msg] )- Ensures that a string matches the regular expression

Example [3]:
def assert_match(pattern, string, message="")
_wrap_assertion do
pattern = case(pattern)
when String
Regexp.new(Regexp.escape(pattern))
else
pattern
end
full_message = build_message(message, "<?> expected to be =~\n<?>.", string, pattern)
assert_block(full_message) { string =~ pattern }
end
end

*assert_not_equal(expected, actual, message="") - If expected != actual, then the assert passes

Example [3]:
def assert_not_equal(expected, actual, message="")
full_message = build_message(message, "<?> expected to be != to\n<?>.", expected, actual)
assert_block(full_message) { expected != actual }
end

*assert_nil(object, message="") - This assert passes if the object is nil.

Example[3]:

# File test/unit/assertions.rb, line 173
def assert_nil(object, message="")
assert_equal(nil, object, message)
end

There are a bunch of other public class methods. This can be obtained from [4]

=='''Test Method & Test Fixture'''==

Assertions must be used inside test methods within test fixtures. Related tests are grouped inside a common test class using assert. The advantage of having a separate class for all related tests is that it keeps the actual developed code to be tested uncluttered from the test code, hence making maintainability easier. It also allows these test code to be deleted from the development code before the final delivery as these test codes are needed mainly for the developer/tester and need not be part of the final product. Main advantage is it allows you to set up a common test fixture for your tests to run against. Test fixtures are a way of organizing test data; they reside in the fixtures folder. The test_helper.rb file holds the default configuration for your tests.

=='''Ruby on Rails'''==

[http://en.wikipedia.org/wiki/Ruby_on_Rails Rails] is an open source web framework for Ruby language. Rails adds some custom assertions of its own to the test/unit framework some of which are as stated below:

*assert_difference(expressions, difference = 1, message = nil) {...}
Test numeric difference between the return value of an expression as a result of what is evaluated in the yielded block.
*assert_recognizes(expected_options, path, extras={}, message=nil)
Asserts that the routing of the given path was handled correctly and that the parsed options (given in the expected_options hash) match path.
Basically, it asserts that Rails recognizes the route given by expected_options.
*assert_template(expected = nil, message=nil)
Asserts that the request was rendered with the appropriate template file.

= '''Benefits of assertions''' =
*Use of assertions in the program help detect errors immediately and directly, rather than at a later stage. Assertion failure usually reports the location of failure in the code which helps in pin-pointing the error without further debugging.
*Assertions provide run time check for assumptions made by developers
*Assertions are also sometimes placed at points the execution is not supposed to reach. For example, assertions could be placed at the default clause of the switch statement in languages such as C++, and Java. Any case which the programmer does not handle intentionally will raise an error and the program will abort rather than silently continuing in an erroneous state.
*Assertions can be viewed as "dynamic documentation", since they are checked at runtime, contrary to the traditional approach of documenting assumptions via plain /* comments */.

*Assert statements are great for helping you torefactor and optimize your code with greater confidence that you have preserved correctness

= '''Limitations of assertions''' =

*Assertions rarely allow for graceful error recovery. They terminate the program abruptly and may not release some of the resources used by the program; hence it is considered bad practice to rely upon assertions for handling expected error conditions.
* Assertions sometime hinder execution time. For example, if the program has an assert that checks to see if the number to be returned is the smallest in the array, then the assertion will have to do the same amount of work that the method would have to do.

= '''Conclusion''' =

When writing program, it is a good practice to check for violations of basic assumptions in the code. These checks help in debugging code. The assertion facility in J2SE 1.4 (and later versions) provides a unified support for assertions in Java technology as well as a convenient way for developers both to turn assertions on and off as needed. Assertions are used in Test Driven Development(TDD) in Ruby programing language. The Test::Unit library in Ruby has a variety of built in assertions that makes writing tests much easier.

Although the use of assertions replaces the ad hoc use of conditional tests with a uniform methodology, it does not allow for a repair strategy to continue program execution. This means that when an exception is detected, the program aborts with no recovery mechanism. Nevertheless, assertions play an important role in debugging and designing code with testability in mind. The assertion facility can be used to support an informal design-by-contract style of programming.

= '''Reference''' =

[http://download.oracle.com/javase/1.4.2/docs/guide/lang/assert.html] Programming with Assertions

[http://www.deitel.com/articles/java_tutorials/20060106/Assertions.html] Assertions in java

[http://ruby-doc.org/stdlib/libdoc/test/unit/rdoc/classes/Test/Unit/Assertions.html#M004514] Assertions in Ruby

[http://guides.rubyonrails.org/testing.html#assertions-available] Ruby assertions

[http://topfunky.com/clients/rails/ruby_and_rails_assertions.pdf] Ruby on Rails assertion cheat sheet

[http://www.cs.clemson.edu/~malloy/papers/prospectus/prospectus.pdf] More about assertions

CSC/ECE 517 Fall 2010/ch3 3j KS

2010-10-15T04:55:24Z

Kschidam: /* Object-relational Mapping Comparison for Ruby */

=Object-relational Mapping for Ruby=

__TOC__

=Introduction=

[http://en.wikipedia.org/wiki/Object-relational_mapping Object-relational mapping (ORM)] provides developers with a set of tools that ease management of the relationships between objects and relational databases, thus allowing applications to be easily extended to add data persistence. For Ruby, several object-relational mapping options are available. This wiki concentrates more on the comparison of ORM's and it gives a very high level overview of the various ORM's such as ActiveRecord , Sequel and DataMapper.

=Overview=

Object-relational Mapping (ORM) frameworks unburden the designer of the complex translation between database and object space.

Typical ORM features:
* Automatic mapping from classes to database tables
** Class instance variables to database columns
** Class instances to table rows
* Aggregation and association relationships between mapped classes are managed
** Example, :has_many, :belongs_to associations in ActiveRecord
** Inheritance cases are mapped to tables
* Validation of data prior to table storage
* Class extensions to enable search, as well as creation, read, update, and deletion (CRUD) of instances/records
* Usually abstracts the database from program space in such a way that alternate database types can be easily chosen (SQLite, Oracle, etc)

The diagram below depicts a simple mapping of an object to a database table….

[[Image:3j_ks_pic1.jpg]]

When applied to Ruby, implementations of ORM often leverage the language’s [http://en.wikipedia.org/wiki/Metaprogramming metaprogramming] strengths to create intuitive application-specific methods and otherwise extend classes to support database functionality.

=ActiveRecord=

[http://ar.rubyonrails.org/ ActiveRecord], originally created by David Heinemeier and released in 2003, became the de-facto ORM for Ruby since it was integrated in the widely-used Rails framework, however alternate ORMs for Ruby have been developed and Rails 3.x is ORM independent. ActiveRecord is an implementation of the active record design pattern, where a table is wrapped into a class and this class implements accessor methods for each column in the table.

To create a table, ActiveRecord makes use of a migration class rather than including table definition in the actual class being modeled. As an example, the following code creates a table ‘’users’’ to store a collection of class ‘’User’’ objects:
<pre>
class CreateUsers < ActiveRecord::Migration
def self.up
create_table :users do |t|
t.string :name
t.string :email
t.string :age

t.timestamps # add creation and modification timestamps
end
end

def self.down # undo the table creation
drop_table :users
end
end
</pre>

Note in the preceeding example, that the ActiveRecord’s migration scheme provides a means for backing out changes via the ‘’self.down’’ method. In addition, a table key ‘’id’’ is added to the new table without explicit definition and record creation and modification timestamps are included via the ‘’timestamps’’ method provided by ActiveRecord.

ActiveRecord manages associations between table elements and provides the means to define such associations in the model definition. For example, the ‘’User’’ class shown below defines a ‘’to_many’’ association with both the cheers and posts tables. Also note ActiveRecord’s integrated support for validation of table information when attempting an update.

<pre>
class User < ActiveRecord::Base
has_many :cheers
has_many :posts

validates_presence_of :name
validates_presence_of :age
validates_uniqueness_of :name
validates_length_of :name, :within => 3..20
end
</pre>

While ActiveRecord provides the flexibility to create more sophisticated table relationships to represent class hierarchy, its base scheme is a single table inheritance, which trades some storage efficiency for simplicity in the database design. The following figure illustrates this concept of simplicity over efficiency.

[[Image:3j_ks_pic2.jpg]]

'''Pros''' -
* Integrated with popular Rails development framework
* Dynamically created database search methods (eg: User.find_by_address) ease db queries and make queries database syntax independent
* DB creation/management using the migrate scheme provides a means for backing out unwanted table changes
'''Cons''' -
* DB creation/management is decoupled from the model, requiring a separate utility (rake/migrate) that must be kept in sync with application

=Sequel=

[http://sequel.rubyforge.org Sequel] was originally developed by Sharon Rosner and the first release was in March 2007. It is based on the active record pattern. Sequel and Active record share a lot of common features , for example association and inheritance. But Sequel handles these features in a much more flexible manner. Currently Sequel is at version 3.16.0. Initially Sequel was had three core modules - sequel, sequel_core and sequel_model.Starting from version 1.4 , sequel and sequel_model were merged. Sequel handles validations using a validation plug-in and helpers.

<pre>
class CreateUser < Sequel::Migration
def up
create_table(:user) {
primary_key :id
String :name
String :age
String :email}
end
def down
drop_table(:user)
end
end # CreateUser.apply(DB, :up)
</pre>

Sequel supports associations and validations similar to ActiveRecord. The following example shows how validations and associations can be enforced int he User table that has been created above. It enforces one to many relationship between the user table and the cheers , posts tables. It also validates for the presence , uniqueness and the length of the attribute '''name'''.

<pre>
class User < Sequel::Model
one_to_many :cheers
one_to_many :posts

validates_presence [:name, :age]
validates_unique(:name)
validates_length_range 3..20, :name
end
</pre>

Some of the key features of sequel are,
* Connection Pooling
* Thread Safety
* Eager Loading / Lazy Loading
* Model Caching

=DataMapper=

[http://datamapper.org/ DataMapper] is an open source ORM for Ruby originally developed by Sam Smoot and first released in 2007. DataMapper provides a very flexible mapping API which allows creation of adapters to a wide variety of datastores beyond traditional SQL-based relational databases – DataMapper adapters have been created to non-standard sources such as the Salesforce API and even Google Video.

Unlike ActiveRecord and Sequel, DataMapper does not rely on a migration scheme to create and manage DB tables. Instead, DataMapper allows table definition as part of the model class definition which keeps the model definition contained to a single file, thus minimizing the effort required to keep the database and model definitions in sync. When required, DataMapper can also support a migration methodology similar to other ORMs.

Example of table definition in the model:
<pre>
class User
include DataMapper::Resource

property :id, Serial # key
property :name, String, :required => true, :unique => true
property :age, String, :required => true, :length => 3..20
property :email, String

has n, :posts # one to many association
has n, :cheers # one to many association
end
</pre>

Notice that in the example above , ":required = true" is an example for Auto Validation. Unlike ActiveRecord and Sequel, DataMapper supports auto validations , i.e. these in turn call the validation helpers to enforce basic validations such as length, uniqueness, format, presence etc.

Some of the key features of DataMapper are:
* API supports a wide variety of databases, including non SQL types
* Thread Safety
* Eager loading of child associations
* Lazy loading

=Comparison of ORM Features=

{|cellspacing="0" border="1"
!style="width:10%"|Features
!style="width:30%"|ActiveRecord
!style="width:30%"|Sequel
!style="width:30%"|DataMapper
|-
! Databases 
| MySQL, PostgreSQL, SQLite, Oracle, SQLServer, and DB2
| ADO, DataObjects, DB2, DBI, Firebird, Informix, JDBC, MySQL, ODBC, OpenBase, Oracle, PostgreSQL and SQLite3
| SQLite, MySQL, PostgreSQL, Oracle, MongoDB, SimpleDB, many others, including CouchDB, Apache Solr, Google Data API
|-
! Migrations 
| Yes
| Yes
| Yes, but optional
|-
! EagerLoading 
| Supported by scanning the SQL fragments
| Supported using eager (preloading) and eager_graph (joins)
| Strategic Eager Loading and by using :summary
|-
! Flexible Overriding 
| No. Overriding is done using alias methods.
| Using methods and by calling 'super'
| Using methods
|-
! Dynamic Finders 
| Yes. Uses 'Method Missing'
| No. Alternative is to use <Model>.FindOrCreate(:name=>"John")
| Yes. Using the dm_ar_finders plugin
|}

 

=Further Reading=
To get more information on ORM and the different type of ORM's available for Ruby , please look into the [http://pg-server.csc.ncsu.edu/mediawiki/index.php/CSC/ECE_517_Fall_2007/wiki2_2_22, Object-relational mapping Fall 2007] wiki.

=Future Work=
More work can be done in the area of comparison between the different ORMs available for Ruby, especially a performance comparison between the ORM's. We came across one cool website which has the ORM comparison for .Net [http://ormbattle.net/ ORMBattle.Net]. Something similar would be really helpful. Due to the time contraint and lack of indepth knowledge we were not able to work on these areas.
=References=

# [http://en.wikipedia.org/wiki/Object-relational_mapping Wikipedia, Object-relational mapping (ORM)]
# [http://ar.rubyonrails.org/ ActiveRecord]
# [http://en.wikipedia.org/wiki/Active_record_pattern Wikipedia Active record pattern]
# [http://sequel.rubyforge.org/ Sequel]
# [http://jeremyevans-pres.heroku.com/mwrc2009_presentation.html Sequel Presentation - By Jeremy Evans]
# [http://merbist.com/2008/09/29/write-your-own-custom-datamapper-adapter/ Merbist blog on custom DM adapters - By Matt Aimonetti]
# [http://en.wikipedia.org/wiki/Datamapper DataMapper]
# [http://pg-server.csc.ncsu.edu/mediawiki/index.php/CSC/ECE_517_Fall_2007/wiki2_2_22 Object-Relational Mapping Fall 2007]
# [http://ormbattle.net/ ORMBattle.Net]

CSC/ECE 517 Fall 2010/ch3 3j KS

2010-10-15T04:44:45Z

Kschidam: /* '''Object-relational Mapping for Ruby''' */

=Object-relational Mapping Comparison for Ruby=

__TOC__

=Introduction=

[http://en.wikipedia.org/wiki/Object-relational_mapping Object-relational mapping (ORM)] provides developers with a set of tools that ease management of the relationships between objects and relational databases, thus allowing applications to be easily extended to add data persistence. For Ruby, several object-relational mapping options are available. This wiki concentrates more on the comparison of ORM's and it gives a very high level overview of the various ORM's such as ActiveRecord , Sequel and DataMapper.

=Overview=

Object-relational Mapping (ORM) frameworks unburden the designer of the complex translation between database and object space.

Typical ORM features:
* Automatic mapping from classes to database tables
** Class instance variables to database columns
** Class instances to table rows
* Aggregation and association relationships between mapped classes are managed
** Example, :has_many, :belongs_to associations in ActiveRecord
** Inheritance cases are mapped to tables
* Validation of data prior to table storage
* Class extensions to enable search, as well as creation, read, update, and deletion (CRUD) of instances/records
* Usually abstracts the database from program space in such a way that alternate database types can be easily chosen (SQLite, Oracle, etc)

The diagram below depicts a simple mapping of an object to a database table….

[[Image:3j_ks_pic1.jpg]]

When applied to Ruby, implementations of ORM often leverage the language’s [http://en.wikipedia.org/wiki/Metaprogramming metaprogramming] strengths to create intuitive application-specific methods and otherwise extend classes to support database functionality.

=ActiveRecord=

[http://ar.rubyonrails.org/ ActiveRecord], originally created by David Heinemeier and released in 2003, became the de-facto ORM for Ruby since it was integrated in the widely-used Rails framework, however alternate ORMs for Ruby have been developed and Rails 3.x is ORM independent. ActiveRecord is an implementation of the active record design pattern, where a table is wrapped into a class and this class implements accessor methods for each column in the table.

To create a table, ActiveRecord makes use of a migration class rather than including table definition in the actual class being modeled. As an example, the following code creates a table ‘’users’’ to store a collection of class ‘’User’’ objects:
<pre>
class CreateUsers < ActiveRecord::Migration
def self.up
create_table :users do |t|
t.string :name
t.string :email
t.string :age

t.timestamps # add creation and modification timestamps
end
end

def self.down # undo the table creation
drop_table :users
end
end
</pre>

Note in the preceeding example, that the ActiveRecord’s migration scheme provides a means for backing out changes via the ‘’self.down’’ method. In addition, a table key ‘’id’’ is added to the new table without explicit definition and record creation and modification timestamps are included via the ‘’timestamps’’ method provided by ActiveRecord.

ActiveRecord manages associations between table elements and provides the means to define such associations in the model definition. For example, the ‘’User’’ class shown below defines a ‘’to_many’’ association with both the cheers and posts tables. Also note ActiveRecord’s integrated support for validation of table information when attempting an update.

<pre>
class User < ActiveRecord::Base
has_many :cheers
has_many :posts

validates_presence_of :name
validates_presence_of :age
validates_uniqueness_of :name
validates_length_of :name, :within => 3..20
end
</pre>

While ActiveRecord provides the flexibility to create more sophisticated table relationships to represent class hierarchy, its base scheme is a single table inheritance, which trades some storage efficiency for simplicity in the database design. The following figure illustrates this concept of simplicity over efficiency.

[[Image:3j_ks_pic2.jpg]]

'''Pros''' -
* Integrated with popular Rails development framework
* Dynamically created database search methods (eg: User.find_by_address) ease db queries and make queries database syntax independent
* DB creation/management using the migrate scheme provides a means for backing out unwanted table changes
'''Cons''' -
* DB creation/management is decoupled from the model, requiring a separate utility (rake/migrate) that must be kept in sync with application

=Sequel=

[http://sequel.rubyforge.org Sequel] was originally developed by Sharon Rosner and the first release was in March 2007. It is based on the active record pattern. Sequel and Active record share a lot of common features , for example association and inheritance. But Sequel handles these features in a much more flexible manner. Currently Sequel is at version 3.16.0. Initially Sequel was had three core modules - sequel, sequel_core and sequel_model.Starting from version 1.4 , sequel and sequel_model were merged. Sequel handles validations using a validation plug-in and helpers.

<pre>
class CreateUser < Sequel::Migration
def up
create_table(:user) {
primary_key :id
String :name
String :age
String :email}
end
def down
drop_table(:user)
end
end # CreateUser.apply(DB, :up)
</pre>

Sequel supports associations and validations similar to ActiveRecord. The following example shows how validations and associations can be enforced int he User table that has been created above. It enforces one to many relationship between the user table and the cheers , posts tables. It also validates for the presence , uniqueness and the length of the attribute '''name'''.

<pre>
class User < Sequel::Model
one_to_many :cheers
one_to_many :posts

validates_presence [:name, :age]
validates_unique(:name)
validates_length_range 3..20, :name
end
</pre>

Some of the key features of sequel are,
* Connection Pooling
* Thread Safety
* Eager Loading / Lazy Loading
* Model Caching

=DataMapper=

[http://datamapper.org/ DataMapper] is an open source ORM for Ruby originally developed by Sam Smoot and first released in 2007. DataMapper provides a very flexible mapping API which allows creation of adapters to a wide variety of datastores beyond traditional SQL-based relational databases – DataMapper adapters have been created to non-standard sources such as the Salesforce API and even Google Video.

Unlike ActiveRecord and Sequel, DataMapper does not rely on a migration scheme to create and manage DB tables. Instead, DataMapper allows table definition as part of the model class definition which keeps the model definition contained to a single file, thus minimizing the effort required to keep the database and model definitions in sync. When required, DataMapper can also support a migration methodology similar to other ORMs.

Example of table definition in the model:
<pre>
class User
include DataMapper::Resource

property :id, Serial # key
property :name, String, :required => true, :unique => true
property :age, String, :required => true, :length => 3..20
property :email, String

has n, :posts # one to many association
has n, :cheers # one to many association
end
</pre>

Notice that in the example above , ":required = true" is an example for Auto Validation. Unlike ActiveRecord and Sequel, DataMapper supports auto validations , i.e. these in turn call the validation helpers to enforce basic validations such as length, uniqueness, format, presence etc.

Some of the key features of DataMapper are:
* API supports a wide variety of databases, including non SQL types
* Thread Safety
* Eager loading of child associations
* Lazy loading

=Comparison of ORM Features=

{|cellspacing="0" border="1"
!style="width:10%"|Features
!style="width:30%"|ActiveRecord
!style="width:30%"|Sequel
!style="width:30%"|DataMapper
|-
! Databases 
| MySQL, PostgreSQL, SQLite, Oracle, SQLServer, and DB2
| ADO, DataObjects, DB2, DBI, Firebird, Informix, JDBC, MySQL, ODBC, OpenBase, Oracle, PostgreSQL and SQLite3
| SQLite, MySQL, PostgreSQL, Oracle, MongoDB, SimpleDB, many others, including CouchDB, Apache Solr, Google Data API
|-
! Migrations 
| Yes
| Yes
| Yes, but optional
|-
! EagerLoading 
| Supported by scanning the SQL fragments
| Supported using eager (preloading) and eager_graph (joins)
| Strategic Eager Loading and by using :summary
|-
! Flexible Overriding 
| No. Overriding is done using alias methods.
| Using methods and by calling 'super'
| Using methods
|-
! Dynamic Finders 
| Yes. Uses 'Method Missing'
| No. Alternative is to use <Model>.FindOrCreate(:name=>"John")
| Yes. Using the dm_ar_finders plugin
|}

 

=Further Reading=
To get more information on ORM and the different type of ORM's available for Ruby , please look into the [http://pg-server.csc.ncsu.edu/mediawiki/index.php/CSC/ECE_517_Fall_2007/wiki2_2_22, Object-relational mapping Fall 2007] wiki.

=Future Work=
More work can be done in the area of comparison between the different ORMs available for Ruby, especially a performance comparison between the ORM's. We came across one cool website which has the ORM comparison for .Net [http://ormbattle.net/ ORMBattle.Net]. Something similar would be really helpful. Due to the time contraint and lack of indepth knowledge we were not able to work on these areas.
=References=

# [http://en.wikipedia.org/wiki/Object-relational_mapping Wikipedia, Object-relational mapping (ORM)]
# [http://ar.rubyonrails.org/ ActiveRecord]
# [http://en.wikipedia.org/wiki/Active_record_pattern Wikipedia Active record pattern]
# [http://sequel.rubyforge.org/ Sequel]
# [http://jeremyevans-pres.heroku.com/mwrc2009_presentation.html Sequel Presentation - By Jeremy Evans]
# [http://merbist.com/2008/09/29/write-your-own-custom-datamapper-adapter/ Merbist blog on custom DM adapters - By Matt Aimonetti]
# [http://en.wikipedia.org/wiki/Datamapper DataMapper]
# [http://pg-server.csc.ncsu.edu/mediawiki/index.php/CSC/ECE_517_Fall_2007/wiki2_2_22 Object-Relational Mapping Fall 2007]
# [http://ormbattle.net/ ORMBattle.Net]

CSC/ECE 517 Fall 2010/ch3 3j KS

2010-10-15T04:34:09Z

Kschidam: /* Comparison of ORM Features */

='''Object-relational Mapping for Ruby'''=

__TOC__

=Introduction=

[http://en.wikipedia.org/wiki/Object-relational_mapping Object-relational mapping (ORM)] provides developers with a set of tools that ease management of the relationships between objects and relational databases, thus allowing applications to be easily extended to add data persistence. For Ruby, several object-relational mapping options are available. This wiki concentrates more on the comparison of ORM's and it gives a very high level overview of the various ORM's such as ActiveRecord , Sequel and DataMapper.

=Overview=

Object-relational Mapping (ORM) frameworks unburden the designer of the complex translation between database and object space.

Typical ORM features:
* Automatic mapping from classes to database tables
** Class instance variables to database columns
** Class instances to table rows
* Aggregation and association relationships between mapped classes are managed
** Example, :has_many, :belongs_to associations in ActiveRecord
** Inheritance cases are mapped to tables
* Validation of data prior to table storage
* Class extensions to enable search, as well as creation, read, update, and deletion (CRUD) of instances/records
* Usually abstracts the database from program space in such a way that alternate database types can be easily chosen (SQLite, Oracle, etc)

The diagram below depicts a simple mapping of an object to a database table….

[[Image:3j_ks_pic1.jpg]]

When applied to Ruby, implementations of ORM often leverage the language’s [http://en.wikipedia.org/wiki/Metaprogramming metaprogramming] strengths to create intuitive application-specific methods and otherwise extend classes to support database functionality.

=ActiveRecord=

[http://ar.rubyonrails.org/ ActiveRecord], originally created by David Heinemeier and released in 2003, became the de-facto ORM for Ruby since it was integrated in the widely-used Rails framework, however alternate ORMs for Ruby have been developed and Rails 3.x is ORM independent. ActiveRecord is an implementation of the active record design pattern, where a table is wrapped into a class and this class implements accessor methods for each column in the table.

To create a table, ActiveRecord makes use of a migration class rather than including table definition in the actual class being modeled. As an example, the following code creates a table ‘’users’’ to store a collection of class ‘’User’’ objects:
<pre>
class CreateUsers < ActiveRecord::Migration
def self.up
create_table :users do |t|
t.string :name
t.string :email
t.string :age

t.timestamps # add creation and modification timestamps
end
end

def self.down # undo the table creation
drop_table :users
end
end
</pre>

Note in the preceeding example, that the ActiveRecord’s migration scheme provides a means for backing out changes via the ‘’self.down’’ method. In addition, a table key ‘’id’’ is added to the new table without explicit definition and record creation and modification timestamps are included via the ‘’timestamps’’ method provided by ActiveRecord.

ActiveRecord manages associations between table elements and provides the means to define such associations in the model definition. For example, the ‘’User’’ class shown below defines a ‘’to_many’’ association with both the cheers and posts tables. Also note ActiveRecord’s integrated support for validation of table information when attempting an update.

<pre>
class User < ActiveRecord::Base
has_many :cheers
has_many :posts

validates_presence_of :name
validates_presence_of :age
validates_uniqueness_of :name
validates_length_of :name, :within => 3..20
end
</pre>

While ActiveRecord provides the flexibility to create more sophisticated table relationships to represent class hierarchy, its base scheme is a single table inheritance, which trades some storage efficiency for simplicity in the database design. The following figure illustrates this concept of simplicity over efficiency.

[[Image:3j_ks_pic2.jpg]]

'''Pros''' -
* Integrated with popular Rails development framework
* Dynamically created database search methods (eg: User.find_by_address) ease db queries and make queries database syntax independent
* DB creation/management using the migrate scheme provides a means for backing out unwanted table changes
'''Cons''' -
* DB creation/management is decoupled from the model, requiring a separate utility (rake/migrate) that must be kept in sync with application

=Sequel=

[http://sequel.rubyforge.org Sequel] was originally developed by Sharon Rosner and the first release was in March 2007. It is based on the active record pattern. Sequel and Active record share a lot of common features , for example association and inheritance. But Sequel handles these features in a much more flexible manner. Currently Sequel is at version 3.16.0. Initially Sequel was had three core modules - sequel, sequel_core and sequel_model.Starting from version 1.4 , sequel and sequel_model were merged. Sequel handles validations using a validation plug-in and helpers.

<pre>
class CreateUser < Sequel::Migration
def up
create_table(:user) {
primary_key :id
String :name
String :age
String :email}
end
def down
drop_table(:user)
end
end # CreateUser.apply(DB, :up)
</pre>

Sequel supports associations and validations similar to ActiveRecord. The following example shows how validations and associations can be enforced int he User table that has been created above. It enforces one to many relationship between the user table and the cheers , posts tables. It also validates for the presence , uniqueness and the length of the attribute '''name'''.

<pre>
class User < Sequel::Model
one_to_many :cheers
one_to_many :posts

validates_presence [:name, :age]
validates_unique(:name)
validates_length_range 3..20, :name
end
</pre>

Some of the key features of sequel are,
* Connection Pooling
* Thread Safety
* Eager Loading / Lazy Loading
* Model Caching

=DataMapper=

[http://datamapper.org/ DataMapper] is an open source ORM for Ruby originally developed by Sam Smoot and first released in 2007. DataMapper provides a very flexible mapping API which allows creation of adapters to a wide variety of datastores beyond traditional SQL-based relational databases – DataMapper adapters have been created to non-standard sources such as the Salesforce API and even Google Video.

Unlike ActiveRecord and Sequel, DataMapper does not rely on a migration scheme to create and manage DB tables. Instead, DataMapper allows table definition as part of the model class definition which keeps the model definition contained to a single file, thus minimizing the effort required to keep the database and model definitions in sync. When required, DataMapper can also support a migration methodology similar to other ORMs.

Example of table definition in the model:
<pre>
class User
include DataMapper::Resource

property :id, Serial # key
property :name, String, :required => true, :unique => true
property :age, String, :required => true, :length => 3..20
property :email, String

has n, :posts # one to many association
has n, :cheers # one to many association
end
</pre>

Notice that in the example above , ":required = true" is an example for Auto Validation. Unlike ActiveRecord and Sequel, DataMapper supports auto validations , i.e. these in turn call the validation helpers to enforce basic validations such as length, uniqueness, format, presence etc.

Some of the key features of DataMapper are:
* API supports a wide variety of databases, including non SQL types
* Thread Safety
* Eager loading of child associations
* Lazy loading

=Comparison of ORM Features=

{|cellspacing="0" border="1"
!style="width:10%"|Features
!style="width:30%"|ActiveRecord
!style="width:30%"|Sequel
!style="width:30%"|DataMapper
|-
! Databases 
| MySQL, PostgreSQL, SQLite, Oracle, SQLServer, and DB2
| ADO, DataObjects, DB2, DBI, Firebird, Informix, JDBC, MySQL, ODBC, OpenBase, Oracle, PostgreSQL and SQLite3
| SQLite, MySQL, PostgreSQL, Oracle, MongoDB, SimpleDB, many others, including CouchDB, Apache Solr, Google Data API
|-
! Migrations 
| Yes
| Yes
| Yes, but optional
|-
! EagerLoading 
| Supported by scanning the SQL fragments
| Supported using eager (preloading) and eager_graph (joins)
| Strategic Eager Loading and by using :summary
|-
! Flexible Overriding 
| No. Overriding is done using alias methods.
| Using methods and by calling 'super'
| Using methods
|-
! Dynamic Finders 
| Yes. Uses 'Method Missing'
| No. Alternative is to use <Model>.FindOrCreate(:name=>"John")
| Yes. Using the dm_ar_finders plugin
|}

 

=Further Reading=
To get more information on ORM and the different type of ORM's available for Ruby , please look into the [http://pg-server.csc.ncsu.edu/mediawiki/index.php/CSC/ECE_517_Fall_2007/wiki2_2_22, Object-relational mapping Fall 2007] wiki.

=Future Work=
More work can be done in the area of comparison between the different ORMs available for Ruby, especially a performance comparison between the ORM's. We came across one cool website which has the ORM comparison for .Net [http://ormbattle.net/ ORMBattle.Net]. Something similar would be really helpful. Due to the time contraint and lack of indepth knowledge we were not able to work on these areas.
=References=

# [http://en.wikipedia.org/wiki/Object-relational_mapping Wikipedia, Object-relational mapping (ORM)]
# [http://ar.rubyonrails.org/ ActiveRecord]
# [http://en.wikipedia.org/wiki/Active_record_pattern Wikipedia Active record pattern]
# [http://sequel.rubyforge.org/ Sequel]
# [http://jeremyevans-pres.heroku.com/mwrc2009_presentation.html Sequel Presentation - By Jeremy Evans]
# [http://merbist.com/2008/09/29/write-your-own-custom-datamapper-adapter/ Merbist blog on custom DM adapters - By Matt Aimonetti]
# [http://en.wikipedia.org/wiki/Datamapper DataMapper]
# [http://pg-server.csc.ncsu.edu/mediawiki/index.php/CSC/ECE_517_Fall_2007/wiki2_2_22 Object-Relational Mapping Fall 2007]
# [http://ormbattle.net/ ORMBattle.Net]

CSC/ECE 517 Fall 2010/ch3 3j KS

2010-10-15T04:29:06Z

Kschidam: /* DataMapper */

='''Object-relational Mapping for Ruby'''=

__TOC__

=Introduction=

[http://en.wikipedia.org/wiki/Object-relational_mapping Object-relational mapping (ORM)] provides developers with a set of tools that ease management of the relationships between objects and relational databases, thus allowing applications to be easily extended to add data persistence. For Ruby, several object-relational mapping options are available. This wiki concentrates more on the comparison of ORM's and it gives a very high level overview of the various ORM's such as ActiveRecord , Sequel and DataMapper.

=Overview=

Object-relational Mapping (ORM) frameworks unburden the designer of the complex translation between database and object space.

Typical ORM features:
* Automatic mapping from classes to database tables
** Class instance variables to database columns
** Class instances to table rows
* Aggregation and association relationships between mapped classes are managed
** Example, :has_many, :belongs_to associations in ActiveRecord
** Inheritance cases are mapped to tables
* Validation of data prior to table storage
* Class extensions to enable search, as well as creation, read, update, and deletion (CRUD) of instances/records
* Usually abstracts the database from program space in such a way that alternate database types can be easily chosen (SQLite, Oracle, etc)

The diagram below depicts a simple mapping of an object to a database table….

[[Image:3j_ks_pic1.jpg]]

When applied to Ruby, implementations of ORM often leverage the language’s [http://en.wikipedia.org/wiki/Metaprogramming metaprogramming] strengths to create intuitive application-specific methods and otherwise extend classes to support database functionality.

=ActiveRecord=

[http://ar.rubyonrails.org/ ActiveRecord], originally created by David Heinemeier and released in 2003, became the de-facto ORM for Ruby since it was integrated in the widely-used Rails framework, however alternate ORMs for Ruby have been developed and Rails 3.x is ORM independent. ActiveRecord is an implementation of the active record design pattern, where a table is wrapped into a class and this class implements accessor methods for each column in the table.

To create a table, ActiveRecord makes use of a migration class rather than including table definition in the actual class being modeled. As an example, the following code creates a table ‘’users’’ to store a collection of class ‘’User’’ objects:
<pre>
class CreateUsers < ActiveRecord::Migration
def self.up
create_table :users do |t|
t.string :name
t.string :email
t.string :age

t.timestamps # add creation and modification timestamps
end
end

def self.down # undo the table creation
drop_table :users
end
end
</pre>

Note in the preceeding example, that the ActiveRecord’s migration scheme provides a means for backing out changes via the ‘’self.down’’ method. In addition, a table key ‘’id’’ is added to the new table without explicit definition and record creation and modification timestamps are included via the ‘’timestamps’’ method provided by ActiveRecord.

ActiveRecord manages associations between table elements and provides the means to define such associations in the model definition. For example, the ‘’User’’ class shown below defines a ‘’to_many’’ association with both the cheers and posts tables. Also note ActiveRecord’s integrated support for validation of table information when attempting an update.

<pre>
class User < ActiveRecord::Base
has_many :cheers
has_many :posts

validates_presence_of :name
validates_presence_of :age
validates_uniqueness_of :name
validates_length_of :name, :within => 3..20
end
</pre>

While ActiveRecord provides the flexibility to create more sophisticated table relationships to represent class hierarchy, its base scheme is a single table inheritance, which trades some storage efficiency for simplicity in the database design. The following figure illustrates this concept of simplicity over efficiency.

[[Image:3j_ks_pic2.jpg]]

'''Pros''' -
* Integrated with popular Rails development framework
* Dynamically created database search methods (eg: User.find_by_address) ease db queries and make queries database syntax independent
* DB creation/management using the migrate scheme provides a means for backing out unwanted table changes
'''Cons''' -
* DB creation/management is decoupled from the model, requiring a separate utility (rake/migrate) that must be kept in sync with application

=Sequel=

[http://sequel.rubyforge.org Sequel] was originally developed by Sharon Rosner and the first release was in March 2007. It is based on the active record pattern. Sequel and Active record share a lot of common features , for example association and inheritance. But Sequel handles these features in a much more flexible manner. Currently Sequel is at version 3.16.0. Initially Sequel was had three core modules - sequel, sequel_core and sequel_model.Starting from version 1.4 , sequel and sequel_model were merged. Sequel handles validations using a validation plug-in and helpers.

<pre>
class CreateUser < Sequel::Migration
def up
create_table(:user) {
primary_key :id
String :name
String :age
String :email}
end
def down
drop_table(:user)
end
end # CreateUser.apply(DB, :up)
</pre>

Sequel supports associations and validations similar to ActiveRecord. The following example shows how validations and associations can be enforced int he User table that has been created above. It enforces one to many relationship between the user table and the cheers , posts tables. It also validates for the presence , uniqueness and the length of the attribute '''name'''.

<pre>
class User < Sequel::Model
one_to_many :cheers
one_to_many :posts

validates_presence [:name, :age]
validates_unique(:name)
validates_length_range 3..20, :name
end
</pre>

Some of the key features of sequel are,
* Connection Pooling
* Thread Safety
* Eager Loading / Lazy Loading
* Model Caching

=DataMapper=

[http://datamapper.org/ DataMapper] is an open source ORM for Ruby originally developed by Sam Smoot and first released in 2007. DataMapper provides a very flexible mapping API which allows creation of adapters to a wide variety of datastores beyond traditional SQL-based relational databases – DataMapper adapters have been created to non-standard sources such as the Salesforce API and even Google Video.

Unlike ActiveRecord and Sequel, DataMapper does not rely on a migration scheme to create and manage DB tables. Instead, DataMapper allows table definition as part of the model class definition which keeps the model definition contained to a single file, thus minimizing the effort required to keep the database and model definitions in sync. When required, DataMapper can also support a migration methodology similar to other ORMs.

Example of table definition in the model:
<pre>
class User
include DataMapper::Resource

property :id, Serial # key
property :name, String, :required => true, :unique => true
property :age, String, :required => true, :length => 3..20
property :email, String

has n, :posts # one to many association
has n, :cheers # one to many association
end
</pre>

Notice that in the example above , ":required = true" is an example for Auto Validation. Unlike ActiveRecord and Sequel, DataMapper supports auto validations , i.e. these in turn call the validation helpers to enforce basic validations such as length, uniqueness, format, presence etc.

Some of the key features of DataMapper are:
* API supports a wide variety of databases, including non SQL types
* Thread Safety
* Eager loading of child associations
* Lazy loading

=Comparison of ORM Features=

{|cellspacing="0" border="1"
!style="width:10%"|Features
!style="width:30%"|ActiveRecord
!style="width:30%"|Sequel
!style="width:30%"|DataMapper
|-
! Databases 
| MySQL, PostgreSQL, SQLite, Oracle, SQLServer, and DB2
| ADO, DataObjects, DB2, DBI, Firebird, Informix, JDBC, MySQL, ODBC, OpenBase, Oracle, PostgreSQL and SQLite3
| SQLite, MySQL, PostgreSQL, Oracle, MongoDB, SimpleDB, many others, including CouchDB, Apache Solr, Google Data API
|-
! Migrations 
| Yes
| Yes
| Yes, but optional
|-
! EagerLoading 
| Supported by scanning the SQL fragments
| Supported using eager (preloading) and eager_graph (joins)
| Supported
|-
! Flexible Overriding 
| No. Overriding is done using alias methods.
| Using methods and by calling 'super'
| Using methods (verify)
|-
! Dynamic Finders 
| Yes. Uses 'Method Missing'
| No. Alternative is to use <Model>.FindOrCreate(:name=>"John")
| Yes. Using the dm_ar_finders plugin
|}

 

=Further Reading=
To get more information on ORM and the different type of ORM's available for Ruby , please look into the [http://pg-server.csc.ncsu.edu/mediawiki/index.php/CSC/ECE_517_Fall_2007/wiki2_2_22, Object-relational mapping Fall 2007] wiki.

=Future Work=
More work can be done in the area of comparison between the different ORMs available for Ruby, especially a performance comparison between the ORM's. We came across one cool website which has the ORM comparison for .Net [http://ormbattle.net/ ORMBattle.Net]. Something similar would be really helpful. Due to the time contraint and lack of indepth knowledge we were not able to work on these areas.
=References=

# [http://en.wikipedia.org/wiki/Object-relational_mapping Wikipedia, Object-relational mapping (ORM)]
# [http://ar.rubyonrails.org/ ActiveRecord]
# [http://en.wikipedia.org/wiki/Active_record_pattern Wikipedia Active record pattern]
# [http://sequel.rubyforge.org/ Sequel]
# [http://jeremyevans-pres.heroku.com/mwrc2009_presentation.html Sequel Presentation - By Jeremy Evans]
# [http://merbist.com/2008/09/29/write-your-own-custom-datamapper-adapter/ Merbist blog on custom DM adapters - By Matt Aimonetti]
# [http://en.wikipedia.org/wiki/Datamapper DataMapper]
# [http://pg-server.csc.ncsu.edu/mediawiki/index.php/CSC/ECE_517_Fall_2007/wiki2_2_22 Object-Relational Mapping Fall 2007]
# [http://ormbattle.net/ ORMBattle.Net]

CSC/ECE 517 Fall 2010/ch3 3j KS

2010-10-15T04:06:03Z

Kschidam: /* References */

='''Object-relational Mapping for Ruby'''=

__TOC__

=Introduction=

[http://en.wikipedia.org/wiki/Object-relational_mapping Object-relational mapping (ORM)] provides developers with a set of tools that ease management of the relationships between objects and relational databases, thus allowing applications to be easily extended to add data persistence. For Ruby, several object-relational mapping options are available. This wiki concentrates more on the comparison of ORM's and it gives a very high level overview of the various ORM's such as ActiveRecord , Sequel and DataMapper.

=Overview=

Object-relational Mapping (ORM) frameworks unburden the designer of the complex translation between database and object space.

Typical ORM features:
* Automatic mapping from classes to database tables
** Class instance variables to database columns
** Class instances to table rows
* Aggregation and association relationships between mapped classes are managed
** Example, :has_many, :belongs_to associations in ActiveRecord
** Inheritance cases are mapped to tables
* Validation of data prior to table storage
* Class extensions to enable search, as well as creation, read, update, and deletion (CRUD) of instances/records
* Usually abstracts the database from program space in such a way that alternate database types can be easily chosen (SQLite, Oracle, etc)

The diagram below depicts a simple mapping of an object to a database table….

[[Image:3j_ks_pic1.jpg]]

When applied to Ruby, implementations of ORM often leverage the language’s [http://en.wikipedia.org/wiki/Metaprogramming metaprogramming] strengths to create intuitive application-specific methods and otherwise extend classes to support database functionality.

=ActiveRecord=

[http://ar.rubyonrails.org/ ActiveRecord], originally created by David Heinemeier and released in 2003, became the de-facto ORM for Ruby since it was integrated in the widely-used Rails framework, however alternate ORMs for Ruby have been developed and Rails 3.x is ORM independent. ActiveRecord is an implementation of the active record design pattern, where a table is wrapped into a class and this class implements accessor methods for each column in the table.

To create a table, ActiveRecord makes use of a migration class rather than including table definition in the actual class being modeled. As an example, the following code creates a table ‘’users’’ to store a collection of class ‘’User’’ objects:
<pre>
class CreateUsers < ActiveRecord::Migration
def self.up
create_table :users do |t|
t.string :name
t.string :email
t.string :age

t.timestamps # add creation and modification timestamps
end
end

def self.down # undo the table creation
drop_table :users
end
end
</pre>

Note in the preceeding example, that the ActiveRecord’s migration scheme provides a means for backing out changes via the ‘’self.down’’ method. In addition, a table key ‘’id’’ is added to the new table without explicit definition and record creation and modification timestamps are included via the ‘’timestamps’’ method provided by ActiveRecord.

ActiveRecord manages associations between table elements and provides the means to define such associations in the model definition. For example, the ‘’User’’ class shown below defines a ‘’to_many’’ association with both the cheers and posts tables. Also note ActiveRecord’s integrated support for validation of table information when attempting an update.

<pre>
class User < ActiveRecord::Base
has_many :cheers
has_many :posts

validates_presence_of :name
validates_presence_of :age
validates_uniqueness_of :name
validates_length_of :name, :within => 3..20
end
</pre>

While ActiveRecord provides the flexibility to create more sophisticated table relationships to represent class hierarchy, its base scheme is a single table inheritance, which trades some storage efficiency for simplicity in the database design. The following figure illustrates this concept of simplicity over efficiency.

[[Image:3j_ks_pic2.jpg]]

'''Pros''' -
* Integrated with popular Rails development framework
* Dynamically created database search methods (eg: User.find_by_address) ease db queries and make queries database syntax independent
* DB creation/management using the migrate scheme provides a means for backing out unwanted table changes
'''Cons''' -
* DB creation/management is decoupled from the model, requiring a separate utility (rake/migrate) that must be kept in sync with application

=Sequel=

[http://sequel.rubyforge.org Sequel] was originally developed by Sharon Rosner and the first release was in March 2007. It is based on the active record pattern. Sequel and Active record share a lot of common features , for example association and inheritance. But Sequel handles these features in a much more flexible manner. Currently Sequel is at version 3.16.0. Initially Sequel was had three core modules - sequel, sequel_core and sequel_model.Starting from version 1.4 , sequel and sequel_model were merged. Sequel handles validations using a validation plug-in and helpers.

<pre>
class CreateUser < Sequel::Migration
def up
create_table(:user) {
primary_key :id
String :name
String :age
String :email}
end
def down
drop_table(:user)
end
end # CreateUser.apply(DB, :up)
</pre>

Sequel supports associations and validations similar to ActiveRecord. The following example shows how validations and associations can be enforced int he User table that has been created above. It enforces one to many relationship between the user table and the cheers , posts tables. It also validates for the presence , uniqueness and the length of the attribute '''name'''.

<pre>
class User < Sequel::Model
one_to_many :cheers
one_to_many :posts

validates_presence [:name, :age]
validates_unique(:name)
validates_length_range 3..20, :name
end
</pre>

Some of the key features of sequel are,
* Connection Pooling
* Thread Safety
* Eager Loading / Lazy Loading
* Model Caching

=DataMapper=

[http://datamapper.org/ DataMapper] is an open source ORM for Ruby originally developed by Sam Smoot and first released in 2007. DataMapper provides a very flexible mapping API which allows creation of adapters to a wide variety of datastores beyond traditional SQL-based relational databases – DataMapper adapters have been created to non-standard sources such as the Salesforce API and even Google Video.

Unlike ActiveRecord and Sequel, DataMapper does not rely on a migration scheme to create and manage DB tables. Instead, DataMapper allows table definition as part of the model class definition which keeps the model definition contained to a single file, thus minimizing the effort required to keep the database and model definitions in sync. When required, DataMapper can also support a migration methodology similar to other ORMs.

Example of table definition in the model:
<pre>
class User
include DataMapper::Resource

property :id, Serial # key
property :name, String, :required => true, :unique => true
property :age, String, :required => true, :length => 3..20
property :email, String

has n, :comments # one to many association
end
</pre>

Notice that in the example above , ":required = true" is an example for Auto Validation. Unlike ActiveRecord and Sequel, DataMapper supports auto validations , i.e. these in turn call the validation helpers to enforce basic validations such as length, uniqueness, format, presence etc.

Some of the key features of DataMapper are:
* API supports a wide variety of databases, including non SQL types
* Thread Safety
* Eager loading of child associations
* Lazy loading

=Comparison of ORM Features=

{|cellspacing="0" border="1"
!style="width:10%"|Features
!style="width:30%"|ActiveRecord
!style="width:30%"|Sequel
!style="width:30%"|DataMapper
|-
! Databases 
| MySQL, PostgreSQL, SQLite, Oracle, SQLServer, and DB2
| ADO, DataObjects, DB2, DBI, Firebird, Informix, JDBC, MySQL, ODBC, OpenBase, Oracle, PostgreSQL and SQLite3
| SQLite, MySQL, PostgreSQL, Oracle, MongoDB, SimpleDB, many others, including CouchDB, Apache Solr, Google Data API
|-
! Migrations 
| Yes
| Yes
| Yes, but optional
|-
! EagerLoading 
| Supported by scanning the SQL fragments
| Supported using eager (preloading) and eager_graph (joins)
| Supported
|-
! Flexible Overriding 
| No. Overriding is done using alias methods.
| Using methods and by calling 'super'
| Using methods (verify)
|-
! Dynamic Finders 
| Yes. Uses 'Method Missing'
| No. Alternative is to use <Model>.FindOrCreate(:name=>"John")
| Yes. Using the dm_ar_finders plugin
|}

 

=Further Reading=
To get more information on ORM and the different type of ORM's available for Ruby , please look into the [http://pg-server.csc.ncsu.edu/mediawiki/index.php/CSC/ECE_517_Fall_2007/wiki2_2_22, Object-relational mapping Fall 2007] wiki.

=Future Work=
More work can be done in the area of comparison between the different ORMs available for Ruby, especially a performance comparison between the ORM's. We came across one cool website which has the ORM comparison for .Net [http://ormbattle.net/ ORMBattle.Net]. Something similar would be really helpful. Due to the time contraint and lack of indepth knowledge we were not able to work on these areas.
=References=

# [http://en.wikipedia.org/wiki/Object-relational_mapping Wikipedia, Object-relational mapping (ORM)]
# [http://ar.rubyonrails.org/ ActiveRecord]
# [http://en.wikipedia.org/wiki/Active_record_pattern Wikipedia Active record pattern]
# [http://sequel.rubyforge.org/ Sequel]
# [http://jeremyevans-pres.heroku.com/mwrc2009_presentation.html Sequel Presentation - By Jeremy Evans]
# [http://merbist.com/2008/09/29/write-your-own-custom-datamapper-adapter/ Merbist blog on custom DM adapters - By Matt Aimonetti]
# [http://en.wikipedia.org/wiki/Datamapper DataMapper]
# [http://pg-server.csc.ncsu.edu/mediawiki/index.php/CSC/ECE_517_Fall_2007/wiki2_2_22 Object-Relational Mapping Fall 2007]
# [http://ormbattle.net/ ORMBattle.Net]

CSC/ECE 517 Fall 2010/ch3 3j KS

2010-10-15T04:05:37Z

Kschidam:

='''Object-relational Mapping for Ruby'''=

__TOC__

=Introduction=

[http://en.wikipedia.org/wiki/Object-relational_mapping Object-relational mapping (ORM)] provides developers with a set of tools that ease management of the relationships between objects and relational databases, thus allowing applications to be easily extended to add data persistence. For Ruby, several object-relational mapping options are available. This wiki concentrates more on the comparison of ORM's and it gives a very high level overview of the various ORM's such as ActiveRecord , Sequel and DataMapper.

=Overview=

Object-relational Mapping (ORM) frameworks unburden the designer of the complex translation between database and object space.

Typical ORM features:
* Automatic mapping from classes to database tables
** Class instance variables to database columns
** Class instances to table rows
* Aggregation and association relationships between mapped classes are managed
** Example, :has_many, :belongs_to associations in ActiveRecord
** Inheritance cases are mapped to tables
* Validation of data prior to table storage
* Class extensions to enable search, as well as creation, read, update, and deletion (CRUD) of instances/records
* Usually abstracts the database from program space in such a way that alternate database types can be easily chosen (SQLite, Oracle, etc)

The diagram below depicts a simple mapping of an object to a database table….

[[Image:3j_ks_pic1.jpg]]

When applied to Ruby, implementations of ORM often leverage the language’s [http://en.wikipedia.org/wiki/Metaprogramming metaprogramming] strengths to create intuitive application-specific methods and otherwise extend classes to support database functionality.

=ActiveRecord=

[http://ar.rubyonrails.org/ ActiveRecord], originally created by David Heinemeier and released in 2003, became the de-facto ORM for Ruby since it was integrated in the widely-used Rails framework, however alternate ORMs for Ruby have been developed and Rails 3.x is ORM independent. ActiveRecord is an implementation of the active record design pattern, where a table is wrapped into a class and this class implements accessor methods for each column in the table.

To create a table, ActiveRecord makes use of a migration class rather than including table definition in the actual class being modeled. As an example, the following code creates a table ‘’users’’ to store a collection of class ‘’User’’ objects:
<pre>
class CreateUsers < ActiveRecord::Migration
def self.up
create_table :users do |t|
t.string :name
t.string :email
t.string :age

t.timestamps # add creation and modification timestamps
end
end

def self.down # undo the table creation
drop_table :users
end
end
</pre>

Note in the preceeding example, that the ActiveRecord’s migration scheme provides a means for backing out changes via the ‘’self.down’’ method. In addition, a table key ‘’id’’ is added to the new table without explicit definition and record creation and modification timestamps are included via the ‘’timestamps’’ method provided by ActiveRecord.

ActiveRecord manages associations between table elements and provides the means to define such associations in the model definition. For example, the ‘’User’’ class shown below defines a ‘’to_many’’ association with both the cheers and posts tables. Also note ActiveRecord’s integrated support for validation of table information when attempting an update.

<pre>
class User < ActiveRecord::Base
has_many :cheers
has_many :posts

validates_presence_of :name
validates_presence_of :age
validates_uniqueness_of :name
validates_length_of :name, :within => 3..20
end
</pre>

While ActiveRecord provides the flexibility to create more sophisticated table relationships to represent class hierarchy, its base scheme is a single table inheritance, which trades some storage efficiency for simplicity in the database design. The following figure illustrates this concept of simplicity over efficiency.

[[Image:3j_ks_pic2.jpg]]

'''Pros''' -
* Integrated with popular Rails development framework
* Dynamically created database search methods (eg: User.find_by_address) ease db queries and make queries database syntax independent
* DB creation/management using the migrate scheme provides a means for backing out unwanted table changes
'''Cons''' -
* DB creation/management is decoupled from the model, requiring a separate utility (rake/migrate) that must be kept in sync with application

=Sequel=

[http://sequel.rubyforge.org Sequel] was originally developed by Sharon Rosner and the first release was in March 2007. It is based on the active record pattern. Sequel and Active record share a lot of common features , for example association and inheritance. But Sequel handles these features in a much more flexible manner. Currently Sequel is at version 3.16.0. Initially Sequel was had three core modules - sequel, sequel_core and sequel_model.Starting from version 1.4 , sequel and sequel_model were merged. Sequel handles validations using a validation plug-in and helpers.

<pre>
class CreateUser < Sequel::Migration
def up
create_table(:user) {
primary_key :id
String :name
String :age
String :email}
end
def down
drop_table(:user)
end
end # CreateUser.apply(DB, :up)
</pre>

Sequel supports associations and validations similar to ActiveRecord. The following example shows how validations and associations can be enforced int he User table that has been created above. It enforces one to many relationship between the user table and the cheers , posts tables. It also validates for the presence , uniqueness and the length of the attribute '''name'''.

<pre>
class User < Sequel::Model
one_to_many :cheers
one_to_many :posts

validates_presence [:name, :age]
validates_unique(:name)
validates_length_range 3..20, :name
end
</pre>

Some of the key features of sequel are,
* Connection Pooling
* Thread Safety
* Eager Loading / Lazy Loading
* Model Caching

=DataMapper=

[http://datamapper.org/ DataMapper] is an open source ORM for Ruby originally developed by Sam Smoot and first released in 2007. DataMapper provides a very flexible mapping API which allows creation of adapters to a wide variety of datastores beyond traditional SQL-based relational databases – DataMapper adapters have been created to non-standard sources such as the Salesforce API and even Google Video.

Unlike ActiveRecord and Sequel, DataMapper does not rely on a migration scheme to create and manage DB tables. Instead, DataMapper allows table definition as part of the model class definition which keeps the model definition contained to a single file, thus minimizing the effort required to keep the database and model definitions in sync. When required, DataMapper can also support a migration methodology similar to other ORMs.

Example of table definition in the model:
<pre>
class User
include DataMapper::Resource

property :id, Serial # key
property :name, String, :required => true, :unique => true
property :age, String, :required => true, :length => 3..20
property :email, String

has n, :comments # one to many association
end
</pre>

Notice that in the example above , ":required = true" is an example for Auto Validation. Unlike ActiveRecord and Sequel, DataMapper supports auto validations , i.e. these in turn call the validation helpers to enforce basic validations such as length, uniqueness, format, presence etc.

Some of the key features of DataMapper are:
* API supports a wide variety of databases, including non SQL types
* Thread Safety
* Eager loading of child associations
* Lazy loading

=Comparison of ORM Features=

{|cellspacing="0" border="1"
!style="width:10%"|Features
!style="width:30%"|ActiveRecord
!style="width:30%"|Sequel
!style="width:30%"|DataMapper
|-
! Databases 
| MySQL, PostgreSQL, SQLite, Oracle, SQLServer, and DB2
| ADO, DataObjects, DB2, DBI, Firebird, Informix, JDBC, MySQL, ODBC, OpenBase, Oracle, PostgreSQL and SQLite3
| SQLite, MySQL, PostgreSQL, Oracle, MongoDB, SimpleDB, many others, including CouchDB, Apache Solr, Google Data API
|-
! Migrations 
| Yes
| Yes
| Yes, but optional
|-
! EagerLoading 
| Supported by scanning the SQL fragments
| Supported using eager (preloading) and eager_graph (joins)
| Supported
|-
! Flexible Overriding 
| No. Overriding is done using alias methods.
| Using methods and by calling 'super'
| Using methods (verify)
|-
! Dynamic Finders 
| Yes. Uses 'Method Missing'
| No. Alternative is to use <Model>.FindOrCreate(:name=>"John")
| Yes. Using the dm_ar_finders plugin
|}

 

=Further Reading=
To get more information on ORM and the different type of ORM's available for Ruby , please look into the [http://pg-server.csc.ncsu.edu/mediawiki/index.php/CSC/ECE_517_Fall_2007/wiki2_2_22, Object-relational mapping Fall 2007] wiki.

=Future Work=
More work can be done in the area of comparison between the different ORMs available for Ruby, especially a performance comparison between the ORM's. We came across one cool website which has the ORM comparison for .Net [http://ormbattle.net/ ORMBattle.Net]. Something similar would be really helpful. Due to the time contraint and lack of indepth knowledge we were not able to work on these areas.
=References=

# [http://en.wikipedia.org/wiki/Object-relational_mapping Wikipedia, Object-relational mapping (ORM)]
# [http://ar.rubyonrails.org/ ActiveRecord]
# [http://en.wikipedia.org/wiki/Active_record_pattern Wikipedia Active record pattern]
# [http://sequel.rubyforge.org/ Sequel]
# [http://jeremyevans-pres.heroku.com/mwrc2009_presentation.html Sequel Presentation - By Jeremy Evans]
# [http://merbist.com/2008/09/29/write-your-own-custom-datamapper-adapter/ Merbist blog on custom DM adapters - By Matt Aimonetti]
# [http://en.wikipedia.org/wiki/Datamapper DataMapper]
# [http://pg-server.csc.ncsu.edu/mediawiki/index.php/CSC/ECE_517_Fall_2007/wiki2_2_22 Object-Relational Mapping Fall 2007]

CSC/ECE 517 Fall 2010/ch3 3j KS

2010-10-15T03:51:49Z

Kschidam: /* DataMapper */

='''Object-relational Mapping for Ruby'''=

__TOC__

=Introduction=

[http://en.wikipedia.org/wiki/Object-relational_mapping Object-relational mapping (ORM)] provides developers with a set of tools that ease management of the relationships between objects and relational databases, thus allowing applications to be easily extended to add data persistence. For Ruby, several object-relational mapping options are available. This wiki concentrates more on the comparison of ORM's and it gives a very high level overview of the various ORM's such as ActiveRecord , Sequel and DataMapper.

=Overview=

Object-relational Mapping (ORM) frameworks unburden the designer of the complex translation between database and object space.

Typical ORM features:
* Automatic mapping from classes to database tables
** Class instance variables to database columns
** Class instances to table rows
* Aggregation and association relationships between mapped classes are managed
** Example, :has_many, :belongs_to associations in ActiveRecord
** Inheritance cases are mapped to tables
* Validation of data prior to table storage
* Class extensions to enable search, as well as creation, read, update, and deletion (CRUD) of instances/records
* Usually abstracts the database from program space in such a way that alternate database types can be easily chosen (SQLite, Oracle, etc)

The diagram below depicts a simple mapping of an object to a database table….

[[Image:3j_ks_pic1.jpg]]

When applied to Ruby, implementations of ORM often leverage the language’s [http://en.wikipedia.org/wiki/Metaprogramming metaprogramming] strengths to create intuitive application-specific methods and otherwise extend classes to support database functionality.

=ActiveRecord=

[http://ar.rubyonrails.org/ ActiveRecord], originally created by David Heinemeier and released in 2003, became the de-facto ORM for Ruby since it was integrated in the widely-used Rails framework, however alternate ORMs for Ruby have been developed and Rails 3.x is ORM independent. ActiveRecord is an implementation of the active record design pattern, where a table is wrapped into a class and this class implements accessor methods for each column in the table.

To create a table, ActiveRecord makes use of a migration class rather than including table definition in the actual class being modeled. As an example, the following code creates a table ‘’users’’ to store a collection of class ‘’User’’ objects:
<pre>
class CreateUsers < ActiveRecord::Migration
def self.up
create_table :users do |t|
t.string :name
t.string :email
t.string :age

t.timestamps # add creation and modification timestamps
end
end

def self.down # undo the table creation
drop_table :users
end
end
</pre>

Note in the preceeding example, that the ActiveRecord’s migration scheme provides a means for backing out changes via the ‘’self.down’’ method. In addition, a table key ‘’id’’ is added to the new table without explicit definition and record creation and modification timestamps are included via the ‘’timestamps’’ method provided by ActiveRecord.

ActiveRecord manages associations between table elements and provides the means to define such associations in the model definition. For example, the ‘’User’’ class shown below defines a ‘’to_many’’ association with both the cheers and posts tables. Also note ActiveRecord’s integrated support for validation of table information when attempting an update.

<pre>
class User < ActiveRecord::Base
has_many :cheers
has_many :posts

validates_presence_of :name
validates_presence_of :age
validates_uniqueness_of :name
validates_length_of :name, :within => 3..20
end
</pre>

While ActiveRecord provides the flexibility to create more sophisticated table relationships to represent class hierarchy, its base scheme is a single table inheritance, which trades some storage efficiency for simplicity in the database design. The following figure illustrates this concept of simplicity over efficiency.

[[Image:3j_ks_pic2.jpg]]

'''Pros''' -
* Integrated with popular Rails development framework
* Dynamically created database search methods (eg: User.find_by_address) ease db queries and make queries database syntax independent
* DB creation/management using the migrate scheme provides a means for backing out unwanted table changes
'''Cons''' -
* DB creation/management is decoupled from the model, requiring a separate utility (rake/migrate) that must be kept in sync with application

=Sequel=

[http://sequel.rubyforge.org Sequel] was originally developed by Sharon Rosner and the first release was in March 2007. It is based on the active record pattern. Sequel and Active record share a lot of common features , for example association and inheritance. But Sequel handles these features in a much more flexible manner. Currently Sequel is at version 3.16.0. Initially Sequel was had three core modules - sequel, sequel_core and sequel_model.Starting from version 1.4 , sequel and sequel_model were merged. Sequel handles validations using a validation plug-in and helpers.

<pre>
class CreateUser < Sequel::Migration
def up
create_table(:user) {
primary_key :id
String :name
String :age
String :email}
end
def down
drop_table(:user)
end
end # CreateUser.apply(DB, :up)
</pre>

Sequel supports associations and validations similar to ActiveRecord. The following example shows how validations and associations can be enforced int he User table that has been created above. It enforces one to many relationship between the user table and the cheers , posts tables. It also validates for the presence , uniqueness and the length of the attribute '''name'''.

<pre>
class User < Sequel::Model
one_to_many :cheers
one_to_many :posts

validates_presence [:name, :age]
validates_unique(:name)
validates_length_range 3..20, :name
end
</pre>

Some of the key features of sequel are,
* Connection Pooling
* Thread Safety
* Eager Loading / Lazy Loading
* Model Caching

=DataMapper=

[http://datamapper.org/ DataMapper] is an open source ORM for Ruby originally developed by Sam Smoot and first released in 2007. DataMapper provides a very flexible mapping API which allows creation of adapters to a wide variety of datastores beyond traditional SQL-based relational databases – DataMapper adapters have been created to non-standard sources such as the Salesforce API and even Google Video.

Unlike ActiveRecord and Sequel, DataMapper does not rely on a migration scheme to create and manage DB tables. Instead, DataMapper allows table definition as part of the model class definition which keeps the model definition contained to a single file, thus minimizing the effort required to keep the database and model definitions in sync. When required, DataMapper can also support a migration methodology similar to other ORMs.

Example of table definition in the model:
<pre>
class User
include DataMapper::Resource

property :id, Serial # key
property :name, String, :required => true, :unique => true
property :age, String, :required => true, :length => 3..20
property :email, String

has n, :comments # one to many association
end
</pre>

Notice that in the example above , ":required = true" is an example for Auto Validation. Unlike ActiveRecord and Sequel, DataMapper supports auto validations , i.e. these in turn call the validation helpers to enforce basic validations such as length, uniqueness, format, presence etc.

Some of the key features of DataMapper are:
* API supports a wide variety of databases, including non SQL types
* Thread Safety
* Eager loading of child associations
* Lazy loading

=Comparison of ORM Features=

{|cellspacing="0" border="1"
!style="width:10%"|Features
!style="width:30%"|ActiveRecord
!style="width:30%"|Sequel
!style="width:30%"|DataMapper
|-
! Databases 
| MySQL, PostgreSQL, SQLite, Oracle, SQLServer, and DB2
| ADO, DataObjects, DB2, DBI, Firebird, Informix, JDBC, MySQL, ODBC, OpenBase, Oracle, PostgreSQL and SQLite3
| SQLite, MySQL, PostgreSQL, Oracle, MongoDB, SimpleDB, many others, including CouchDB, Apache Solr, Google Data API
|-
! Migrations 
| Yes
| Yes
| Yes, but optional
|-
! EagerLoading 
| Supported by scanning the SQL fragments
| Supported using eager (preloading) and eager_graph (joins)
| Supported
|-
! Flexible Overriding 
| No. Overriding is done using alias methods.
| Using methods and by calling 'super'
| Using methods (verify)
|-
! Dynamic Finders 
| Yes. Uses 'Method Missing'
| No. Alternative is to use <Model>.FindOrCreate(:name=>"John")
| Yes. Using the dm_ar_finders plugin
|}

 

=Further Reading=
To get more information on ORM and the different type of ORM's available for Ruby , please look into the [http://pg-server.csc.ncsu.edu/mediawiki/index.php/CSC/ECE_517_Fall_2007/wiki2_2_22, Object-relational mapping Fall 2007] wiki.

=References=

# [http://en.wikipedia.org/wiki/Object-relational_mapping Wikipedia, Object-relational mapping (ORM)]
# [http://ar.rubyonrails.org/ ActiveRecord]
# [http://en.wikipedia.org/wiki/Active_record_pattern Wikipedia Active record pattern]
# [http://sequel.rubyforge.org/ Sequel]
# [http://jeremyevans-pres.heroku.com/mwrc2009_presentation.html Sequel Presentation - By Jeremy Evans]
# [http://merbist.com/2008/09/29/write-your-own-custom-datamapper-adapter/ Merbist blog on custom DM adapters - By Matt Aimonetti]
# [http://en.wikipedia.org/wiki/Datamapper DataMapper]
# [http://pg-server.csc.ncsu.edu/mediawiki/index.php/CSC/ECE_517_Fall_2007/wiki2_2_22 Object-Relational Mapping Fall 2007]

CSC/ECE 517 Fall 2010/ch3 3j KS

2010-10-15T03:38:11Z

Kschidam: /* DataMapper */

='''Object-relational Mapping for Ruby'''=

__TOC__

=Introduction=

[http://en.wikipedia.org/wiki/Object-relational_mapping Object-relational mapping (ORM)] provides developers with a set of tools that ease management of the relationships between objects and relational databases, thus allowing applications to be easily extended to add data persistence. For Ruby, several object-relational mapping options are available. This wiki concentrates more on the comparison of ORM's and it gives a very high level overview of the various ORM's such as ActiveRecord , Sequel and DataMapper.

=Overview=

Object-relational Mapping (ORM) frameworks unburden the designer of the complex translation between database and object space.

Typical ORM features:
* Automatic mapping from classes to database tables
** Class instance variables to database columns
** Class instances to table rows
* Aggregation and association relationships between mapped classes are managed
** Example, :has_many, :belongs_to associations in ActiveRecord
** Inheritance cases are mapped to tables
* Validation of data prior to table storage
* Class extensions to enable search, as well as creation, read, update, and deletion (CRUD) of instances/records
* Usually abstracts the database from program space in such a way that alternate database types can be easily chosen (SQLite, Oracle, etc)

The diagram below depicts a simple mapping of an object to a database table….

[[Image:3j_ks_pic1.jpg]]

When applied to Ruby, implementations of ORM often leverage the language’s [http://en.wikipedia.org/wiki/Metaprogramming metaprogramming] strengths to create intuitive application-specific methods and otherwise extend classes to support database functionality.

=ActiveRecord=

[http://ar.rubyonrails.org/ ActiveRecord], originally created by David Heinemeier and released in 2003, became the de-facto ORM for Ruby since it was integrated in the widely-used Rails framework, however alternate ORMs for Ruby have been developed and Rails 3.x is ORM independent. ActiveRecord is an implementation of the active record design pattern, where a table is wrapped into a class and this class implements accessor methods for each column in the table.

To create a table, ActiveRecord makes use of a migration class rather than including table definition in the actual class being modeled. As an example, the following code creates a table ‘’users’’ to store a collection of class ‘’User’’ objects:
<pre>
class CreateUsers < ActiveRecord::Migration
def self.up
create_table :users do |t|
t.string :name
t.string :email
t.string :age

t.timestamps # add creation and modification timestamps
end
end

def self.down # undo the table creation
drop_table :users
end
end
</pre>

Note in the preceeding example, that the ActiveRecord’s migration scheme provides a means for backing out changes via the ‘’self.down’’ method. In addition, a table key ‘’id’’ is added to the new table without explicit definition and record creation and modification timestamps are included via the ‘’timestamps’’ method provided by ActiveRecord.

ActiveRecord manages associations between table elements and provides the means to define such associations in the model definition. For example, the ‘’User’’ class shown below defines a ‘’to_many’’ association with both the cheers and posts tables. Also note ActiveRecord’s integrated support for validation of table information when attempting an update.

<pre>
class User < ActiveRecord::Base
has_many :cheers
has_many :posts

validates_presence_of :name
validates_presence_of :age
validates_uniqueness_of :name
validates_length_of :name, :within => 3..20
end
</pre>

While ActiveRecord provides the flexibility to create more sophisticated table relationships to represent class hierarchy, its base scheme is a single table inheritance, which trades some storage efficiency for simplicity in the database design. The following figure illustrates this concept of simplicity over efficiency.

[[Image:3j_ks_pic2.jpg]]

'''Pros''' -
* Integrated with popular Rails development framework
* Dynamically created database search methods (eg: User.find_by_address) ease db queries and make queries database syntax independent
* DB creation/management using the migrate scheme provides a means for backing out unwanted table changes
'''Cons''' -
* DB creation/management is decoupled from the model, requiring a separate utility (rake/migrate) that must be kept in sync with application

=Sequel=

[http://sequel.rubyforge.org Sequel] was originally developed by Sharon Rosner and the first release was in March 2007. It is based on the active record pattern. Sequel and Active record share a lot of common features , for example association and inheritance. But Sequel handles these features in a much more flexible manner. Currently Sequel is at version 3.16.0. Initially Sequel was had three core modules - sequel, sequel_core and sequel_model.Starting from version 1.4 , sequel and sequel_model were merged. Sequel handles validations using a validation plug-in and helpers.

<pre>
class CreateUser < Sequel::Migration
def up
create_table(:user) {
primary_key :id
String :name
String :age
String :email}
end
def down
drop_table(:user)
end
end # CreateUser.apply(DB, :up)
</pre>

Sequel supports associations and validations similar to ActiveRecord. The following example shows how validations and associations can be enforced int he User table that has been created above. It enforces one to many relationship between the user table and the cheers , posts tables. It also validates for the presence , uniqueness and the length of the attribute '''name'''.

<pre>
class User < Sequel::Model
one_to_many :cheers
one_to_many :posts

validates_presence [:name, :age]
validates_unique(:name)
validates_length_range 3..20, :name
end
</pre>

Some of the key features of sequel are,
* Connection Pooling
* Thread Safety
* Eager Loading / Lazy Loading
* Model Caching

=DataMapper=

[http://datamapper.org/ DataMapper] is an open source ORM for Ruby originally developed by Sam Smoot and first released in 2007. DataMapper provides a very flexible mapping API which allows creation of adapters to a wide variety of datastores beyond traditional SQL-based relational databases – DataMapper adapters have been created to non-standard sources such as the Salesforce API and even Google Video.

Some of the key features of DataMapper are:
* API supports a wide variety of databases, including non SQL types
* Thread Safety
* Eager loading of child associations
* Lazy loading

Unlike ActiveRecord and Sequel, DataMapper does not rely on a migration scheme to create and manage DB tables. Instead, DataMapper allows table definition as part of the model class definition which keeps the model definition contained to a single file, thus minimizing the effort required to keep the database and model definitions in sync. When required, DataMapper can also support a migration methodology similar to other ORMs.

Example of table definition in the model:
<pre>
class User
include DataMapper::Resource

property :id, Serial # key
property :name, String, :required => true, :unique => true
property :age, String, :required => true, :length => 3..20
property :email, String

has n, :comments # one to many association
end
</pre>

Notice that in the example above , ":required = true" is an example for Auto Validation. Unlike ActiveRecord and Sequel, DataMapper supports auto validations , i.e. these in turn call the validation helpers to enforce basic validations such as length, uniqueness, format, presence etc.

=Comparison of ORM Features=

{|cellspacing="0" border="1"
!style="width:10%"|Features
!style="width:30%"|ActiveRecord
!style="width:30%"|Sequel
!style="width:30%"|DataMapper
|-
! Databases 
| MySQL, PostgreSQL, SQLite, Oracle, SQLServer, and DB2
| ADO, DataObjects, DB2, DBI, Firebird, Informix, JDBC, MySQL, ODBC, OpenBase, Oracle, PostgreSQL and SQLite3
| SQLite, MySQL, PostgreSQL, Oracle, MongoDB, SimpleDB, many others, including CouchDB, Apache Solr, Google Data API
|-
! Migrations 
| Yes
| Yes
| Yes, but optional
|-
! EagerLoading 
| Supported by scanning the SQL fragments
| Supported using eager (preloading) and eager_graph (joins)
| Supported
|-
! Flexible Overriding 
| No. Overriding is done using alias methods.
| Using methods and by calling 'super'
| Using methods (verify)
|-
! Dynamic Finders 
| Yes. Uses 'Method Missing'
| No. Alternative is to use <Model>.FindOrCreate(:name=>"John")
| Yes. Using the dm_ar_finders plugin
|}

 

=Further Reading=
To get more information on ORM and the different type of ORM's available for Ruby , please look into the [http://pg-server.csc.ncsu.edu/mediawiki/index.php/CSC/ECE_517_Fall_2007/wiki2_2_22, Object-relational mapping Fall 2007] wiki.

=References=

# [http://en.wikipedia.org/wiki/Object-relational_mapping Wikipedia, Object-relational mapping (ORM)]
# [http://ar.rubyonrails.org/ ActiveRecord]
# [http://en.wikipedia.org/wiki/Active_record_pattern Wikipedia Active record pattern]
# [http://sequel.rubyforge.org/ Sequel]
# [http://jeremyevans-pres.heroku.com/mwrc2009_presentation.html Sequel Presentation - By Jeremy Evans]
# [http://merbist.com/2008/09/29/write-your-own-custom-datamapper-adapter/ Merbist blog on custom DM adapters - By Matt Aimonetti]
# [http://en.wikipedia.org/wiki/Datamapper DataMapper]
# [http://pg-server.csc.ncsu.edu/mediawiki/index.php/CSC/ECE_517_Fall_2007/wiki2_2_22 Object-Relational Mapping Fall 2007]

CSC/ECE 517 Fall 2010/ch3 3j KS

2010-10-15T03:36:48Z

Kschidam: /* DataMapper */

='''Object-relational Mapping for Ruby'''=

__TOC__

=Introduction=

[http://en.wikipedia.org/wiki/Object-relational_mapping Object-relational mapping (ORM)] provides developers with a set of tools that ease management of the relationships between objects and relational databases, thus allowing applications to be easily extended to add data persistence. For Ruby, several object-relational mapping options are available. This wiki concentrates more on the comparison of ORM's and it gives a very high level overview of the various ORM's such as ActiveRecord , Sequel and DataMapper.

=Overview=

Object-relational Mapping (ORM) frameworks unburden the designer of the complex translation between database and object space.

Typical ORM features:
* Automatic mapping from classes to database tables
** Class instance variables to database columns
** Class instances to table rows
* Aggregation and association relationships between mapped classes are managed
** Example, :has_many, :belongs_to associations in ActiveRecord
** Inheritance cases are mapped to tables
* Validation of data prior to table storage
* Class extensions to enable search, as well as creation, read, update, and deletion (CRUD) of instances/records
* Usually abstracts the database from program space in such a way that alternate database types can be easily chosen (SQLite, Oracle, etc)

The diagram below depicts a simple mapping of an object to a database table….

[[Image:3j_ks_pic1.jpg]]

When applied to Ruby, implementations of ORM often leverage the language’s [http://en.wikipedia.org/wiki/Metaprogramming metaprogramming] strengths to create intuitive application-specific methods and otherwise extend classes to support database functionality.

=ActiveRecord=

[http://ar.rubyonrails.org/ ActiveRecord], originally created by David Heinemeier and released in 2003, became the de-facto ORM for Ruby since it was integrated in the widely-used Rails framework, however alternate ORMs for Ruby have been developed and Rails 3.x is ORM independent. ActiveRecord is an implementation of the active record design pattern, where a table is wrapped into a class and this class implements accessor methods for each column in the table.

To create a table, ActiveRecord makes use of a migration class rather than including table definition in the actual class being modeled. As an example, the following code creates a table ‘’users’’ to store a collection of class ‘’User’’ objects:
<pre>
class CreateUsers < ActiveRecord::Migration
def self.up
create_table :users do |t|
t.string :name
t.string :email
t.string :age

t.timestamps # add creation and modification timestamps
end
end

def self.down # undo the table creation
drop_table :users
end
end
</pre>

Note in the preceeding example, that the ActiveRecord’s migration scheme provides a means for backing out changes via the ‘’self.down’’ method. In addition, a table key ‘’id’’ is added to the new table without explicit definition and record creation and modification timestamps are included via the ‘’timestamps’’ method provided by ActiveRecord.

ActiveRecord manages associations between table elements and provides the means to define such associations in the model definition. For example, the ‘’User’’ class shown below defines a ‘’to_many’’ association with both the cheers and posts tables. Also note ActiveRecord’s integrated support for validation of table information when attempting an update.

<pre>
class User < ActiveRecord::Base
has_many :cheers
has_many :posts

validates_presence_of :name
validates_presence_of :age
validates_uniqueness_of :name
validates_length_of :name, :within => 3..20
end
</pre>

While ActiveRecord provides the flexibility to create more sophisticated table relationships to represent class hierarchy, its base scheme is a single table inheritance, which trades some storage efficiency for simplicity in the database design. The following figure illustrates this concept of simplicity over efficiency.

[[Image:3j_ks_pic2.jpg]]

'''Pros''' -
* Integrated with popular Rails development framework
* Dynamically created database search methods (eg: User.find_by_address) ease db queries and make queries database syntax independent
* DB creation/management using the migrate scheme provides a means for backing out unwanted table changes
'''Cons''' -
* DB creation/management is decoupled from the model, requiring a separate utility (rake/migrate) that must be kept in sync with application

=Sequel=

[http://sequel.rubyforge.org Sequel] was originally developed by Sharon Rosner and the first release was in March 2007. It is based on the active record pattern. Sequel and Active record share a lot of common features , for example association and inheritance. But Sequel handles these features in a much more flexible manner. Currently Sequel is at version 3.16.0. Initially Sequel was had three core modules - sequel, sequel_core and sequel_model.Starting from version 1.4 , sequel and sequel_model were merged. Sequel handles validations using a validation plug-in and helpers.

<pre>
class CreateUser < Sequel::Migration
def up
create_table(:user) {
primary_key :id
String :name
String :age
String :email}
end
def down
drop_table(:user)
end
end # CreateUser.apply(DB, :up)
</pre>

Sequel supports associations and validations similar to ActiveRecord. The following example shows how validations and associations can be enforced int he User table that has been created above. It enforces one to many relationship between the user table and the cheers , posts tables. It also validates for the presence , uniqueness and the length of the attribute '''name'''.

<pre>
class User < Sequel::Model
one_to_many :cheers
one_to_many :posts

validates_presence [:name, :age]
validates_unique(:name)
validates_length_range 3..20, :name
end
</pre>

Some of the key features of sequel are,
* Connection Pooling
* Thread Safety
* Eager Loading / Lazy Loading
* Model Caching

=DataMapper=

[http://datamapper.org/ DataMapper] is an open source ORM for Ruby originally developed by Sam Smoot and first released in 2007. DataMapper provides a very flexible mapping API which allows creation of adapters to a wide variety of datastores beyond traditional SQL-based relational databases – DataMapper adapters have been created to non-standard sources such as the Salesforce API and even Google Video.

Some of the key features of DataMapper are:
* API supports a wide variety of databases, including non SQL types
* Thread Safety
* Eager loading of child associations
* Lazy loading

Unlike ActiveRecord and Sequel, DataMapper does not rely on a migration scheme to create and manage DB tables. Instead, DataMapper allows table definition as part of the model class definition which keeps the model definition contained to a single file, thus minimizing the effort required to keep the database and model definitions in sync. When required, DataMapper can also support a migration methodology similar to other ORMs.

Example of table definition in the model:
<pre>
class User
include DataMapper::Resource

property :id, Serial # key
property :name, String, :required => true, :unique => true
property :age, String, :required => true
property :email, String

has n, :comments # one to many association
end
</pre>

Notice that in the example above , ":required = true" is an example for Auto Validation. Unlike ActiveRecord and Sequel, DataMapper supports auto validations , i.e. these in turn call the validation helpers to enforce basic validations such as length, uniqueness, format, presence etc.

=Comparison of ORM Features=

{|cellspacing="0" border="1"
!style="width:10%"|Features
!style="width:30%"|ActiveRecord
!style="width:30%"|Sequel
!style="width:30%"|DataMapper
|-
! Databases 
| MySQL, PostgreSQL, SQLite, Oracle, SQLServer, and DB2
| ADO, DataObjects, DB2, DBI, Firebird, Informix, JDBC, MySQL, ODBC, OpenBase, Oracle, PostgreSQL and SQLite3
| SQLite, MySQL, PostgreSQL, Oracle, MongoDB, SimpleDB, many others, including CouchDB, Apache Solr, Google Data API
|-
! Migrations 
| Yes
| Yes
| Yes, but optional
|-
! EagerLoading 
| Supported by scanning the SQL fragments
| Supported using eager (preloading) and eager_graph (joins)
| Supported
|-
! Flexible Overriding 
| No. Overriding is done using alias methods.
| Using methods and by calling 'super'
| Using methods (verify)
|-
! Dynamic Finders 
| Yes. Uses 'Method Missing'
| No. Alternative is to use <Model>.FindOrCreate(:name=>"John")
| Yes. Using the dm_ar_finders plugin
|}

 

=Further Reading=
To get more information on ORM and the different type of ORM's available for Ruby , please look into the [http://pg-server.csc.ncsu.edu/mediawiki/index.php/CSC/ECE_517_Fall_2007/wiki2_2_22, Object-relational mapping Fall 2007] wiki.

=References=

# [http://en.wikipedia.org/wiki/Object-relational_mapping Wikipedia, Object-relational mapping (ORM)]
# [http://ar.rubyonrails.org/ ActiveRecord]
# [http://en.wikipedia.org/wiki/Active_record_pattern Wikipedia Active record pattern]
# [http://sequel.rubyforge.org/ Sequel]
# [http://jeremyevans-pres.heroku.com/mwrc2009_presentation.html Sequel Presentation - By Jeremy Evans]
# [http://merbist.com/2008/09/29/write-your-own-custom-datamapper-adapter/ Merbist blog on custom DM adapters - By Matt Aimonetti]
# [http://en.wikipedia.org/wiki/Datamapper DataMapper]
# [http://pg-server.csc.ncsu.edu/mediawiki/index.php/CSC/ECE_517_Fall_2007/wiki2_2_22 Object-Relational Mapping Fall 2007]

CSC/ECE 517 Fall 2010/ch3 3j KS

2010-10-15T03:29:48Z

Kschidam: /* Sequel */

='''Object-relational Mapping for Ruby'''=

__TOC__

=Introduction=

[http://en.wikipedia.org/wiki/Object-relational_mapping Object-relational mapping (ORM)] provides developers with a set of tools that ease management of the relationships between objects and relational databases, thus allowing applications to be easily extended to add data persistence. For Ruby, several object-relational mapping options are available. This wiki concentrates more on the comparison of ORM's and it gives a very high level overview of the various ORM's such as ActiveRecord , Sequel and DataMapper.

=Overview=

Object-relational Mapping (ORM) frameworks unburden the designer of the complex translation between database and object space.

Typical ORM features:
* Automatic mapping from classes to database tables
** Class instance variables to database columns
** Class instances to table rows
* Aggregation and association relationships between mapped classes are managed
** Example, :has_many, :belongs_to associations in ActiveRecord
** Inheritance cases are mapped to tables
* Validation of data prior to table storage
* Class extensions to enable search, as well as creation, read, update, and deletion (CRUD) of instances/records
* Usually abstracts the database from program space in such a way that alternate database types can be easily chosen (SQLite, Oracle, etc)

The diagram below depicts a simple mapping of an object to a database table….

[[Image:3j_ks_pic1.jpg]]

When applied to Ruby, implementations of ORM often leverage the language’s [http://en.wikipedia.org/wiki/Metaprogramming metaprogramming] strengths to create intuitive application-specific methods and otherwise extend classes to support database functionality.

=ActiveRecord=

[http://ar.rubyonrails.org/ ActiveRecord], originally created by David Heinemeier and released in 2003, became the de-facto ORM for Ruby since it was integrated in the widely-used Rails framework, however alternate ORMs for Ruby have been developed and Rails 3.x is ORM independent. ActiveRecord is an implementation of the active record design pattern, where a table is wrapped into a class and this class implements accessor methods for each column in the table.

To create a table, ActiveRecord makes use of a migration class rather than including table definition in the actual class being modeled. As an example, the following code creates a table ‘’users’’ to store a collection of class ‘’User’’ objects:
<pre>
class CreateUsers < ActiveRecord::Migration
def self.up
create_table :users do |t|
t.string :name
t.string :email
t.string :age

t.timestamps # add creation and modification timestamps
end
end

def self.down # undo the table creation
drop_table :users
end
end
</pre>

Note in the preceeding example, that the ActiveRecord’s migration scheme provides a means for backing out changes via the ‘’self.down’’ method. In addition, a table key ‘’id’’ is added to the new table without explicit definition and record creation and modification timestamps are included via the ‘’timestamps’’ method provided by ActiveRecord.

ActiveRecord manages associations between table elements and provides the means to define such associations in the model definition. For example, the ‘’User’’ class shown below defines a ‘’to_many’’ association with both the cheers and posts tables. Also note ActiveRecord’s integrated support for validation of table information when attempting an update.

<pre>
class User < ActiveRecord::Base
has_many :cheers
has_many :posts

validates_presence_of :name
validates_presence_of :age
validates_uniqueness_of :name
validates_length_of :name, :within => 3..20
end
</pre>

While ActiveRecord provides the flexibility to create more sophisticated table relationships to represent class hierarchy, its base scheme is a single table inheritance, which trades some storage efficiency for simplicity in the database design. The following figure illustrates this concept of simplicity over efficiency.

[[Image:3j_ks_pic2.jpg]]

'''Pros''' -
* Integrated with popular Rails development framework
* Dynamically created database search methods (eg: User.find_by_address) ease db queries and make queries database syntax independent
* DB creation/management using the migrate scheme provides a means for backing out unwanted table changes
'''Cons''' -
* DB creation/management is decoupled from the model, requiring a separate utility (rake/migrate) that must be kept in sync with application

=Sequel=

[http://sequel.rubyforge.org Sequel] was originally developed by Sharon Rosner and the first release was in March 2007. It is based on the active record pattern. Sequel and Active record share a lot of common features , for example association and inheritance. But Sequel handles these features in a much more flexible manner. Currently Sequel is at version 3.16.0. Initially Sequel was had three core modules - sequel, sequel_core and sequel_model.Starting from version 1.4 , sequel and sequel_model were merged. Sequel handles validations using a validation plug-in and helpers.

<pre>
class CreateUser < Sequel::Migration
def up
create_table(:user) {
primary_key :id
String :name
String :age
String :email}
end
def down
drop_table(:user)
end
end # CreateUser.apply(DB, :up)
</pre>

Sequel supports associations and validations similar to ActiveRecord. The following example shows how validations and associations can be enforced int he User table that has been created above. It enforces one to many relationship between the user table and the cheers , posts tables. It also validates for the presence , uniqueness and the length of the attribute '''name'''.

<pre>
class User < Sequel::Model
one_to_many :cheers
one_to_many :posts

validates_presence [:name, :age]
validates_unique(:name)
validates_length_range 3..20, :name
end
</pre>

Some of the key features of sequel are,
* Connection Pooling
* Thread Safety
* Eager Loading / Lazy Loading
* Model Caching

=DataMapper=

[http://datamapper.org/ DataMapper] is an open source ORM for Ruby originally developed by Sam Smoot and first released in 2007. DataMapper provides a very flexible mapping API which allows creation of adapters to a wide variety of datastores beyond traditional SQL-based relational databases – DataMapper adapters have been created to non-standard sources such as the Salesforce API and even Google Video.

Some of the key features of DataMapper are:
* API supports a wide variety of databases, including non SQL types
* Thread Safety
* Eager loading of child associations
* Lazy loading

Unlike ActiveRecord and Sequel, DataMapper does not rely on a migration scheme to create and manage DB tables. Instead, DataMapper allows table definition as part of the model class definition which keeps the model definition contained to a single file, thus minimizing the effort required to keep the database and model definitions in sync. When required, DataMapper can also support a migration methodology similar to other ORMs.

Example of table definition in the model:
<pre>
class User
include DataMapper::Resource

property :id, Serial # key
property :name, String
property :password, String
property :age, String
property :created_at, DateTime

has n, :comments # one to many association
end
</pre>

=Comparison of ORM Features=

{|cellspacing="0" border="1"
!style="width:10%"|Features
!style="width:30%"|ActiveRecord
!style="width:30%"|Sequel
!style="width:30%"|DataMapper
|-
! Databases 
| MySQL, PostgreSQL, SQLite, Oracle, SQLServer, and DB2
| ADO, DataObjects, DB2, DBI, Firebird, Informix, JDBC, MySQL, ODBC, OpenBase, Oracle, PostgreSQL and SQLite3
| SQLite, MySQL, PostgreSQL, Oracle, MongoDB, SimpleDB, many others, including CouchDB, Apache Solr, Google Data API
|-
! Migrations 
| Yes
| Yes
| Yes, but optional
|-
! EagerLoading 
| Supported by scanning the SQL fragments
| Supported using eager (preloading) and eager_graph (joins)
| Supported
|-
! Flexible Overriding 
| No. Overriding is done using alias methods.
| Using methods and by calling 'super'
| Using methods (verify)
|-
! Dynamic Finders 
| Yes. Uses 'Method Missing'
| No. Alternative is to use <Model>.FindOrCreate(:name=>"John")
| Yes. Using the dm_ar_finders plugin
|}

 

=Further Reading=
To get more information on ORM and the different type of ORM's available for Ruby , please look into the [http://pg-server.csc.ncsu.edu/mediawiki/index.php/CSC/ECE_517_Fall_2007/wiki2_2_22, Object-relational mapping Fall 2007] wiki.

=References=

# [http://en.wikipedia.org/wiki/Object-relational_mapping Wikipedia, Object-relational mapping (ORM)]
# [http://ar.rubyonrails.org/ ActiveRecord]
# [http://en.wikipedia.org/wiki/Active_record_pattern Wikipedia Active record pattern]
# [http://sequel.rubyforge.org/ Sequel]
# [http://jeremyevans-pres.heroku.com/mwrc2009_presentation.html Sequel Presentation - By Jeremy Evans]
# [http://merbist.com/2008/09/29/write-your-own-custom-datamapper-adapter/ Merbist blog on custom DM adapters - By Matt Aimonetti]
# [http://en.wikipedia.org/wiki/Datamapper DataMapper]
# [http://pg-server.csc.ncsu.edu/mediawiki/index.php/CSC/ECE_517_Fall_2007/wiki2_2_22 Object-Relational Mapping Fall 2007]

CSC/ECE 517 Fall 2010/ch3 3j KS

2010-10-15T03:26:16Z

Kschidam: /* Sequel */

='''Object-relational Mapping for Ruby'''=

__TOC__

=Introduction=

[http://en.wikipedia.org/wiki/Object-relational_mapping Object-relational mapping (ORM)] provides developers with a set of tools that ease management of the relationships between objects and relational databases, thus allowing applications to be easily extended to add data persistence. For Ruby, several object-relational mapping options are available. This wiki concentrates more on the comparison of ORM's and it gives a very high level overview of the various ORM's such as ActiveRecord , Sequel and DataMapper.

=Overview=

Object-relational Mapping (ORM) frameworks unburden the designer of the complex translation between database and object space.

Typical ORM features:
* Automatic mapping from classes to database tables
** Class instance variables to database columns
** Class instances to table rows
* Aggregation and association relationships between mapped classes are managed
** Example, :has_many, :belongs_to associations in ActiveRecord
** Inheritance cases are mapped to tables
* Validation of data prior to table storage
* Class extensions to enable search, as well as creation, read, update, and deletion (CRUD) of instances/records
* Usually abstracts the database from program space in such a way that alternate database types can be easily chosen (SQLite, Oracle, etc)

The diagram below depicts a simple mapping of an object to a database table….

[[Image:3j_ks_pic1.jpg]]

When applied to Ruby, implementations of ORM often leverage the language’s [http://en.wikipedia.org/wiki/Metaprogramming metaprogramming] strengths to create intuitive application-specific methods and otherwise extend classes to support database functionality.

=ActiveRecord=

[http://ar.rubyonrails.org/ ActiveRecord], originally created by David Heinemeier and released in 2003, became the de-facto ORM for Ruby since it was integrated in the widely-used Rails framework, however alternate ORMs for Ruby have been developed and Rails 3.x is ORM independent. ActiveRecord is an implementation of the active record design pattern, where a table is wrapped into a class and this class implements accessor methods for each column in the table.

To create a table, ActiveRecord makes use of a migration class rather than including table definition in the actual class being modeled. As an example, the following code creates a table ‘’users’’ to store a collection of class ‘’User’’ objects:
<pre>
class CreateUsers < ActiveRecord::Migration
def self.up
create_table :users do |t|
t.string :name
t.string :email
t.string :age

t.timestamps # add creation and modification timestamps
end
end

def self.down # undo the table creation
drop_table :users
end
end
</pre>

Note in the preceeding example, that the ActiveRecord’s migration scheme provides a means for backing out changes via the ‘’self.down’’ method. In addition, a table key ‘’id’’ is added to the new table without explicit definition and record creation and modification timestamps are included via the ‘’timestamps’’ method provided by ActiveRecord.

ActiveRecord manages associations between table elements and provides the means to define such associations in the model definition. For example, the ‘’User’’ class shown below defines a ‘’to_many’’ association with both the cheers and posts tables. Also note ActiveRecord’s integrated support for validation of table information when attempting an update.

<pre>
class User < ActiveRecord::Base
has_many :cheers
has_many :posts

validates_presence_of :name
validates_presence_of :age
validates_uniqueness_of :name
validates_length_of :name, :within => 3..20
end
</pre>

While ActiveRecord provides the flexibility to create more sophisticated table relationships to represent class hierarchy, its base scheme is a single table inheritance, which trades some storage efficiency for simplicity in the database design. The following figure illustrates this concept of simplicity over efficiency.

[[Image:3j_ks_pic2.jpg]]

'''Pros''' -
* Integrated with popular Rails development framework
* Dynamically created database search methods (eg: User.find_by_address) ease db queries and make queries database syntax independent
* DB creation/management using the migrate scheme provides a means for backing out unwanted table changes
'''Cons''' -
* DB creation/management is decoupled from the model, requiring a separate utility (rake/migrate) that must be kept in sync with application

=Sequel=

[http://sequel.rubyforge.org Sequel] was originally developed by Sharon Rosner and the first release was in March 2007. It is based on the active record pattern. Sequel and Active record share a lot of common features , for example association and inheritance. But Sequel handles these features in a much more flexible manner. Currently Sequel is at version 3.16.0. Initially Sequel was had three core modules - sequel, sequel_core and sequel_model.Starting from version 1.4 , sequel and sequel_model were merged. Sequel handles validations using a validation plug-in and helpers.

<pre>
class CreateUser < Sequel::Migration
def up
create_table(:user) {
primary_key :id
String :name
String :age}
end
def down
drop_table(:user)
end
end # CreateUser.apply(DB, :up)
</pre>

Sequel supports associations and validations similar to ActiveRecord. The following example shows how validations and associations can be enforced int he User table that has been created above. It enforces one to many relationship between the user table and the cheers , posts tables. It also validates for the presence , uniqueness and the length of the attribute '''name'''.

<pre>
class User < Sequel::Model
one_to_many :cheers
one_to_many :posts

validates_presence [:name, :age]
validates_unique(:name)
validates_length_range 3..20, :name
end
</pre>

Some of the key features of sequel are,
* Connection Pooling
* Thread Safety
* Eager Loading / Lazy Loading
* Model Caching

=DataMapper=

[http://datamapper.org/ DataMapper] is an open source ORM for Ruby originally developed by Sam Smoot and first released in 2007. DataMapper provides a very flexible mapping API which allows creation of adapters to a wide variety of datastores beyond traditional SQL-based relational databases – DataMapper adapters have been created to non-standard sources such as the Salesforce API and even Google Video.

Some of the key features of DataMapper are:
* API supports a wide variety of databases, including non SQL types
* Thread Safety
* Eager loading of child associations
* Lazy loading

Unlike ActiveRecord and Sequel, DataMapper does not rely on a migration scheme to create and manage DB tables. Instead, DataMapper allows table definition as part of the model class definition which keeps the model definition contained to a single file, thus minimizing the effort required to keep the database and model definitions in sync. When required, DataMapper can also support a migration methodology similar to other ORMs.

Example of table definition in the model:
<pre>
class User
include DataMapper::Resource

property :id, Serial # key
property :name, String
property :password, String
property :age, String
property :created_at, DateTime

has n, :comments # one to many association
end
</pre>

=Comparison of ORM Features=

{|cellspacing="0" border="1"
!style="width:10%"|Features
!style="width:30%"|ActiveRecord
!style="width:30%"|Sequel
!style="width:30%"|DataMapper
|-
! Databases 
| MySQL, PostgreSQL, SQLite, Oracle, SQLServer, and DB2
| ADO, DataObjects, DB2, DBI, Firebird, Informix, JDBC, MySQL, ODBC, OpenBase, Oracle, PostgreSQL and SQLite3
| SQLite, MySQL, PostgreSQL, Oracle, MongoDB, SimpleDB, many others, including CouchDB, Apache Solr, Google Data API
|-
! Migrations 
| Yes
| Yes
| Yes, but optional
|-
! EagerLoading 
| Supported by scanning the SQL fragments
| Supported using eager (preloading) and eager_graph (joins)
| Supported
|-
! Flexible Overriding 
| No. Overriding is done using alias methods.
| Using methods and by calling 'super'
| Using methods (verify)
|-
! Dynamic Finders 
| Yes. Uses 'Method Missing'
| No. Alternative is to use <Model>.FindOrCreate(:name=>"John")
| Yes. Using the dm_ar_finders plugin
|}

 

=Further Reading=
To get more information on ORM and the different type of ORM's available for Ruby , please look into the [http://pg-server.csc.ncsu.edu/mediawiki/index.php/CSC/ECE_517_Fall_2007/wiki2_2_22, Object-relational mapping Fall 2007] wiki.

=References=

# [http://en.wikipedia.org/wiki/Object-relational_mapping Wikipedia, Object-relational mapping (ORM)]
# [http://ar.rubyonrails.org/ ActiveRecord]
# [http://en.wikipedia.org/wiki/Active_record_pattern Wikipedia Active record pattern]
# [http://sequel.rubyforge.org/ Sequel]
# [http://jeremyevans-pres.heroku.com/mwrc2009_presentation.html Sequel Presentation - By Jeremy Evans]
# [http://merbist.com/2008/09/29/write-your-own-custom-datamapper-adapter/ Merbist blog on custom DM adapters - By Matt Aimonetti]
# [http://en.wikipedia.org/wiki/Datamapper DataMapper]
# [http://pg-server.csc.ncsu.edu/mediawiki/index.php/CSC/ECE_517_Fall_2007/wiki2_2_22 Object-Relational Mapping Fall 2007]

CSC/ECE 517 Fall 2010/ch3 3j KS

2010-10-15T03:25:41Z

Kschidam: /* ActiveRecord */

='''Object-relational Mapping for Ruby'''=

__TOC__

=Introduction=

[http://en.wikipedia.org/wiki/Object-relational_mapping Object-relational mapping (ORM)] provides developers with a set of tools that ease management of the relationships between objects and relational databases, thus allowing applications to be easily extended to add data persistence. For Ruby, several object-relational mapping options are available. This wiki concentrates more on the comparison of ORM's and it gives a very high level overview of the various ORM's such as ActiveRecord , Sequel and DataMapper.

=Overview=

Object-relational Mapping (ORM) frameworks unburden the designer of the complex translation between database and object space.

Typical ORM features:
* Automatic mapping from classes to database tables
** Class instance variables to database columns
** Class instances to table rows
* Aggregation and association relationships between mapped classes are managed
** Example, :has_many, :belongs_to associations in ActiveRecord
** Inheritance cases are mapped to tables
* Validation of data prior to table storage
* Class extensions to enable search, as well as creation, read, update, and deletion (CRUD) of instances/records
* Usually abstracts the database from program space in such a way that alternate database types can be easily chosen (SQLite, Oracle, etc)

The diagram below depicts a simple mapping of an object to a database table….

[[Image:3j_ks_pic1.jpg]]

When applied to Ruby, implementations of ORM often leverage the language’s [http://en.wikipedia.org/wiki/Metaprogramming metaprogramming] strengths to create intuitive application-specific methods and otherwise extend classes to support database functionality.

=ActiveRecord=

[http://ar.rubyonrails.org/ ActiveRecord], originally created by David Heinemeier and released in 2003, became the de-facto ORM for Ruby since it was integrated in the widely-used Rails framework, however alternate ORMs for Ruby have been developed and Rails 3.x is ORM independent. ActiveRecord is an implementation of the active record design pattern, where a table is wrapped into a class and this class implements accessor methods for each column in the table.

To create a table, ActiveRecord makes use of a migration class rather than including table definition in the actual class being modeled. As an example, the following code creates a table ‘’users’’ to store a collection of class ‘’User’’ objects:
<pre>
class CreateUsers < ActiveRecord::Migration
def self.up
create_table :users do |t|
t.string :name
t.string :email
t.string :age

t.timestamps # add creation and modification timestamps
end
end

def self.down # undo the table creation
drop_table :users
end
end
</pre>

Note in the preceeding example, that the ActiveRecord’s migration scheme provides a means for backing out changes via the ‘’self.down’’ method. In addition, a table key ‘’id’’ is added to the new table without explicit definition and record creation and modification timestamps are included via the ‘’timestamps’’ method provided by ActiveRecord.

ActiveRecord manages associations between table elements and provides the means to define such associations in the model definition. For example, the ‘’User’’ class shown below defines a ‘’to_many’’ association with both the cheers and posts tables. Also note ActiveRecord’s integrated support for validation of table information when attempting an update.

<pre>
class User < ActiveRecord::Base
has_many :cheers
has_many :posts

validates_presence_of :name
validates_presence_of :age
validates_uniqueness_of :name
validates_length_of :name, :within => 3..20
end
</pre>

While ActiveRecord provides the flexibility to create more sophisticated table relationships to represent class hierarchy, its base scheme is a single table inheritance, which trades some storage efficiency for simplicity in the database design. The following figure illustrates this concept of simplicity over efficiency.

[[Image:3j_ks_pic2.jpg]]

'''Pros''' -
* Integrated with popular Rails development framework
* Dynamically created database search methods (eg: User.find_by_address) ease db queries and make queries database syntax independent
* DB creation/management using the migrate scheme provides a means for backing out unwanted table changes
'''Cons''' -
* DB creation/management is decoupled from the model, requiring a separate utility (rake/migrate) that must be kept in sync with application

=Sequel=

[http://sequel.rubyforge.org Sequel] was originally developed by Sharon Rosner and the first release was in March 2007. It is based on the active record pattern. Sequel and Active record share a lot of common features , for example association and inheritance. But Sequel handles these features in a much more flexible manner. Currently Sequel is at version 3.16.0. Initially Sequel was had three core modules - sequel, sequel_core and sequel_model.Starting from version 1.4 , sequel and sequel_model were merged. Sequel handles validations using a validation plug-in and helpers.

Some of the key features of sequel are,
* Connection Pooling
* Thread Safety
* Eager Loading / Lazy Loading
* Model Caching

<pre>
class CreateUser < Sequel::Migration
def up
create_table(:user) {
primary_key :id
String :name
String :age}
end
def down
drop_table(:user)
end
end # CreateUser.apply(DB, :up)
</pre>

Sequel supports associations and validations similar to ActiveRecord. The following example shows how validations and associations can be enforced int he User table that has been created above. It enforces one to many relationship between the user table and the cheers , posts tables. It also validates for the presence , uniqueness and the length of the attribute '''name'''.

<pre>
class User < Sequel::Model
one_to_many :cheers
one_to_many :posts

validates_presence [:name, :age]
validates_unique(:name)
validates_length_range 3..20, :name
end
</pre>

=DataMapper=

[http://datamapper.org/ DataMapper] is an open source ORM for Ruby originally developed by Sam Smoot and first released in 2007. DataMapper provides a very flexible mapping API which allows creation of adapters to a wide variety of datastores beyond traditional SQL-based relational databases – DataMapper adapters have been created to non-standard sources such as the Salesforce API and even Google Video.

Some of the key features of DataMapper are:
* API supports a wide variety of databases, including non SQL types
* Thread Safety
* Eager loading of child associations
* Lazy loading

Unlike ActiveRecord and Sequel, DataMapper does not rely on a migration scheme to create and manage DB tables. Instead, DataMapper allows table definition as part of the model class definition which keeps the model definition contained to a single file, thus minimizing the effort required to keep the database and model definitions in sync. When required, DataMapper can also support a migration methodology similar to other ORMs.

Example of table definition in the model:
<pre>
class User
include DataMapper::Resource

property :id, Serial # key
property :name, String
property :password, String
property :age, String
property :created_at, DateTime

has n, :comments # one to many association
end
</pre>

=Comparison of ORM Features=

{|cellspacing="0" border="1"
!style="width:10%"|Features
!style="width:30%"|ActiveRecord
!style="width:30%"|Sequel
!style="width:30%"|DataMapper
|-
! Databases 
| MySQL, PostgreSQL, SQLite, Oracle, SQLServer, and DB2
| ADO, DataObjects, DB2, DBI, Firebird, Informix, JDBC, MySQL, ODBC, OpenBase, Oracle, PostgreSQL and SQLite3
| SQLite, MySQL, PostgreSQL, Oracle, MongoDB, SimpleDB, many others, including CouchDB, Apache Solr, Google Data API
|-
! Migrations 
| Yes
| Yes
| Yes, but optional
|-
! EagerLoading 
| Supported by scanning the SQL fragments
| Supported using eager (preloading) and eager_graph (joins)
| Supported
|-
! Flexible Overriding 
| No. Overriding is done using alias methods.
| Using methods and by calling 'super'
| Using methods (verify)
|-
! Dynamic Finders 
| Yes. Uses 'Method Missing'
| No. Alternative is to use <Model>.FindOrCreate(:name=>"John")
| Yes. Using the dm_ar_finders plugin
|}

 

=Further Reading=
To get more information on ORM and the different type of ORM's available for Ruby , please look into the [http://pg-server.csc.ncsu.edu/mediawiki/index.php/CSC/ECE_517_Fall_2007/wiki2_2_22, Object-relational mapping Fall 2007] wiki.

=References=

# [http://en.wikipedia.org/wiki/Object-relational_mapping Wikipedia, Object-relational mapping (ORM)]
# [http://ar.rubyonrails.org/ ActiveRecord]
# [http://en.wikipedia.org/wiki/Active_record_pattern Wikipedia Active record pattern]
# [http://sequel.rubyforge.org/ Sequel]
# [http://jeremyevans-pres.heroku.com/mwrc2009_presentation.html Sequel Presentation - By Jeremy Evans]
# [http://merbist.com/2008/09/29/write-your-own-custom-datamapper-adapter/ Merbist blog on custom DM adapters - By Matt Aimonetti]
# [http://en.wikipedia.org/wiki/Datamapper DataMapper]
# [http://pg-server.csc.ncsu.edu/mediawiki/index.php/CSC/ECE_517_Fall_2007/wiki2_2_22 Object-Relational Mapping Fall 2007]

CSC/ECE 517 Fall 2010/ch3 3j KS

2010-10-15T03:03:35Z

Kschidam: /* References */

='''Object-relational Mapping for Ruby'''=

__TOC__

=Introduction=

[http://en.wikipedia.org/wiki/Object-relational_mapping Object-relational mapping (ORM)] provides developers with a set of tools that ease management of the relationships between objects and relational databases, thus allowing applications to be easily extended to add data persistence. For Ruby, several object-relational mapping options are available. This wiki concentrates more on the comparison of ORM's and it gives a very high level overview of the various ORM's such as ActiveRecord , Sequel and DataMapper.

=Overview=

Object-relational Mapping (ORM) frameworks unburden the designer of the complex translation between database and object space.

Typical ORM features:
* Automatic mapping from classes to database tables
** Class instance variables to database columns
** Class instances to table rows
* Aggregation and association relationships between mapped classes are managed
** Example, :has_many, :belongs_to associations in ActiveRecord
** Inheritance cases are mapped to tables
* Validation of data prior to table storage
* Class extensions to enable search, as well as creation, read, update, and deletion (CRUD) of instances/records
* Usually abstracts the database from program space in such a way that alternate database types can be easily chosen (SQLite, Oracle, etc)

The diagram below depicts a simple mapping of an object to a database table….

[[Image:3j_ks_pic1.jpg]]

When applied to Ruby, implementations of ORM often leverage the language’s [http://en.wikipedia.org/wiki/Metaprogramming metaprogramming] strengths to create intuitive application-specific methods and otherwise extend classes to support database functionality.

=ActiveRecord=

[http://ar.rubyonrails.org/ ActiveRecord], originally created by David Heinemeier and released in 2003, became the de-facto ORM for Ruby since it was integrated in the widely-used Rails framework, however alternate ORMs for Ruby have been developed and Rails 3.x is ORM independent. ActiveRecord is an implementation of the active record design pattern, where a table is wrapped into a class and this class implements accessor methods for each column in the table.

To create a table, ActiveRecord makes use of a migration class rather than including table definition in the actual class being modeled. As an example, the following code creates a table ‘’users’’ to store a collection of class ‘’User’’ objects:
<pre>
class CreateUsers < ActiveRecord::Migration
def self.up
create_table :users do |t|
t.string :name
t.string :email
t.string :age

t.timestamps # add creation and modification timestamps
end
end

def self.down # undo the table creation
drop_table :users
end
end
</pre>

Note in the preceeding example, that the ActiveRecord’s migration scheme provides a means for backing out changes via the ‘’self.down’’ method. In addition, a table key ‘’id’’ is added to the new table without explicit definition and record creation and modification timestamps are included via the ‘’timestamps’’ method provided by ActiveRecord.

ActiveRecord manages associations between table elements and provides the means to define such associations in the model definition. For example, the ‘’User’’ class shown below defines a ‘’to_many’’ association with both the cheers and posts tables. Also note ActiveRecord’s integrated support for validation of table information when attempting an update.

<pre>
class User < ActiveRecord::Base
has_many :cheers
has_many :posts

validates_presence_of :name
validates_presence_of :age
validates_uniqueness_of :name
validates_length_of :name, :within => 3..20
end
</pre>

While ActiveRecord provides the flexibility to create more sophisticated table relationships to represent class hierarchy, its base scheme is a single table inheritance, which trades some storage efficiency for simplicity in the database design.

[[Image:3j_ks_pic2.jpg]]

'''Pros''' -
* Integrated with popular Rails development framework
* Dynamically created database search methods (eg: User.find_by_address) ease db queries and make queries database syntax independent
* DB creation/management using the migrate scheme provides a means for backing out unwanted table changes
'''Cons''' -
* DB creation/management is decoupled from the model, requiring a separate utility (rake/migrate) that must be kept in sync with application

=Sequel=

[http://sequel.rubyforge.org Sequel] was originally developed by Sharon Rosner and the first release was in March 2007. It is based on the active record pattern. Sequel and Active record share a lot of common features , for example association and inheritance. But Sequel handles these features in a much more flexible manner. Currently Sequel is at version 3.16.0. Initially Sequel was had three core modules - sequel, sequel_core and sequel_model.Starting from version 1.4 , sequel and sequel_model were merged. Sequel handles validations using a validation plug-in and helpers.

Some of the key features of sequel are,
* Connection Pooling
* Thread Safety
* Eager Loading / Lazy Loading
* Model Caching

<pre>
class CreateUser < Sequel::Migration
def up
create_table(:user) {
primary_key :id
String :name
String :age}
end
def down
drop_table(:user)
end
end # CreateUser.apply(DB, :up)
</pre>

Sequel supports associations and validations similar to ActiveRecord. The following example shows how validations and associations can be enforced int he User table that has been created above. It enforces one to many relationship between the user table and the cheers , posts tables. It also validates for the presence , uniqueness and the length of the attribute '''name'''.

<pre>
class User < Sequel::Model
one_to_many :cheers
one_to_many :posts

validates_presence [:name, :age]
validates_unique(:name)
validates_length_range 3..20, :name
end
</pre>

=DataMapper=

[http://datamapper.org/ DataMapper] is an open source ORM for Ruby originally developed by Sam Smoot and first released in 2007. DataMapper provides a very flexible mapping API which allows creation of adapters to a wide variety of datastores beyond traditional SQL-based relational databases – DataMapper adapters have been created to non-standard sources such as the Salesforce API and even Google Video.

Some of the key features of DataMapper are:
* API supports a wide variety of databases, including non SQL types
* Thread Safety
* Eager loading of child associations
* Lazy loading

Unlike ActiveRecord and Sequel, DataMapper does not rely on a migration scheme to create and manage DB tables. Instead, DataMapper allows table definition as part of the model class definition which keeps the model definition contained to a single file, thus minimizing the effort required to keep the database and model definitions in sync. When required, DataMapper can also support a migration methodology similar to other ORMs.

Example of table definition in the model:
<pre>
class User
include DataMapper::Resource

property :id, Serial # key
property :name, String
property :password, String
property :age, String
property :created_at, DateTime

has n, :comments # one to many association
end
</pre>

=Comparison of ORM Features=

{|cellspacing="0" border="1"
!style="width:10%"|Features
!style="width:30%"|ActiveRecord
!style="width:30%"|Sequel
!style="width:30%"|DataMapper
|-
! Databases 
| MySQL, PostgreSQL, SQLite, Oracle, SQLServer, and DB2
| ADO, DataObjects, DB2, DBI, Firebird, Informix, JDBC, MySQL, ODBC, OpenBase, Oracle, PostgreSQL and SQLite3
| SQLite, MySQL, PostgreSQL, Oracle, MongoDB, SimpleDB, many others, including CouchDB, Apache Solr, Google Data API
|-
! Migrations 
| Yes
| Yes
| Yes, but optional
|-
! EagerLoading 
| Supported by scanning the SQL fragments
| Supported using eager (preloading) and eager_graph (joins)
| Supported
|-
! Flexible Overriding 
| No. Overriding is done using alias methods.
| Using methods and by calling 'super'
| Using methods (verify)
|-
! Dynamic Finders 
| Yes. Uses 'Method Missing'
| No. Alternative is to use <Model>.FindOrCreate(:name=>"John")
| Yes. Using the dm_ar_finders plugin
|}

 

=Further Reading=
To get more information on ORM and the different type of ORM's available for Ruby , please look into the [http://pg-server.csc.ncsu.edu/mediawiki/index.php/CSC/ECE_517_Fall_2007/wiki2_2_22, Object-relational mapping Fall 2007] wiki.

=References=

# [http://en.wikipedia.org/wiki/Object-relational_mapping Wikipedia, Object-relational mapping (ORM)]
# [http://ar.rubyonrails.org/ ActiveRecord]
# [http://en.wikipedia.org/wiki/Active_record_pattern Wikipedia Active record pattern]
# [http://sequel.rubyforge.org/ Sequel]
# [http://jeremyevans-pres.heroku.com/mwrc2009_presentation.html Sequel Presentation - By Jeremy Evans]
# [http://merbist.com/2008/09/29/write-your-own-custom-datamapper-adapter/ Merbist blog on custom DM adapters - By Matt Aimonetti]
# [http://en.wikipedia.org/wiki/Datamapper DataMapper]
# [http://pg-server.csc.ncsu.edu/mediawiki/index.php/CSC/ECE_517_Fall_2007/wiki2_2_22 Object-Relational Mapping Fall 2007]

CSC/ECE 517 Fall 2010/ch3 3j KS

2010-10-15T02:56:51Z

Kschidam: /* DataMapper */

='''Object-relational Mapping for Ruby'''=

__TOC__

=Introduction=

[http://en.wikipedia.org/wiki/Object-relational_mapping Object-relational mapping (ORM)] provides developers with a set of tools that ease management of the relationships between objects and relational databases, thus allowing applications to be easily extended to add data persistence. For Ruby, several object-relational mapping options are available. This wiki concentrates more on the comparison of ORM's and it gives a very high level overview of the various ORM's such as ActiveRecord , Sequel and DataMapper.

=Overview=

Object-relational Mapping (ORM) frameworks unburden the designer of the complex translation between database and object space.

Typical ORM features:
* Automatic mapping from classes to database tables
** Class instance variables to database columns
** Class instances to table rows
* Aggregation and association relationships between mapped classes are managed
** Example, :has_many, :belongs_to associations in ActiveRecord
** Inheritance cases are mapped to tables
* Validation of data prior to table storage
* Class extensions to enable search, as well as creation, read, update, and deletion (CRUD) of instances/records
* Usually abstracts the database from program space in such a way that alternate database types can be easily chosen (SQLite, Oracle, etc)

The diagram below depicts a simple mapping of an object to a database table….

[[Image:3j_ks_pic1.jpg]]

When applied to Ruby, implementations of ORM often leverage the language’s [http://en.wikipedia.org/wiki/Metaprogramming metaprogramming] strengths to create intuitive application-specific methods and otherwise extend classes to support database functionality.

=ActiveRecord=

[http://ar.rubyonrails.org/ ActiveRecord], originally created by David Heinemeier and released in 2003, became the de-facto ORM for Ruby since it was integrated in the widely-used Rails framework, however alternate ORMs for Ruby have been developed and Rails 3.x is ORM independent. ActiveRecord is an implementation of the active record design pattern, where a table is wrapped into a class and this class implements accessor methods for each column in the table.

To create a table, ActiveRecord makes use of a migration class rather than including table definition in the actual class being modeled. As an example, the following code creates a table ‘’users’’ to store a collection of class ‘’User’’ objects:
<pre>
class CreateUsers < ActiveRecord::Migration
def self.up
create_table :users do |t|
t.string :name
t.string :email
t.string :age

t.timestamps # add creation and modification timestamps
end
end

def self.down # undo the table creation
drop_table :users
end
end
</pre>

Note in the preceeding example, that the ActiveRecord’s migration scheme provides a means for backing out changes via the ‘’self.down’’ method. In addition, a table key ‘’id’’ is added to the new table without explicit definition and record creation and modification timestamps are included via the ‘’timestamps’’ method provided by ActiveRecord.

ActiveRecord manages associations between table elements and provides the means to define such associations in the model definition. For example, the ‘’User’’ class shown below defines a ‘’to_many’’ association with both the cheers and posts tables. Also note ActiveRecord’s integrated support for validation of table information when attempting an update.

<pre>
class User < ActiveRecord::Base
has_many :cheers
has_many :posts

validates_presence_of :name
validates_presence_of :age
validates_uniqueness_of :name
validates_length_of :name, :within => 3..20
end
</pre>

While ActiveRecord provides the flexibility to create more sophisticated table relationships to represent class hierarchy, its base scheme is a single table inheritance, which trades some storage efficiency for simplicity in the database design.

[[Image:3j_ks_pic2.jpg]]

'''Pros''' -
* Integrated with popular Rails development framework
* Dynamically created database search methods (eg: User.find_by_address) ease db queries and make queries database syntax independent
* DB creation/management using the migrate scheme provides a means for backing out unwanted table changes
'''Cons''' -
* DB creation/management is decoupled from the model, requiring a separate utility (rake/migrate) that must be kept in sync with application

=Sequel=

[http://sequel.rubyforge.org Sequel] was originally developed by Sharon Rosner and the first release was in March 2007. It is based on the active record pattern. Sequel and Active record share a lot of common features , for example association and inheritance. But Sequel handles these features in a much more flexible manner. Currently Sequel is at version 3.16.0. Initially Sequel was had three core modules - sequel, sequel_core and sequel_model.Starting from version 1.4 , sequel and sequel_model were merged. Sequel handles validations using a validation plug-in and helpers.

Some of the key features of sequel are,
* Connection Pooling
* Thread Safety
* Eager Loading / Lazy Loading
* Model Caching

<pre>
class CreateUser < Sequel::Migration
def up
create_table(:user) {
primary_key :id
String :name
String :age}
end
def down
drop_table(:user)
end
end # CreateUser.apply(DB, :up)
</pre>

Sequel supports associations and validations similar to ActiveRecord. The following example shows how validations and associations can be enforced int he User table that has been created above. It enforces one to many relationship between the user table and the cheers , posts tables. It also validates for the presence , uniqueness and the length of the attribute '''name'''.

<pre>
class User < Sequel::Model
one_to_many :cheers
one_to_many :posts

validates_presence [:name, :age]
validates_unique(:name)
validates_length_range 3..20, :name
end
</pre>

=DataMapper=

[http://datamapper.org/ DataMapper] is an open source ORM for Ruby originally developed by Sam Smoot and first released in 2007. DataMapper provides a very flexible mapping API which allows creation of adapters to a wide variety of datastores beyond traditional SQL-based relational databases – DataMapper adapters have been created to non-standard sources such as the Salesforce API and even Google Video.

Some of the key features of DataMapper are:
* API supports a wide variety of databases, including non SQL types
* Thread Safety
* Eager loading of child associations
* Lazy loading

Unlike ActiveRecord and Sequel, DataMapper does not rely on a migration scheme to create and manage DB tables. Instead, DataMapper allows table definition as part of the model class definition which keeps the model definition contained to a single file, thus minimizing the effort required to keep the database and model definitions in sync. When required, DataMapper can also support a migration methodology similar to other ORMs.

Example of table definition in the model:
<pre>
class User
include DataMapper::Resource

property :id, Serial # key
property :name, String
property :password, String
property :age, String
property :created_at, DateTime

has n, :comments # one to many association
end
</pre>

=Comparison of ORM Features=

{|cellspacing="0" border="1"
!style="width:10%"|Features
!style="width:30%"|ActiveRecord
!style="width:30%"|Sequel
!style="width:30%"|DataMapper
|-
! Databases 
| MySQL, PostgreSQL, SQLite, Oracle, SQLServer, and DB2
| ADO, DataObjects, DB2, DBI, Firebird, Informix, JDBC, MySQL, ODBC, OpenBase, Oracle, PostgreSQL and SQLite3
| SQLite, MySQL, PostgreSQL, Oracle, MongoDB, SimpleDB, many others, including CouchDB, Apache Solr, Google Data API
|-
! Migrations 
| Yes
| Yes
| Yes, but optional
|-
! EagerLoading 
| Supported by scanning the SQL fragments
| Supported using eager (preloading) and eager_graph (joins)
| Supported
|-
! Flexible Overriding 
| No. Overriding is done using alias methods.
| Using methods and by calling 'super'
| Using methods (verify)
|-
! Dynamic Finders 
| Yes. Uses 'Method Missing'
| No. Alternative is to use <Model>.FindOrCreate(:name=>"John")
| Yes. Using the dm_ar_finders plugin
|}

 

=Further Reading=
To get more information on ORM and the different type of ORM's available for Ruby , please look into the [http://pg-server.csc.ncsu.edu/mediawiki/index.php/CSC/ECE_517_Fall_2007/wiki2_2_22, Object-relational mapping Fall 2007] wiki.

=References=

# [http://en.wikipedia.org/wiki/Object-relational_mapping Wikipedia, Object-relational mapping (ORM)]
# [http://ar.rubyonrails.org/ ActiveRecord]
# [http://en.wikipedia.org/wiki/Active_record_pattern Wikipedia, Active record pattern]
# [http://sequel.rubyforge.org/ Sequel]
# [http://jeremyevans-pres.heroku.com/mwrc2009_presentation.html Sequel Presentation - By Jeremy Evans]
# [http://datamapper.org/ DataMapper]
# [http://merbist.com/2008/09/29/write-your-own-custom-datamapper-adapter/ Merbist blog on custom DM adapters - By Matt Aimonetti]
# [http://en.wikipedia.org/wiki/Datamapper Wikipedia, DataMapper]
# [http://pg-server.csc.ncsu.edu/mediawiki/index.php/CSC/ECE_517_Fall_2007/wiki2_2_22, Object-Relational Mapping Fall 2007]

CSC/ECE 517 Fall 2010/ch3 3j KS

2010-10-15T02:56:11Z

Kschidam:

='''Object-relational Mapping for Ruby'''=

__TOC__

=Introduction=

[http://en.wikipedia.org/wiki/Object-relational_mapping Object-relational mapping (ORM)] provides developers with a set of tools that ease management of the relationships between objects and relational databases, thus allowing applications to be easily extended to add data persistence. For Ruby, several object-relational mapping options are available. This wiki concentrates more on the comparison of ORM's and it gives a very high level overview of the various ORM's such as ActiveRecord , Sequel and DataMapper.

=Overview=

Object-relational Mapping (ORM) frameworks unburden the designer of the complex translation between database and object space.

Typical ORM features:
* Automatic mapping from classes to database tables
** Class instance variables to database columns
** Class instances to table rows
* Aggregation and association relationships between mapped classes are managed
** Example, :has_many, :belongs_to associations in ActiveRecord
** Inheritance cases are mapped to tables
* Validation of data prior to table storage
* Class extensions to enable search, as well as creation, read, update, and deletion (CRUD) of instances/records
* Usually abstracts the database from program space in such a way that alternate database types can be easily chosen (SQLite, Oracle, etc)

The diagram below depicts a simple mapping of an object to a database table….

[[Image:3j_ks_pic1.jpg]]

When applied to Ruby, implementations of ORM often leverage the language’s [http://en.wikipedia.org/wiki/Metaprogramming metaprogramming] strengths to create intuitive application-specific methods and otherwise extend classes to support database functionality.

=ActiveRecord=

[http://ar.rubyonrails.org/ ActiveRecord], originally created by David Heinemeier and released in 2003, became the de-facto ORM for Ruby since it was integrated in the widely-used Rails framework, however alternate ORMs for Ruby have been developed and Rails 3.x is ORM independent. ActiveRecord is an implementation of the active record design pattern, where a table is wrapped into a class and this class implements accessor methods for each column in the table.

To create a table, ActiveRecord makes use of a migration class rather than including table definition in the actual class being modeled. As an example, the following code creates a table ‘’users’’ to store a collection of class ‘’User’’ objects:
<pre>
class CreateUsers < ActiveRecord::Migration
def self.up
create_table :users do |t|
t.string :name
t.string :email
t.string :age

t.timestamps # add creation and modification timestamps
end
end

def self.down # undo the table creation
drop_table :users
end
end
</pre>

Note in the preceeding example, that the ActiveRecord’s migration scheme provides a means for backing out changes via the ‘’self.down’’ method. In addition, a table key ‘’id’’ is added to the new table without explicit definition and record creation and modification timestamps are included via the ‘’timestamps’’ method provided by ActiveRecord.

ActiveRecord manages associations between table elements and provides the means to define such associations in the model definition. For example, the ‘’User’’ class shown below defines a ‘’to_many’’ association with both the cheers and posts tables. Also note ActiveRecord’s integrated support for validation of table information when attempting an update.

<pre>
class User < ActiveRecord::Base
has_many :cheers
has_many :posts

validates_presence_of :name
validates_presence_of :age
validates_uniqueness_of :name
validates_length_of :name, :within => 3..20
end
</pre>

While ActiveRecord provides the flexibility to create more sophisticated table relationships to represent class hierarchy, its base scheme is a single table inheritance, which trades some storage efficiency for simplicity in the database design.

[[Image:3j_ks_pic2.jpg]]

'''Pros''' -
* Integrated with popular Rails development framework
* Dynamically created database search methods (eg: User.find_by_address) ease db queries and make queries database syntax independent
* DB creation/management using the migrate scheme provides a means for backing out unwanted table changes
'''Cons''' -
* DB creation/management is decoupled from the model, requiring a separate utility (rake/migrate) that must be kept in sync with application

=Sequel=

[http://sequel.rubyforge.org Sequel] was originally developed by Sharon Rosner and the first release was in March 2007. It is based on the active record pattern. Sequel and Active record share a lot of common features , for example association and inheritance. But Sequel handles these features in a much more flexible manner. Currently Sequel is at version 3.16.0. Initially Sequel was had three core modules - sequel, sequel_core and sequel_model.Starting from version 1.4 , sequel and sequel_model were merged. Sequel handles validations using a validation plug-in and helpers.

Some of the key features of sequel are,
* Connection Pooling
* Thread Safety
* Eager Loading / Lazy Loading
* Model Caching

<pre>
class CreateUser < Sequel::Migration
def up
create_table(:user) {
primary_key :id
String :name
String :age}
end
def down
drop_table(:user)
end
end # CreateUser.apply(DB, :up)
</pre>

Sequel supports associations and validations similar to ActiveRecord. The following example shows how validations and associations can be enforced int he User table that has been created above. It enforces one to many relationship between the user table and the cheers , posts tables. It also validates for the presence , uniqueness and the length of the attribute '''name'''.

<pre>
class User < Sequel::Model
one_to_many :cheers
one_to_many :posts

validates_presence [:name, :age]
validates_unique(:name)
validates_length_range 3..20, :name
end
</pre>

=DataMapper=

[http://datamapper.org/ DataMapper] is an open source ORM for Ruby originally developed by Sam Smoot and first released in 2007. DataMapper provides a very flexible mapping API which allows creation of adapters to a wide variety of datastores beyond traditional SQL-based relational databases – DataMapper adapters have been created to non-standard sources such as the Salesforce API and even Google Video.

Some of the key features of DataMapper are:
* API supports a wide variety of databases, including non SQL types
* Thread Safety
* Eager loading of child associations
* Lazy loading

Unlike ActiveRecord and Sequel, DataMapper does not rely on a migration scheme to create and manage DB tables. Instead, DataMapper allows table definition as part of the model class definition which keeps the model definition contained to a single file, thus minimizing the effort required to keep the database and model definitions in sync. When required, DataMapper can also support a migration methodology similar to other ORMs.

Example of table definition in the model:
<pre>
class User
include DataMapper::Resource

property :id, Serial # key
property :name, String
property :password, String
property :age, String
property :created_at, DateTime

has n, :comments # one to many association
end
/pre>

=Comparison of ORM Features=

{|cellspacing="0" border="1"
!style="width:10%"|Features
!style="width:30%"|ActiveRecord
!style="width:30%"|Sequel
!style="width:30%"|DataMapper
|-
! Databases 
| MySQL, PostgreSQL, SQLite, Oracle, SQLServer, and DB2
| ADO, DataObjects, DB2, DBI, Firebird, Informix, JDBC, MySQL, ODBC, OpenBase, Oracle, PostgreSQL and SQLite3
| SQLite, MySQL, PostgreSQL, Oracle, MongoDB, SimpleDB, many others, including CouchDB, Apache Solr, Google Data API
|-
! Migrations 
| Yes
| Yes
| Yes, but optional
|-
! EagerLoading 
| Supported by scanning the SQL fragments
| Supported using eager (preloading) and eager_graph (joins)
| Supported
|-
! Flexible Overriding 
| No. Overriding is done using alias methods.
| Using methods and by calling 'super'
| Using methods (verify)
|-
! Dynamic Finders 
| Yes. Uses 'Method Missing'
| No. Alternative is to use <Model>.FindOrCreate(:name=>"John")
| Yes. Using the dm_ar_finders plugin
|}

 

=Further Reading=
To get more information on ORM and the different type of ORM's available for Ruby , please look into the [http://pg-server.csc.ncsu.edu/mediawiki/index.php/CSC/ECE_517_Fall_2007/wiki2_2_22, Object-relational mapping Fall 2007] wiki.

=References=

# [http://en.wikipedia.org/wiki/Object-relational_mapping Wikipedia, Object-relational mapping (ORM)]
# [http://ar.rubyonrails.org/ ActiveRecord]
# [http://en.wikipedia.org/wiki/Active_record_pattern Wikipedia, Active record pattern]
# [http://sequel.rubyforge.org/ Sequel]
# [http://jeremyevans-pres.heroku.com/mwrc2009_presentation.html Sequel Presentation - By Jeremy Evans]
# [http://datamapper.org/ DataMapper]
# [http://merbist.com/2008/09/29/write-your-own-custom-datamapper-adapter/ Merbist blog on custom DM adapters - By Matt Aimonetti]
# [http://en.wikipedia.org/wiki/Datamapper Wikipedia, DataMapper]
# [http://pg-server.csc.ncsu.edu/mediawiki/index.php/CSC/ECE_517_Fall_2007/wiki2_2_22, Object-Relational Mapping Fall 2007]

CSC/ECE 517 Fall 2010/ch3 3j KS

2010-10-15T02:54:51Z

Kschidam:

='''Object-relational Mapping for Ruby'''=

__TOC__

=Introduction=

[http://en.wikipedia.org/wiki/Object-relational_mapping Object-relational mapping (ORM)] provides developers with a set of tools that ease management of the relationships between objects and relational databases, thus allowing applications to be easily extended to add data persistence. For Ruby, several object-relational mapping options are available. This wiki concentrates more on the comparison of ORM's and it gives a very high level overview of the various ORM's such as ActiveRecord , Sequel and DataMapper.

=Overview=

Object-relational Mapping (ORM) frameworks unburden the designer of the complex translation between database and object space.

Typical ORM features:
* Automatic mapping from classes to database tables
** Class instance variables to database columns
** Class instances to table rows
* Aggregation and association relationships between mapped classes are managed
** Example, :has_many, :belongs_to associations in ActiveRecord
** Inheritance cases are mapped to tables
* Validation of data prior to table storage
* Class extensions to enable search, as well as creation, read, update, and deletion (CRUD) of instances/records
* Usually abstracts the database from program space in such a way that alternate database types can be easily chosen (SQLite, Oracle, etc)

The diagram below depicts a simple mapping of an object to a database table….

[[Image:3j_ks_pic1.jpg]]

When applied to Ruby, implementations of ORM often leverage the language’s [http://en.wikipedia.org/wiki/Metaprogramming metaprogramming] strengths to create intuitive application-specific methods and otherwise extend classes to support database functionality.

=''' ActiveRecord '''=

[http://ar.rubyonrails.org/ ActiveRecord], originally created by David Heinemeier and released in 2003, became the de-facto ORM for Ruby since it was integrated in the widely-used Rails framework, however alternate ORMs for Ruby have been developed and Rails 3.x is ORM independent. ActiveRecord is an implementation of the active record design pattern, where a table is wrapped into a class and this class implements accessor methods for each column in the table.

To create a table, ActiveRecord makes use of a migration class rather than including table definition in the actual class being modeled. As an example, the following code creates a table ‘’users’’ to store a collection of class ‘’User’’ objects:
<pre>
class CreateUsers < ActiveRecord::Migration
def self.up
create_table :users do |t|
t.string :name
t.string :email
t.string :age

t.timestamps # add creation and modification timestamps
end
end

def self.down # undo the table creation
drop_table :users
end
end
</pre>

Note in the preceeding example, that the ActiveRecord’s migration scheme provides a means for backing out changes via the ‘’self.down’’ method. In addition, a table key ‘’id’’ is added to the new table without explicit definition and record creation and modification timestamps are included via the ‘’timestamps’’ method provided by ActiveRecord.

ActiveRecord manages associations between table elements and provides the means to define such associations in the model definition. For example, the ‘’User’’ class shown below defines a ‘’to_many’’ association with both the cheers and posts tables. Also note ActiveRecord’s integrated support for validation of table information when attempting an update.

<pre>
class User < ActiveRecord::Base
has_many :cheers
has_many :posts

validates_presence_of :name
validates_presence_of :age
validates_uniqueness_of :name
validates_length_of :name, :within => 3..20
end
</pre>

While ActiveRecord provides the flexibility to create more sophisticated table relationships to represent class hierarchy, its base scheme is a single table inheritance, which trades some storage efficiency for simplicity in the database design.

[[Image:3j_ks_pic2.jpg]]

'''Pros''' -
* Integrated with popular Rails development framework
* Dynamically created database search methods (eg: User.find_by_address) ease db queries and make queries database syntax independent
* DB creation/management using the migrate scheme provides a means for backing out unwanted table changes
'''Cons''' -
* DB creation/management is decoupled from the model, requiring a separate utility (rake/migrate) that must be kept in sync with application

='''Sequel'''=

[http://sequel.rubyforge.org Sequel] was originally developed by Sharon Rosner and the first release was in March 2007. It is based on the active record pattern. Sequel and Active record share a lot of common features , for example association and inheritance. But Sequel handles these features in a much more flexible manner. Currently Sequel is at version 3.16.0. Initially Sequel was had three core modules - sequel, sequel_core and sequel_model.Starting from version 1.4 , sequel and sequel_model were merged. Sequel handles validations using a validation plug-in and helpers.

Some of the key features of sequel are,
* Connection Pooling
* Thread Safety
* Eager Loading / Lazy Loading
* Model Caching

<pre>
class CreateUser < Sequel::Migration
def up
create_table(:user) {
primary_key :id
String :name
String :age}
end
def down
drop_table(:user)
end
end # CreateUser.apply(DB, :up)
</pre>

Sequel supports associations and validations similar to ActiveRecord. The following example shows how validations and associations can be enforced int he User table that has been created above. It enforces one to many relationship between the user table and the cheers , posts tables. It also validates for the presence , uniqueness and the length of the attribute '''name'''.

<pre>
class User < Sequel::Model
one_to_many :cheers
one_to_many :posts

validates_presence [:name, :age]
validates_unique(:name)
validates_length_range 3..20, :name
end
</pre>

=''' DataMapper'''=

[http://datamapper.org/ DataMapper] is an open source ORM for Ruby originally developed by Sam Smoot and first released in 2007. DataMapper provides a very flexible mapping API which allows creation of adapters to a wide variety of datastores beyond traditional SQL-based relational databases – DataMapper adapters have been created to non-standard sources such as the Salesforce API and even Google Video.

Some of the key features of DataMapper are:
* API supports a wide variety of databases, including non SQL types
* Thread Safety
* Eager loading of child associations
* Lazy loading

Unlike ActiveRecord and Sequel, DataMapper does not rely on a migration scheme to create and manage DB tables. Instead, DataMapper allows table definition as part of the model class definition which keeps the model definition contained to a single file, thus minimizing the effort required to keep the database and model definitions in sync. When required, DataMapper can also support a migration methodology similar to other ORMs.

Example of table definition in the model:
<pre>
class User
include DataMapper::Resource

property :id, Serial # key
property :name, String
property :password, String
property :age, String
property :created_at, DateTime

has n, :comments # one to many association

end
</pre>

=Comparison of ORM Features=

{|cellspacing="0" border="1"
!style="width:10%"|Features
!style="width:30%"|ActiveRecord
!style="width:30%"|Sequel
!style="width:30%"|DataMapper
|-
! Databases 
| MySQL, PostgreSQL, SQLite, Oracle, SQLServer, and DB2
| ADO, DataObjects, DB2, DBI, Firebird, Informix, JDBC, MySQL, ODBC, OpenBase, Oracle, PostgreSQL and SQLite3
| SQLite, MySQL, PostgreSQL, Oracle, MongoDB, SimpleDB, many others, including CouchDB, Apache Solr, Google Data API
|-
! Migrations 
| Yes
| Yes
| Yes, but optional
|-
! EagerLoading 
| Supported by scanning the SQL fragments
| Supported using eager (preloading) and eager_graph (joins)
| Supported
|-
! Flexible Overriding 
| No. Overriding is done using alias methods.
| Using methods and by calling 'super'
| Using methods (verify)
|-
! Dynamic Finders 
| Yes. Uses 'Method Missing'
| No. Alternative is to use <Model>.FindOrCreate(:name=>"John")
| Yes. Using the dm_ar_finders plugin
|}

 

=Further Reading=
To get more information on ORM and the different type of ORM's available for Ruby , please look into the [http://pg-server.csc.ncsu.edu/mediawiki/index.php/CSC/ECE_517_Fall_2007/wiki2_2_22, Object-relational mapping Fall 2007] wiki.

=References=

# [http://en.wikipedia.org/wiki/Object-relational_mapping Wikipedia, Object-relational mapping (ORM)]
# [http://ar.rubyonrails.org/ ActiveRecord]
# [http://en.wikipedia.org/wiki/Active_record_pattern Wikipedia, Active record pattern]
# [http://sequel.rubyforge.org/ Sequel]
# [http://jeremyevans-pres.heroku.com/mwrc2009_presentation.html Sequel Presentation - By Jeremy Evans]
# [http://datamapper.org/ DataMapper]
# [http://merbist.com/2008/09/29/write-your-own-custom-datamapper-adapter/ Merbist blog on custom DM adapters - By Matt Aimonetti]
# [http://en.wikipedia.org/wiki/Datamapper Wikipedia, DataMapper]
# [http://pg-server.csc.ncsu.edu/mediawiki/index.php/CSC/ECE_517_Fall_2007/wiki2_2_22, Object-Relational Mapping Fall 2007]

CSC/ECE 517 Fall 2010/ch3 3j KS

2010-10-15T02:48:40Z

Kschidam: /* ''' ActiveRecord ''' */

='''Object-relational Mapping for Ruby'''=

__TOC__

=Introduction=

[http://en.wikipedia.org/wiki/Object-relational_mapping Object-relational mapping (ORM)] provides developers with a set of tools that ease management of the relationships between objects and relational databases, thus allowing applications to be easily extended to add data persistence. For Ruby, several object-relational mapping options are available. This wiki concentrates more on the comparison of ORM's and it gives a very high level overview of the various ORM's such as ActiveRecord , Sequel and DataMapper.

=Overview=

Object-relational Mapping (ORM) frameworks unburden the designer of the complex translation between database and object space.

Typical ORM features:
* Automatic mapping from classes to database tables
** Class instance variables to database columns
** Class instances to table rows
* Aggregation and association relationships between mapped classes are managed
** Example, :has_many, :belongs_to associations in ActiveRecord
** Inheritance cases are mapped to tables
* Validation of data prior to table storage
* Class extensions to enable search, as well as creation, read, update, and deletion (CRUD) of instances/records
* Usually abstracts the database from program space in such a way that alternate database types can be easily chosen (SQLite, Oracle, etc)

The diagram below depicts a simple mapping of an object to a database table….

[[Image:3j_ks_pic1.jpg]]

When applied to Ruby, implementations of ORM often leverage the language’s [http://en.wikipedia.org/wiki/Metaprogramming metaprogramming] strengths to create intuitive application-specific methods and otherwise extend classes to support database functionality.

=''' ActiveRecord '''=

[http://ar.rubyonrails.org/ ActiveRecord], originally created by David Heinemeier and released in 2003, became the de-facto ORM for Ruby since it was integrated in the widely-used Rails framework, however alternate ORMs for Ruby have been developed and Rails 3.x is ORM independent. ActiveRecord is an implementation of the active record design pattern, where a table is wrapped into a class and this class implements accessor methods for each column in the table.

To create a table, ActiveRecord makes use of a migration class rather than including table definition in the actual class being modeled. As an example, the following code creates a table ‘’users’’ to store a collection of class ‘’User’’ objects:
<pre>
class CreateUsers < ActiveRecord::Migration
def self.up
create_table :users do |t|
t.string :name
t.string :email
t.string :age

t.timestamps # add creation and modification timestamps
end
end

def self.down # undo the table creation
drop_table :users
end
end
</pre>

Note in the preceeding example, that the ActiveRecord’s migration scheme provides a means for backing out changes via the ‘’self.down’’ method. In addition, a table key ‘’id’’ is added to the new table without explicit definition and record creation and modification timestamps are included via the ‘’timestamps’’ method provided by ActiveRecord.

ActiveRecord manages associations between table elements and provides the means to define such associations in the model definition. For example, the ‘’User’’ class shown below defines a ‘’to_many’’ association with both the cheers and posts tables. Also note ActiveRecord’s integrated support for validation of table information when attempting an update.

<pre>
class User < ActiveRecord::Base
has_many :cheers
has_many :posts

validates_presence_of :name
validates_presence_of :age
validates_uniqueness_of :name
validates_length_of :name, :within => 3..20
end
</pre>

While ActiveRecord provides the flexibility to create more sophisticated table relationships to represent class hierarchy, its base scheme is a single table inheritance, which trades some storage efficiency for simplicity in the database design.

[[Image:3j_ks_pic2.jpg]]

'''Pros''' -
* Integrated with popular Rails development framework
* Dynamically created database search methods (eg User.find_by_address) ease db queries and make queries database syntax independent
* DB creation/management using the migrate scheme provides a means for backing out unwanted table changes
'''Cons''' -
* DB creation/management is decoupled from the model, requiring a separate utility (rake/migrate) that must be kept in sync with application

='''Sequel'''=

[http://sequel.rubyforge.org Sequel] was originally developed by Sharon Rosner and the first release was in March 2007. It is based on the active record pattern. Sequel and Active record share a lot of common features , for example association and inheritance. But Sequel handles these features in a much more flexible manner. Currently Sequel is at version 3.16.0. Initially Sequel was had three core modules - sequel, sequel_core and sequel_model.Starting from version 1.4 , sequel and sequel_model were merged. Sequel handles validations using a validation plug-in and helpers.

Some of the key features of sequel are,
* Connection Pooling
* Thread Safety
* Eager Loading / Lazy Loading
* Model Caching

<pre>
class CreateUser < Sequel::Migration
def up
create_table(:user) {
primary_key :id
String :name
String :age}
end
def down
drop_table(:user)
end
end # CreateUser.apply(DB, :up)
</pre>

Sequel supports associations and validations similar to ActiveRecord. The following example shows how validations and associations can be enforced int he User table that has been created above. It enforces one to many relationship between the user table and the cheers , posts tables. It also validates for the presence , uniqueness and the length of the attribute 'name'.

<pre>
class User < Sequel::Model
one_to_many :cheers
one_to_many :posts

validates_presence [:name, :age]
validates_unique(:name)
validates_length_range 3..20, :name
end
</pre>

=''' DataMapper'''=

[http://datamapper.org/ DataMapper] is an open source ORM for Ruby originally developed by Sam Smoot and first released in 2007. DataMapper provides a very flexible mapping API which allows creation of adapters to a wide variety of datastores beyond traditional SQL-based relational databases – DataMapper adapters have been created to non-standard sources such as the Salesforce API and even Google Video. [http://merbist.com/2008/09/29/write-your-own-custom-datamapper-adapter/ [7]]

Some of the key features of DataMapper are:
* API supports a wide variety of databases, including non SQL types
* Thread Safety
* Eager loading of child associations
* Lazy loading

Unlike ActiveRecord and Sequel, DataMapper does not rely on a migration scheme to create and manage DB tables. Instead, DataMapper allows table definition as part of the model class definition which keeps the model definition contained to a single file, thus minimizing the effort required to keep the database and model definitions in sync. When required, DataMapper can also support a migration methodology similar to other ORMs.

Example of table definition in the model:
<pre>
class User
include DataMapper::Resource

property :id, Serial # key
property :name, String
property :password, String
property :age, String
property :created_at, DateTime

has n, :comments # one to many association

end
</pre>

=Comparison of ORM Features=

{|cellspacing="0" border="1"
!style="width:10%"|Features
!style="width:30%"|ActiveRecord
!style="width:30%"|Sequel
!style="width:30%"|DataMapper
|-
! Databases 
| MySQL, PostgreSQL, SQLite, Oracle, SQLServer, and DB2
| ADO, DataObjects, DB2, DBI, Firebird, Informix, JDBC, MySQL, ODBC, OpenBase, Oracle, PostgreSQL and SQLite3
| SQLite, MySQL, PostgreSQL, Oracle, MongoDB, SimpleDB, many others, including CouchDB, Apache Solr, Google Data API
|-
! Migrations 
| Yes
| Yes
| Yes, but optional
|-
! EagerLoading 
| Supported by scanning the SQL fragments
| Supported using eager (preloading) and eager_graph (joins)
| Supported
|-
! Flexible Overriding 
| No. Overriding is done using alias methods.
| Using methods and by calling 'super'
| Using methods (verify)
|-
! Dynamic Finders 
| Yes. Uses 'Method Missing'
| No. Alternative is to use <Model>.FindOrCreate(:name=>"John")
| Yes. Using the dm_ar_finders plugin
|}

 

=Further Reading=
To get more information on ORM and the different type of ORM's available for Ruby , please look into the [http://pg-server.csc.ncsu.edu/mediawiki/index.php/CSC/ECE_517_Fall_2007/wiki2_2_22, Object-relational mapping Fall 2007] wiki.

=References=

# [http://en.wikipedia.org/wiki/Object-relational_mapping Wikipedia, Object-relational mapping (ORM)]
# [http://ar.rubyonrails.org/ ActiveRecord]
# [http://en.wikipedia.org/wiki/Active_record_pattern Wikipedia, Active record pattern]
# [http://sequel.rubyforge.org/ Sequel]
# [http://jeremyevans-pres.heroku.com/mwrc2009_presentation.html Sequel Presentation - By Jeremy Evans]
# [http://datamapper.org/ DataMapper]
# [http://merbist.com/2008/09/29/write-your-own-custom-datamapper-adapter/ Merbist blog on custom DM adapters - By Matt Aimonetti]
# [http://en.wikipedia.org/wiki/Datamapper Wikipedia, DataMapper]
# [http://pg-server.csc.ncsu.edu/mediawiki/index.php/CSC/ECE_517_Fall_2007/wiki2_2_22, Object-Relational Mapping Fall 2007]

CSC/ECE 517 Fall 2010/ch3 3j KS

2010-10-15T02:45:37Z

Kschidam: Updating References

='''Object-relational Mapping for Ruby'''=

__TOC__

=Introduction=

[http://en.wikipedia.org/wiki/Object-relational_mapping Object-relational mapping (ORM)] provides developers with a set of tools that ease management of the relationships between objects and relational databases, thus allowing applications to be easily extended to add data persistence. For Ruby, several object-relational mapping options are available. This wiki concentrates more on the comparison of ORM's and it gives a very high level overview of the various ORM's such as ActiveRecord , Sequel and DataMapper.

=Overview=

Object-relational Mapping (ORM) frameworks unburden the designer of the complex translation between database and object space.

Typical ORM features:
* Automatic mapping from classes to database tables
** Class instance variables to database columns
** Class instances to table rows
* Aggregation and association relationships between mapped classes are managed
** Example, :has_many, :belongs_to associations in ActiveRecord
** Inheritance cases are mapped to tables
* Validation of data prior to table storage
* Class extensions to enable search, as well as creation, read, update, and deletion (CRUD) of instances/records
* Usually abstracts the database from program space in such a way that alternate database types can be easily chosen (SQLite, Oracle, etc)

The diagram below depicts a simple mapping of an object to a database table….

[[Image:3j_ks_pic1.jpg]]

When applied to Ruby, implementations of ORM often leverage the language’s [http://en.wikipedia.org/wiki/Metaprogramming metaprogramming] strengths to create intuitive application-specific methods and otherwise extend classes to support database functionality.

=''' ActiveRecord '''=

[http://ar.rubyonrails.org/ ActiveRecord], originally created by David Heinemeier and released in 2003, became the de-facto ORM for Ruby since it was integrated in the widely-used Rails framework, however alternate ORMs for Ruby have been developed and Rails 3.x is ORM independent. ActiveRecord is an implementation of the active record design pattern, where a table is wrapped into a class and this class implements accessor methods for each column in the table. [http://en.wikipedia.org/wiki/Active_record_pattern [3]]

To create a table, ActiveRecord makes use of a migration class rather than including table definition in the actual class being modeled. As an example, the following code creates a table ‘’users’’ to store a collection of class ‘’User’’ objects:
<pre>
class CreateUsers < ActiveRecord::Migration
def self.up
create_table :users do |t|
t.string :name
t.string :email
t.string :age

t.timestamps # add creation and modification timestamps
end
end

def self.down # undo the table creation
drop_table :users
end
end
</pre>

Note in the preceeding example, that the ActiveRecord’s migration scheme provides a means for backing out changes via the ‘’self.down’’ method. In addition, a table key ‘’id’’ is added to the new table without explicit definition and record creation and modification timestamps are included via the ‘’timestamps’’ method provided by ActiveRecord.

ActiveRecord manages associations between table elements and provides the means to define such associations in the model definition. For example, the ‘’User’’ class shown below defines a ‘’to_many’’ association with both the cheers and posts tables. Also note ActiveRecord’s integrated support for validation of table information when attempting an update.

<pre>
class User < ActiveRecord::Base
has_many :cheers
has_many :posts

validates_presence_of :name
validates_presence_of :age
validates_uniqueness_of :name
validates_length_of :name, :within => 3..20
end
</pre>

While ActiveRecord provides the flexibility to create more sophisticated table relationships to represent class hierarchy, its base scheme is a single table inheritance, which trades some storage efficiency for simplicity in the database design.

[[Image:3j_ks_pic2.jpg]]

'''Pros''' -
* Integrated with popular Rails development framework
* Dynamically created database search methods (eg User.find_by_address) ease db queries and make queries database syntax independent
* DB creation/management using the migrate scheme provides a means for backing out unwanted table changes
'''Cons''' -
* DB creation/management is decoupled from the model, requiring a separate utility (rake/migrate) that must be kept in sync with application

='''Sequel'''=

[http://sequel.rubyforge.org Sequel] was originally developed by Sharon Rosner and the first release was in March 2007. It is based on the active record pattern. Sequel and Active record share a lot of common features , for example association and inheritance. But Sequel handles these features in a much more flexible manner. Currently Sequel is at version 3.16.0. Initially Sequel was had three core modules - sequel, sequel_core and sequel_model.Starting from version 1.4 , sequel and sequel_model were merged. Sequel handles validations using a validation plug-in and helpers.

Some of the key features of sequel are,
* Connection Pooling
* Thread Safety
* Eager Loading / Lazy Loading
* Model Caching

<pre>
class CreateUser < Sequel::Migration
def up
create_table(:user) {
primary_key :id
String :name
String :age}
end
def down
drop_table(:user)
end
end # CreateUser.apply(DB, :up)
</pre>

Sequel supports associations and validations similar to ActiveRecord. The following example shows how validations and associations can be enforced int he User table that has been created above. It enforces one to many relationship between the user table and the cheers , posts tables. It also validates for the presence , uniqueness and the length of the attribute 'name'.

<pre>
class User < Sequel::Model
one_to_many :cheers
one_to_many :posts

validates_presence [:name, :age]
validates_unique(:name)
validates_length_range 3..20, :name
end
</pre>

=''' DataMapper'''=

[http://datamapper.org/ DataMapper] is an open source ORM for Ruby originally developed by Sam Smoot and first released in 2007. DataMapper provides a very flexible mapping API which allows creation of adapters to a wide variety of datastores beyond traditional SQL-based relational databases – DataMapper adapters have been created to non-standard sources such as the Salesforce API and even Google Video. [http://merbist.com/2008/09/29/write-your-own-custom-datamapper-adapter/ [7]]

Some of the key features of DataMapper are:
* API supports a wide variety of databases, including non SQL types
* Thread Safety
* Eager loading of child associations
* Lazy loading

Unlike ActiveRecord and Sequel, DataMapper does not rely on a migration scheme to create and manage DB tables. Instead, DataMapper allows table definition as part of the model class definition which keeps the model definition contained to a single file, thus minimizing the effort required to keep the database and model definitions in sync. When required, DataMapper can also support a migration methodology similar to other ORMs.

Example of table definition in the model:
<pre>
class User
include DataMapper::Resource

property :id, Serial # key
property :name, String
property :password, String
property :age, String
property :created_at, DateTime

has n, :comments # one to many association

end
</pre>

=Comparison of ORM Features=

{|cellspacing="0" border="1"
!style="width:10%"|Features
!style="width:30%"|ActiveRecord
!style="width:30%"|Sequel
!style="width:30%"|DataMapper
|-
! Databases 
| MySQL, PostgreSQL, SQLite, Oracle, SQLServer, and DB2
| ADO, DataObjects, DB2, DBI, Firebird, Informix, JDBC, MySQL, ODBC, OpenBase, Oracle, PostgreSQL and SQLite3
| SQLite, MySQL, PostgreSQL, Oracle, MongoDB, SimpleDB, many others, including CouchDB, Apache Solr, Google Data API
|-
! Migrations 
| Yes
| Yes
| Yes, but optional
|-
! EagerLoading 
| Supported by scanning the SQL fragments
| Supported using eager (preloading) and eager_graph (joins)
| Supported
|-
! Flexible Overriding 
| No. Overriding is done using alias methods.
| Using methods and by calling 'super'
| Using methods (verify)
|-
! Dynamic Finders 
| Yes. Uses 'Method Missing'
| No. Alternative is to use <Model>.FindOrCreate(:name=>"John")
| Yes. Using the dm_ar_finders plugin
|}

 

=Further Reading=
To get more information on ORM and the different type of ORM's available for Ruby , please look into the [http://pg-server.csc.ncsu.edu/mediawiki/index.php/CSC/ECE_517_Fall_2007/wiki2_2_22, Object-relational mapping Fall 2007] wiki.

=References=

# [http://en.wikipedia.org/wiki/Object-relational_mapping Wikipedia, Object-relational mapping (ORM)]
# [http://ar.rubyonrails.org/ ActiveRecord]
# [http://en.wikipedia.org/wiki/Active_record_pattern Wikipedia, Active record pattern]
# [http://sequel.rubyforge.org/ Sequel]
# [http://jeremyevans-pres.heroku.com/mwrc2009_presentation.html Sequel Presentation - By Jeremy Evans]
# [http://datamapper.org/ DataMapper]
# [http://merbist.com/2008/09/29/write-your-own-custom-datamapper-adapter/ Merbist blog on custom DM adapters - By Matt Aimonetti]
# [http://en.wikipedia.org/wiki/Datamapper Wikipedia, DataMapper]
# [http://pg-server.csc.ncsu.edu/mediawiki/index.php/CSC/ECE_517_Fall_2007/wiki2_2_22, Object-Relational Mapping Fall 2007]

CSC/ECE 517 Fall 2010/ch3 3j KS

2010-10-15T02:40:52Z

Kschidam: Reference to past wiki

='''Object-relational Mapping for Ruby'''=

__TOC__

=Introduction=

[http://en.wikipedia.org/wiki/Object-relational_mapping Object-relational mapping (ORM)] provides developers with a set of tools that ease management of the relationships between objects and relational databases, thus allowing applications to be easily extended to add data persistence. For Ruby, several object-relational mapping options are available. This wiki concentrates more on the comparison of ORM's and it gives a very high level overview of the various ORM's such as ActiveRecord , Sequel and DataMapper.

=Overview=

Object-relational Mapping (ORM) frameworks unburden the designer of the complex translation between database and object space.

Typical ORM features:
* Automatic mapping from classes to database tables
** Class instance variables to database columns
** Class instances to table rows
* Aggregation and association relationships between mapped classes are managed
** Example, :has_many, :belongs_to associations in ActiveRecord
** Inheritance cases are mapped to tables
* Validation of data prior to table storage
* Class extensions to enable search, as well as creation, read, update, and deletion (CRUD) of instances/records
* Usually abstracts the database from program space in such a way that alternate database types can be easily chosen (SQLite, Oracle, etc)

The diagram below depicts a simple mapping of an object to a database table….

[[Image:3j_ks_pic1.jpg]]

When applied to Ruby, implementations of ORM often leverage the language’s [http://en.wikipedia.org/wiki/Metaprogramming metaprogramming] strengths to create intuitive application-specific methods and otherwise extend classes to support database functionality.

=''' ActiveRecord '''=

[http://ar.rubyonrails.org/ ActiveRecord], originally created by David Heinemeier and released in 2003, became the de-facto ORM for Ruby since it was integrated in the widely-used Rails framework, however alternate ORMs for Ruby have been developed and Rails 3.x is ORM independent. ActiveRecord is an implementation of the active record design pattern, where a table is wrapped into a class and this class implements accessor methods for each column in the table. [http://en.wikipedia.org/wiki/Active_record_pattern [3]]

To create a table, ActiveRecord makes use of a migration class rather than including table definition in the actual class being modeled. As an example, the following code creates a table ‘’users’’ to store a collection of class ‘’User’’ objects:
<pre>
class CreateUsers < ActiveRecord::Migration
def self.up
create_table :users do |t|
t.string :name
t.string :email
t.string :age

t.timestamps # add creation and modification timestamps
end
end

def self.down # undo the table creation
drop_table :users
end
end
</pre>

Note in the preceeding example, that the ActiveRecord’s migration scheme provides a means for backing out changes via the ‘’self.down’’ method. In addition, a table key ‘’id’’ is added to the new table without explicit definition and record creation and modification timestamps are included via the ‘’timestamps’’ method provided by ActiveRecord.

ActiveRecord manages associations between table elements and provides the means to define such associations in the model definition. For example, the ‘’User’’ class shown below defines a ‘’to_many’’ association with both the cheers and posts tables. Also note ActiveRecord’s integrated support for validation of table information when attempting an update.

<pre>
class User < ActiveRecord::Base
has_many :cheers
has_many :posts

validates_presence_of :name
validates_presence_of :age
validates_uniqueness_of :name
validates_length_of :name, :within => 3..20
end
</pre>

While ActiveRecord provides the flexibility to create more sophisticated table relationships to represent class hierarchy, its base scheme is a single table inheritance, which trades some storage efficiency for simplicity in the database design.

[[Image:3j_ks_pic2.jpg]]

'''Pros''' -
* Integrated with popular Rails development framework
* Dynamically created database search methods (eg User.find_by_address) ease db queries and make queries database syntax independent
* DB creation/management using the migrate scheme provides a means for backing out unwanted table changes
'''Cons''' -
* DB creation/management is decoupled from the model, requiring a separate utility (rake/migrate) that must be kept in sync with application

='''Sequel'''=

[http://sequel.rubyforge.org Sequel] was originally developed by Sharon Rosner and the first release was in March 2007. It is based on the active record pattern. Sequel and Active record share a lot of common features , for example association and inheritance. But Sequel handles these features in a much more flexible manner. Currently Sequel is at version 3.16.0. Initially Sequel was had three core modules - sequel, sequel_core and sequel_model.Starting from version 1.4 , sequel and sequel_model were merged. Sequel handles validations using a validation plug-in and helpers.

Some of the key features of sequel are,
* Connection Pooling
* Thread Safety
* Eager Loading / Lazy Loading
* Model Caching

<pre>
class CreateUser < Sequel::Migration
def up
create_table(:user) {
primary_key :id
String :name
String :age}
end
def down
drop_table(:user)
end
end # CreateUser.apply(DB, :up)
</pre>

Sequel supports associations and validations similar to ActiveRecord. The following example shows how validations and associations can be enforced int he User table that has been created above. It enforces one to many relationship between the user table and the cheers , posts tables. It also validates for the presence , uniqueness and the length of the attribute 'name'.

<pre>
class User < Sequel::Model
one_to_many :cheers
one_to_many :posts

validates_presence [:name, :age]
validates_unique(:name)
validates_length_range 3..20, :name
end
</pre>

=''' DataMapper'''=

[http://datamapper.org/ DataMapper] is an open source ORM for Ruby originally developed by Sam Smoot and first released in 2007. DataMapper provides a very flexible mapping API which allows creation of adapters to a wide variety of datastores beyond traditional SQL-based relational databases – DataMapper adapters have been created to non-standard sources such as the Salesforce API and even Google Video. [http://merbist.com/2008/09/29/write-your-own-custom-datamapper-adapter/ [7]]

Some of the key features of DataMapper are:
* API supports a wide variety of databases, including non SQL types
* Thread Safety
* Eager loading of child associations
* Lazy loading

Unlike ActiveRecord and Sequel, DataMapper does not rely on a migration scheme to create and manage DB tables. Instead, DataMapper allows table definition as part of the model class definition which keeps the model definition contained to a single file, thus minimizing the effort required to keep the database and model definitions in sync. When required, DataMapper can also support a migration methodology similar to other ORMs.

Example of table definition in the model:
<pre>
class User
include DataMapper::Resource

property :id, Serial # key
property :name, String
property :password, String
property :age, String
property :created_at, DateTime

has n, :comments # one to many association

end
</pre>

=Comparison of ORM Features=

{|cellspacing="0" border="1"
!style="width:10%"|Features
!style="width:30%"|ActiveRecord
!style="width:30%"|Sequel
!style="width:30%"|DataMapper
|-
! Databases 
| MySQL, PostgreSQL, SQLite, Oracle, SQLServer, and DB2
| ADO, DataObjects, DB2, DBI, Firebird, Informix, JDBC, MySQL, ODBC, OpenBase, Oracle, PostgreSQL and SQLite3
| SQLite, MySQL, PostgreSQL, Oracle, MongoDB, SimpleDB, many others, including CouchDB, Apache Solr, Google Data API
|-
! Migrations 
| Yes
| Yes
| Yes, but optional
|-
! EagerLoading 
| Supported by scanning the SQL fragments
| Supported using eager (preloading) and eager_graph (joins)
| Supported
|-
! Flexible Overriding 
| No. Overriding is done using alias methods.
| Using methods and by calling 'super'
| Using methods (verify)
|-
! Dynamic Finders 
| Yes. Uses 'Method Missing'
| No. Alternative is to use <Model>.FindOrCreate(:name=>"John")
| Yes. Using the dm_ar_finders plugin
|}

 

=Further Reading=
To get more information on ORM and the different type of ORM's available for Ruby , please look into the [http://pg-server.csc.ncsu.edu/mediawiki/index.php/CSC/ECE_517_Fall_2007/wiki2_2_22, Object-relational mapping Fall 2007] wiki.

=References=

[1] [http://en.wikipedia.org/wiki/Object-relational_mapping Wikipedia, Object-relational mapping (ORM)]

[2] [http://ar.rubyonrails.org/ ActiveRecord]

[3] [http://en.wikipedia.org/wiki/Active_record_pattern Wikipedia, Active record pattern]

[4] [http://sequel.rubyforge.org/ Sequel]

[5] [http://jeremyevans-pres.heroku.com/mwrc2009_presentation.html Sequel Presentation - By Jeremy Evans]

[6] [http://datamapper.org/ DataMapper]

[7] [http://merbist.com/2008/09/29/write-your-own-custom-datamapper-adapter/ Merbist blog on custom DM adapters - By Matt Aimonetti]

[8] [http://en.wikipedia.org/wiki/Datamapper Wikipedia, DataMapper]

[9] [http://pg-server.csc.ncsu.edu/mediawiki/index.php/CSC/ECE_517_Fall_2007/wiki2_2_22,

CSC/ECE 517 Fall 2010/ch3 3j KS

2010-10-15T02:36:52Z

Kschidam: /* Introduction */

='''Object-relational Mapping for Ruby'''=

__TOC__

=Introduction=

[http://en.wikipedia.org/wiki/Object-relational_mapping Object-relational mapping (ORM)] provides developers with a set of tools that ease management of the relationships between objects and relational databases, thus allowing applications to be easily extended to add data persistence. For Ruby, several object-relational mapping options are available. This wiki concentrates more on the comparison of ORM's and it gives a very high level overview of the various ORM's such as ActiveRecord , Sequel and DataMapper.

=Overview=

Object-relational Mapping (ORM) frameworks unburden the designer of the complex translation between database and object space.

Typical ORM features:
* Automatic mapping from classes to database tables
** Class instance variables to database columns
** Class instances to table rows
* Aggregation and association relationships between mapped classes are managed
** Example, :has_many, :belongs_to associations in ActiveRecord
** Inheritance cases are mapped to tables
* Validation of data prior to table storage
* Class extensions to enable search, as well as creation, read, update, and deletion (CRUD) of instances/records
* Usually abstracts the database from program space in such a way that alternate database types can be easily chosen (SQLite, Oracle, etc)

The diagram below depicts a simple mapping of an object to a database table….

[[Image:3j_ks_pic1.jpg]]

When applied to Ruby, implementations of ORM often leverage the language’s [http://en.wikipedia.org/wiki/Metaprogramming metaprogramming] strengths to create intuitive application-specific methods and otherwise extend classes to support database functionality.

=''' ActiveRecord '''=

[http://ar.rubyonrails.org/ ActiveRecord], originally created by David Heinemeier and released in 2003, became the de-facto ORM for Ruby since it was integrated in the widely-used Rails framework, however alternate ORMs for Ruby have been developed and Rails 3.x is ORM independent. ActiveRecord is an implementation of the active record design pattern, where a table is wrapped into a class and this class implements accessor methods for each column in the table. [http://en.wikipedia.org/wiki/Active_record_pattern [3]]

To create a table, ActiveRecord makes use of a migration class rather than including table definition in the actual class being modeled. As an example, the following code creates a table ‘’users’’ to store a collection of class ‘’User’’ objects:
<pre>
class CreateUsers < ActiveRecord::Migration
def self.up
create_table :users do |t|
t.string :name
t.string :email
t.string :age

t.timestamps # add creation and modification timestamps
end
end

def self.down # undo the table creation
drop_table :users
end
end
</pre>

Note in the preceeding example, that the ActiveRecord’s migration scheme provides a means for backing out changes via the ‘’self.down’’ method. In addition, a table key ‘’id’’ is added to the new table without explicit definition and record creation and modification timestamps are included via the ‘’timestamps’’ method provided by ActiveRecord.

ActiveRecord manages associations between table elements and provides the means to define such associations in the model definition. For example, the ‘’User’’ class shown below defines a ‘’to_many’’ association with both the cheers and posts tables. Also note ActiveRecord’s integrated support for validation of table information when attempting an update.

<pre>
class User < ActiveRecord::Base
has_many :cheers
has_many :posts

validates_presence_of :name
validates_presence_of :age
validates_uniqueness_of :name
validates_length_of :name, :within => 3..20
end
</pre>

While ActiveRecord provides the flexibility to create more sophisticated table relationships to represent class hierarchy, its base scheme is a single table inheritance, which trades some storage efficiency for simplicity in the database design.

[[Image:3j_ks_pic2.jpg]]

'''Pros''' -
* Integrated with popular Rails development framework
* Dynamically created database search methods (eg User.find_by_address) ease db queries and make queries database syntax independent
* DB creation/management using the migrate scheme provides a means for backing out unwanted table changes
'''Cons''' -
* DB creation/management is decoupled from the model, requiring a separate utility (rake/migrate) that must be kept in sync with application

='''Sequel'''=

[http://sequel.rubyforge.org Sequel] was originally developed by Sharon Rosner and the first release was in March 2007. It is based on the active record pattern. Sequel and Active record share a lot of common features , for example association and inheritance. But Sequel handles these features in a much more flexible manner. Currently Sequel is at version 3.16.0. Initially Sequel was had three core modules - sequel, sequel_core and sequel_model.Starting from version 1.4 , sequel and sequel_model were merged. Sequel handles validations using a validation plug-in and helpers.

Some of the key features of sequel are,
* Connection Pooling
* Thread Safety
* Eager Loading / Lazy Loading
* Model Caching

<pre>
class CreateUser < Sequel::Migration
def up
create_table(:user) {
primary_key :id
String :name
String :age}
end
def down
drop_table(:user)
end
end # CreateUser.apply(DB, :up)
</pre>

Sequel supports associations and validations similar to ActiveRecord. The following example shows how validations and associations can be enforced int he User table that has been created above. It enforces one to many relationship between the user table and the cheers , posts tables. It also validates for the presence , uniqueness and the length of the attribute 'name'.

<pre>
class User < Sequel::Model
one_to_many :cheers
one_to_many :posts

validates_presence [:name, :age]
validates_unique(:name)
validates_length_range 3..20, :name
end
</pre>

=''' DataMapper'''=

[http://datamapper.org/ DataMapper] is an open source ORM for Ruby originally developed by Sam Smoot and first released in 2007. DataMapper provides a very flexible mapping API which allows creation of adapters to a wide variety of datastores beyond traditional SQL-based relational databases – DataMapper adapters have been created to non-standard sources such as the Salesforce API and even Google Video. [http://merbist.com/2008/09/29/write-your-own-custom-datamapper-adapter/ [7]]

Some of the key features of DataMapper are:
* API supports a wide variety of databases, including non SQL types
* Thread Safety
* Eager loading of child associations
* Lazy loading

Unlike ActiveRecord and Sequel, DataMapper does not rely on a migration scheme to create and manage DB tables. Instead, DataMapper allows table definition as part of the model class definition which keeps the model definition contained to a single file, thus minimizing the effort required to keep the database and model definitions in sync. When required, DataMapper can also support a migration methodology similar to other ORMs.

Example of table definition in the model:
<pre>
class User
include DataMapper::Resource

property :id, Serial # key
property :name, String
property :password, String
property :age, String
property :created_at, DateTime

has n, :comments # one to many association

end
</pre>

=Comparison of ORM Features=

{|cellspacing="0" border="1"
!style="width:10%"|Features
!style="width:30%"|ActiveRecord
!style="width:30%"|Sequel
!style="width:30%"|DataMapper
|-
! Databases 
| MySQL, PostgreSQL, SQLite, Oracle, SQLServer, and DB2
| ADO, DataObjects, DB2, DBI, Firebird, Informix, JDBC, MySQL, ODBC, OpenBase, Oracle, PostgreSQL and SQLite3
| SQLite, MySQL, PostgreSQL, Oracle, MongoDB, SimpleDB, many others, including CouchDB, Apache Solr, Google Data API
|-
! Migrations 
| Yes
| Yes
| Yes, but optional
|-
! EagerLoading 
| Supported by scanning the SQL fragments
| Supported using eager (preloading) and eager_graph (joins)
| Supported
|-
! Flexible Overriding 
| No. Overriding is done using alias methods.
| Using methods and by calling 'super'
| Using methods (verify)
|-
! Dynamic Finders 
| Yes. Uses 'Method Missing'
| No. Alternative is to use <Model>.FindOrCreate(:name=>"John")
| Yes. Using the dm_ar_finders plugin
|}

 

=References=

[1] [http://en.wikipedia.org/wiki/Object-relational_mapping Wikipedia, Object-relational mapping (ORM)]

[2] [http://ar.rubyonrails.org/ ActiveRecord]

[3] [http://en.wikipedia.org/wiki/Active_record_pattern Wikipedia, Active record pattern]

[4] [http://sequel.rubyforge.org/ Sequel]

[5] [http://jeremyevans-pres.heroku.com/mwrc2009_presentation.html Sequel Presentation - By Jeremy Evans]

[6] [http://datamapper.org/ DataMapper]

[7] [http://merbist.com/2008/09/29/write-your-own-custom-datamapper-adapter/ Merbist blog on custom DM adapters - By Matt Aimonetti]

[8] [http://en.wikipedia.org/wiki/Datamapper Wikipedia, DataMapper]

CSC/ECE 517 Fall 2010/ch3 3j KS

2010-10-15T02:21:31Z

Kschidam: Adding Content to 'Sequel'

='''Object-relational Mapping for Ruby'''=

__TOC__

=Introduction=

[http://en.wikipedia.org/wiki/Object-relational_mapping Object-relational mapping (ORM)] provides developers with a set of tools that ease management of the relationships between objects and relational databases, thus allowing applications to be easily extended to add data persistence. For Ruby, several object-relational mapping options are available in addition to ActiveRecord, the ORM layer supplied with Rails.

=Overview=

Object-relational Mapping (ORM) frameworks unburden the designer of the complex translation between database and object space.

Typical ORM features:
* Automatic mapping from classes to database tables
** Class instance variables to database columns
** Class instances to table rows
* Aggregation and association relationships between mapped classes are managed
** Example, :has_many, :belongs_to associations in ActiveRecord
** Inheritance cases are mapped to tables
* Validation of data prior to table storage
* Class extensions to enable search, as well as creation, read, update, and deletion (CRUD) of instances/records
* Usually abstracts the database from program space in such a way that alternate database types can be easily chosen (SQLite, Oracle, etc)

The diagram below depicts a simple mapping of an object to a database table….

[[Image:3j_ks_pic1.jpg]]

When applied to Ruby, implementations of ORM often leverage the language’s [http://en.wikipedia.org/wiki/Metaprogramming metaprogramming] strengths to create intuitive application-specific methods and otherwise extend classes to support database functionality.

=''' ActiveRecord '''=

[http://ar.rubyonrails.org/ ActiveRecord], originally created by David Heinemeier and released in 2003, became the de-facto ORM for Ruby since it was integrated in the widely-used Rails framework, however alternate ORMs for Ruby have been developed and Rails 3.x is ORM independent. ActiveRecord is an implementation of the active record design pattern, where a table is wrapped into a class and this class implements accessor methods for each column in the table. [http://en.wikipedia.org/wiki/Active_record_pattern [3]]

To create a table, ActiveRecord makes use of a migration class rather than including table definition in the actual class being modeled. As an example, the following code creates a table ‘’users’’ to store a collection of class ‘’User’’ objects:
<pre>
class CreateUsers < ActiveRecord::Migration
def self.up
create_table :users do |t|
t.string :name
t.string :email
t.string :age

t.timestamps # add creation and modification timestamps
end
end

def self.down # undo the table creation
drop_table :users
end
end
</pre>

Note in the preceeding example, that the ActiveRecord’s migration scheme provides a means for backing out changes via the ‘’self.down’’ method. In addition, a table key ‘’id’’ is added to the new table without explicit definition and record creation and modification timestamps are included via the ‘’timestamps’’ method provided by ActiveRecord.

ActiveRecord manages associations between table elements and provides the means to define such associations in the model definition. For example, the ‘’User’’ class shown below defines a ‘’to_many’’ association with both the cheers and posts tables. Also note ActiveRecord’s integrated support for validation of table information when attempting an update.

<pre>
class User < ActiveRecord::Base
has_many :cheers
has_many :posts

validates_presence_of :name
validates_presence_of :age
validates_uniqueness_of :name
validates_length_of :name, :within => 3..20
end
</pre>

While ActiveRecord provides the flexibility to create more sophisticated table relationships to represent class hierarchy, its base scheme is a single table inheritance, which trades some storage efficiency for simplicity in the database design.

[[Image:3j_ks_pic2.jpg]]

'''Pros''' -
* Integrated with popular Rails development framework
* Dynamically created database search methods (eg User.find_by_address) ease db queries and make queries database syntax independent
* DB creation/management using the migrate scheme provides a means for backing out unwanted table changes
'''Cons''' -
* DB creation/management is decoupled from the model, requiring a separate utility (rake/migrate) that must be kept in sync with application

='''Sequel'''=

[http://sequel.rubyforge.org Sequel] was originally developed by Sharon Rosner and the first release was in March 2007. It is based on the active record pattern. Sequel and Active record share a lot of common features , for example association and inheritance. But Sequel handles these features in a much more flexible manner. Currently Sequel is at version 3.16.0. Initially Sequel was had three core modules - sequel, sequel_core and sequel_model.Starting from version 1.4 , sequel and sequel_model were merged. Sequel handles validations using a validation plug-in and helpers.

Some of the key features of sequel are,
* Connection Pooling
* Thread Safety
* Eager Loading / Lazy Loading
* Model Caching

<pre>
class CreateUser < Sequel::Migration
def up
create_table(:user) {
primary_key :id
String :name
String :age}
end
def down
drop_table(:user)
end
end # CreateUser.apply(DB, :up)
</pre>

Sequel supports associations and validations similar to ActiveRecord. The following example shows how validations and associations can be enforced int he User table that has been created above. It enforces one to many relationship between the user table and the cheers , posts tables. It also validates for the presence , uniqueness and the length of the attribute 'name'.

<pre>
class User < Sequel::Model
one_to_many :cheers
one_to_many :posts

validates_presence [:name, :age]
validates_unique(:name)
validates_length_range 3..20, :name
end
</pre>

=''' DataMapper'''=

[http://datamapper.org/ DataMapper] is an open source ORM for Ruby originally developed by Sam Smoot and first released in 2007. DataMapper provides a very flexible mapping API which allows creation of adapters to a wide variety of datastores beyond traditional SQL-based relational databases – DataMapper adapters have been created to non-standard sources such as the Salesforce API and even Google Video. [http://merbist.com/2008/09/29/write-your-own-custom-datamapper-adapter/ [7]]

Some of the key features of DataMapper are:
* API supports a wide variety of databases, including non SQL types
* Thread Safety
* Eager loading of child associations
* Lazy loading

Unlike ActiveRecord and Sequel, DataMapper does not rely on a migration scheme to create and manage DB tables. Instead, DataMapper allows table definition as part of the model class definition which keeps the model definition contained to a single file, thus minimizing the effort required to keep the database and model definitions in sync. When required, DataMapper can also support a migration methodology similar to other ORMs.

Example of table definition in the model:
<pre>
class User
include DataMapper::Resource

property :id, Serial # key
property :name, String
property :password, String
property :age, String
property :created_at, DateTime

has n, :comments # one to many association

end
</pre>

=Comparison of ORM Features=

{|cellspacing="0" border="1"
!style="width:10%"|Features
!style="width:30%"|ActiveRecord
!style="width:30%"|Sequel
!style="width:30%"|DataMapper
|-
! Databases 
| MySQL, PostgreSQL, SQLite, Oracle, SQLServer, and DB2
| ADO, DataObjects, DB2, DBI, Firebird, Informix, JDBC, MySQL, ODBC, OpenBase, Oracle, PostgreSQL and SQLite3
| SQLite, MySQL, PostgreSQL, Oracle, MongoDB, SimpleDB, many others, including CouchDB, Apache Solr, Google Data API
|-
! Migrations 
| Yes
| Yes
| Yes, but optional
|-
! EagerLoading 
| Supported by scanning the SQL fragments
| Supported using eager (preloading) and eager_graph (joins)
| Supported
|-
! Flexible Overriding 
| No. Overriding is done using alias methods.
| Using methods and by calling 'super'
| Using methods (verify)
|-
! Dynamic Finders 
| Yes. Uses 'Method Missing'
| No. Alternative is to use <Model>.FindOrCreate(:name=>"John")
| Yes. Using the dm_ar_finders plugin
|}

 

=References=

[1] [http://en.wikipedia.org/wiki/Object-relational_mapping Wikipedia, Object-relational mapping (ORM)]

[2] [http://ar.rubyonrails.org/ ActiveRecord]

[3] [http://en.wikipedia.org/wiki/Active_record_pattern Wikipedia, Active record pattern]

[4] [http://sequel.rubyforge.org/ Sequel]

[5] [http://jeremyevans-pres.heroku.com/mwrc2009_presentation.html Sequel Presentation - By Jeremy Evans]

[6] [http://datamapper.org/ DataMapper]

[7] [http://merbist.com/2008/09/29/write-your-own-custom-datamapper-adapter/ Merbist blog on custom DM adapters - By Matt Aimonetti]

[8] [http://en.wikipedia.org/wiki/Datamapper Wikipedia, DataMapper]

CSC/ECE 517 Fall 2010/ch3 3j KS

2010-10-05T01:30:03Z

Kschidam: /* '''Sequel'''= */

='''Object-relational Mapping for Ruby'''=

__TOC__

=Introduction=

[http://en.wikipedia.org/wiki/Object-relational_mapping Object-relational mapping (ORM)] provides developers with a set of tools that ease management of the relationships between objects and relational databases, thus allowing applications to be easily extended to add data persistence. For Ruby, several object-relational mapping options are available in addition to ActiveRecord, the ORM layer supplied with Rails.

=Overview=

Object-relational Mapping (ORM) frameworks unburden the designer of the complex translation between database and object space.

Typical ORM features:
* Automatic mapping from classes to database tables
** Class instance variables to database columns
** Class instances to table rows
* Aggregation and association relationships between mapped classes are managed
** Example, :has_many, :belongs_to associations in ActiveRecord
** Inheritance cases are mapped to tables
* Validation of data prior to table storage
* Class extensions to enable search, as well as creation, read, update, and deletion (CRUD) of instances/records
* Usually abstracts the database from program space in such a way that alternate database types can be easily chosen (SQLite, Oracle, etc)

The diagram below depicts a simple mapping of an object to a database table….

[[Image:3j_ks_pic1.jpg]]

When applied to Ruby, implementations of ORM often leverage the language’s [http://en.wikipedia.org/wiki/Metaprogramming metaprogramming] strengths to create intuitive application-specific methods and otherwise extend classes to support database functionality.

=''' ActiveRecord '''=

[http://ar.rubyonrails.org/ ActiveRecord], originally created by David Heinemeier and released in 2003, became the de-facto ORM for Ruby since it was integrated in the widely-used Rails framework, however alternate ORMs for Ruby have been developed and Rails 3.x is ORM independent. ActiveRecord is an implementation of the active record design pattern, where a table is wrapped into a class and this class implements accessor methods for each column in the table. [http://en.wikipedia.org/wiki/Active_record_pattern]

To create a table, ActiveRecord makes use of a migration class rather than including table definition in the actual class being modeled. As an example, the following code creates a table ‘’users’’ to store a collection of class ‘’User’’ objects:
<pre>
class CreateUsers < ActiveRecord::Migration
def self.up
create_table :users do |t|
t.string :name
t.string :email
t.integer :age

t.timestamps # add creation and modification timestamps
end
end

def self.down # undo the table creation
drop_table :users
end
end
</pre>

Note in the preceeding example, that the ActiveRecord’s migration scheme provides a means for backing out changes via the ‘’self.down’’ method. In addition, a table key ‘’id’’ is added to the new table without explicit definition and record creation and modification timestamps are included via the ‘’timestamps’’ method provided by ActiveRecord.

ActiveRecord manages associations between table elements and provides the means to define such associations in the model definition. For example, the ‘’User’’ class shown below defines a ‘’to_many’’ association with both the cheers and posts tables. Also note ActiveRecord’s integrated support for validation of table information when attempting an update.

<pre>
class User < ActiveRecord::Base

has_many :cheers
has_many :posts

validates_presence_of :name
validates_uniqueness_of :name
validates_length_of :name, :within => 3..20
end
</pre>

While ActiveRecord provides the flexibility to create more sophisticated table relationships to represent class hierarchy, its base scheme is a single table inheritance, which trades some storage efficiency for simplicity in the database design.

[[Image:3j_ks_pic2.jpg]]

'''Pros''' -
* Integrated with popular Rails development framework
* Dynamically created database search methods (eg User.find_by_address) ease db queries and make queries database syntax independent
* DB creation/management using the migrate scheme provides a means for backing out unwanted table changes
'''Cons''' -
* DB creation/management is decoupled from the model, requiring a separate utility (rake/migrate) that must be kept in sync with application

='''Sequel'''=

[http://sequel.rubyforge.org Sequel] was originally developed by Sharon Rosner and the first release was in March 2007. It is based on the active record pattern. Sequel and Active record share a lot of common features , for example association and inheritance. But Sequel handles these features in a much more flexible manner. Currently Sequel is at version 3.16.0. Initially Sequel was had three core modules - sequel, sequel_core and sequel_model.Starting from version 1.4 , sequel and sequel_model were merged. Sequel handles validations using a validation plug-in and helpers.

Some of the key features of sequel are,
* Connection Pooling
* Thread Safety
* Eager Loading / Lazy Loading
* Model Caching

<pre>
class CreateUser < Sequel::Migration
def up
create_table(:user) {
primary_key :id
String :name
String :password }
end
def down
drop_table(:user)
end
end # CreateUser.apply(DB, :up)
</pre>

=''' DataMapper'''=
http://www.gelens.org/2007/12/13/ruby_orm_datamapper/
Ruby ORM: DataMapper
There is a relative new ORM (Object Relational Mapper) for Ruby called “DataMapper”. Its goal is to create a fast, feature rich and thread-safe(!) ORM. DataMapper can be used standalone or as plugin for example Rails or Merb.
Finally some competition in the Ruby ORM world. Rails’ ActiveRecord is no longer the only usable production ORM. DataMapper’s developers made some radical different fundamental design decisions regarding to migrations and property declarations. Property declarations are now done in the Model itself and not in separate “migration”-files. Which is more elegant in my opinion.
Lately DataMapper is growing fast, it gets more attention and its feature list gets longer and is already superior to AR in terms of speed. A few weeks ago I started a new project using the new ruby framework Merb. Merb is also thread-safe and is in combination with DataMapper a really cool framework. By the way, did you know Rails is not thread-safe? Kinda sucky for a web framework to handle only one connection at a time. That’s the reason why people use multiple Mongrel servers when deploying Rails application. Not everyone I know seems to realize that. The bad thing is, there is NO plan to make it thread-safe :-/.
[http://blog.mattwynne.net/2008/05/23/datamapper-a-better-orm-for-ruby/]
DataMapper: A Better ORM for Ruby
One of the things that’s always irritated my about rails’ ActiveRecord framework is the way that the domain model lives in the database.Don’t get me wrong: it’s very clever, and a great showcase for ruby’s metaprogramming features, which will blow average C# / Java mind the mind when they first see it.
In rails, you build a database of your domain model, and create empty classes with the names of the domain entities (conventionally the singular of a database table name) which inherit from ActiveRecord. ActiveRecord then looks at your database, and using the magic of metaprogramming, hydrates your object with a bunch of properties that map to the database fields.
But I prefer to write my models in the code, and if you do too, you might want to take a look at DataMapper.

=Comparison of ORM Features=

{|cellspacing="0" border="1"
!style="width:10%"|Features
!style="width:30%"|ActiveRecord
!style="width:30%"|Sequel
!style="width:30%"|DataMapper
|-
! Databases 
| MySQL, PostgreSQL, SQLite, Oracle, SQLServer, and DB2
| ADO, DataObjects, DB2, DBI, Firebird, Informix, JDBC, MySQL, ODBC, OpenBase, Oracle, PostgreSQL and SQLite3
| N/A
|-
! Migrations 
| Yes
| Yes
| No
|-
! EagerLoading 
| Supported by scanning the SQL fragments
| Supported using eager (preloading) and eager_graph (joins)
| N/A
|-
! Flexible Overriding 
| No. Overriding is done using alias methods.
| Using methods and by calling 'super'
| N/A
|-
! Dynamic Finders 
| Yes. Uses 'Method Missing'
| No. Alternative is to use <Model>.FindOrCreate(:name=>"John")
| N/A
|}

 

=References=

[1] [http://ruby-doc.org/ Ruby language]

[2] [http://ar.rubyonrails.org/ Active Record]

[3] [http://sequel.rubyforge.org/ Sequel]

[4] [http://jeremyevans-pres.heroku.com/mwrc2009_presentation.html Sequel Presentation - By Jeremy Evans]

CSC/ECE 517 Fall 2010/ch3 3j KS

2010-10-05T01:29:52Z

Kschidam:

='''Object-relational Mapping for Ruby'''=

__TOC__

=Introduction=

[http://en.wikipedia.org/wiki/Object-relational_mapping Object-relational mapping (ORM)] provides developers with a set of tools that ease management of the relationships between objects and relational databases, thus allowing applications to be easily extended to add data persistence. For Ruby, several object-relational mapping options are available in addition to ActiveRecord, the ORM layer supplied with Rails.

=Overview=

Object-relational Mapping (ORM) frameworks unburden the designer of the complex translation between database and object space.

Typical ORM features:
* Automatic mapping from classes to database tables
** Class instance variables to database columns
** Class instances to table rows
* Aggregation and association relationships between mapped classes are managed
** Example, :has_many, :belongs_to associations in ActiveRecord
** Inheritance cases are mapped to tables
* Validation of data prior to table storage
* Class extensions to enable search, as well as creation, read, update, and deletion (CRUD) of instances/records
* Usually abstracts the database from program space in such a way that alternate database types can be easily chosen (SQLite, Oracle, etc)

The diagram below depicts a simple mapping of an object to a database table….

[[Image:3j_ks_pic1.jpg]]

When applied to Ruby, implementations of ORM often leverage the language’s [http://en.wikipedia.org/wiki/Metaprogramming metaprogramming] strengths to create intuitive application-specific methods and otherwise extend classes to support database functionality.

=''' ActiveRecord '''=

[http://ar.rubyonrails.org/ ActiveRecord], originally created by David Heinemeier and released in 2003, became the de-facto ORM for Ruby since it was integrated in the widely-used Rails framework, however alternate ORMs for Ruby have been developed and Rails 3.x is ORM independent. ActiveRecord is an implementation of the active record design pattern, where a table is wrapped into a class and this class implements accessor methods for each column in the table. [http://en.wikipedia.org/wiki/Active_record_pattern]

To create a table, ActiveRecord makes use of a migration class rather than including table definition in the actual class being modeled. As an example, the following code creates a table ‘’users’’ to store a collection of class ‘’User’’ objects:
<pre>
class CreateUsers < ActiveRecord::Migration
def self.up
create_table :users do |t|
t.string :name
t.string :email
t.integer :age

t.timestamps # add creation and modification timestamps
end
end

def self.down # undo the table creation
drop_table :users
end
end
</pre>

Note in the preceeding example, that the ActiveRecord’s migration scheme provides a means for backing out changes via the ‘’self.down’’ method. In addition, a table key ‘’id’’ is added to the new table without explicit definition and record creation and modification timestamps are included via the ‘’timestamps’’ method provided by ActiveRecord.

ActiveRecord manages associations between table elements and provides the means to define such associations in the model definition. For example, the ‘’User’’ class shown below defines a ‘’to_many’’ association with both the cheers and posts tables. Also note ActiveRecord’s integrated support for validation of table information when attempting an update.

<pre>
class User < ActiveRecord::Base

has_many :cheers
has_many :posts

validates_presence_of :name
validates_uniqueness_of :name
validates_length_of :name, :within => 3..20
end
</pre>

While ActiveRecord provides the flexibility to create more sophisticated table relationships to represent class hierarchy, its base scheme is a single table inheritance, which trades some storage efficiency for simplicity in the database design.

[[Image:3j_ks_pic2.jpg]]

'''Pros''' -
* Integrated with popular Rails development framework
* Dynamically created database search methods (eg User.find_by_address) ease db queries and make queries database syntax independent
* DB creation/management using the migrate scheme provides a means for backing out unwanted table changes
'''Cons''' -
* DB creation/management is decoupled from the model, requiring a separate utility (rake/migrate) that must be kept in sync with application

='''Sequel'''==

[http://sequel.rubyforge.org Sequel] was originally developed by Sharon Rosner and the first release was in March 2007. It is based on the active record pattern. Sequel and Active record share a lot of common features , for example association and inheritance. But Sequel handles these features in a much more flexible manner. Currently Sequel is at version 3.16.0. Initially Sequel was had three core modules - sequel, sequel_core and sequel_model.Starting from version 1.4 , sequel and sequel_model were merged. Sequel handles validations using a validation plug-in and helpers.

Some of the key features of sequel are,
* Connection Pooling
* Thread Safety
* Eager Loading / Lazy Loading
* Model Caching

<pre>
class CreateUser < Sequel::Migration
def up
create_table(:user) {
primary_key :id
String :name
String :password }
end
def down
drop_table(:user)
end
end # CreateUser.apply(DB, :up)
</pre>

=''' DataMapper'''=
http://www.gelens.org/2007/12/13/ruby_orm_datamapper/
Ruby ORM: DataMapper
There is a relative new ORM (Object Relational Mapper) for Ruby called “DataMapper”. Its goal is to create a fast, feature rich and thread-safe(!) ORM. DataMapper can be used standalone or as plugin for example Rails or Merb.
Finally some competition in the Ruby ORM world. Rails’ ActiveRecord is no longer the only usable production ORM. DataMapper’s developers made some radical different fundamental design decisions regarding to migrations and property declarations. Property declarations are now done in the Model itself and not in separate “migration”-files. Which is more elegant in my opinion.
Lately DataMapper is growing fast, it gets more attention and its feature list gets longer and is already superior to AR in terms of speed. A few weeks ago I started a new project using the new ruby framework Merb. Merb is also thread-safe and is in combination with DataMapper a really cool framework. By the way, did you know Rails is not thread-safe? Kinda sucky for a web framework to handle only one connection at a time. That’s the reason why people use multiple Mongrel servers when deploying Rails application. Not everyone I know seems to realize that. The bad thing is, there is NO plan to make it thread-safe :-/.
[http://blog.mattwynne.net/2008/05/23/datamapper-a-better-orm-for-ruby/]
DataMapper: A Better ORM for Ruby
One of the things that’s always irritated my about rails’ ActiveRecord framework is the way that the domain model lives in the database.Don’t get me wrong: it’s very clever, and a great showcase for ruby’s metaprogramming features, which will blow average C# / Java mind the mind when they first see it.
In rails, you build a database of your domain model, and create empty classes with the names of the domain entities (conventionally the singular of a database table name) which inherit from ActiveRecord. ActiveRecord then looks at your database, and using the magic of metaprogramming, hydrates your object with a bunch of properties that map to the database fields.
But I prefer to write my models in the code, and if you do too, you might want to take a look at DataMapper.

=Comparison of ORM Features=

{|cellspacing="0" border="1"
!style="width:10%"|Features
!style="width:30%"|ActiveRecord
!style="width:30%"|Sequel
!style="width:30%"|DataMapper
|-
! Databases 
| MySQL, PostgreSQL, SQLite, Oracle, SQLServer, and DB2
| ADO, DataObjects, DB2, DBI, Firebird, Informix, JDBC, MySQL, ODBC, OpenBase, Oracle, PostgreSQL and SQLite3
| N/A
|-
! Migrations 
| Yes
| Yes
| No
|-
! EagerLoading 
| Supported by scanning the SQL fragments
| Supported using eager (preloading) and eager_graph (joins)
| N/A
|-
! Flexible Overriding 
| No. Overriding is done using alias methods.
| Using methods and by calling 'super'
| N/A
|-
! Dynamic Finders 
| Yes. Uses 'Method Missing'
| No. Alternative is to use <Model>.FindOrCreate(:name=>"John")
| N/A
|}

 

=References=

[1] [http://ruby-doc.org/ Ruby language]

[2] [http://ar.rubyonrails.org/ Active Record]

[3] [http://sequel.rubyforge.org/ Sequel]

[4] [http://jeremyevans-pres.heroku.com/mwrc2009_presentation.html Sequel Presentation - By Jeremy Evans]

CSC/ECE 517 Fall 2010/ch3 3j KS

2010-10-05T01:29:17Z

Kschidam:

='''Object-relational Mapping for Ruby'''=

__TOC__

=Introduction=

[http://en.wikipedia.org/wiki/Object-relational_mapping Object-relational mapping (ORM)] provides developers with a set of tools that ease management of the relationships between objects and relational databases, thus allowing applications to be easily extended to add data persistence. For Ruby, several object-relational mapping options are available in addition to ActiveRecord, the ORM layer supplied with Rails.

=Overview=

Object-relational Mapping (ORM) frameworks unburden the designer of the complex translation between database and object space.

Typical ORM features:
* Automatic mapping from classes to database tables
** Class instance variables to database columns
** Class instances to table rows
* Aggregation and association relationships between mapped classes are managed
** Example, :has_many, :belongs_to associations in ActiveRecord
** Inheritance cases are mapped to tables
* Validation of data prior to table storage
* Class extensions to enable search, as well as creation, read, update, and deletion (CRUD) of instances/records
* Usually abstracts the database from program space in such a way that alternate database types can be easily chosen (SQLite, Oracle, etc)

The diagram below depicts a simple mapping of an object to a database table….

[[Image:3j_ks_pic1.jpg]]

When applied to Ruby, implementations of ORM often leverage the language’s [http://en.wikipedia.org/wiki/Metaprogramming metaprogramming] strengths to create intuitive application-specific methods and otherwise extend classes to support database functionality.

=''' ActiveRecord '''=

[http://ar.rubyonrails.org/ ActiveRecord], originally created by David Heinemeier and released in 2003, became the de-facto ORM for Ruby since it was integrated in the widely-used Rails framework, however alternate ORMs for Ruby have been developed and Rails 3.x is ORM independent. ActiveRecord is an implementation of the active record design pattern, where a table is wrapped into a class and this class implements accessor methods for each column in the table. [http://en.wikipedia.org/wiki/Active_record_pattern]

To create a table, ActiveRecord makes use of a migration class rather than including table definition in the actual class being modeled. As an example, the following code creates a table ‘’users’’ to store a collection of class ‘’User’’ objects:
<pre>
class CreateUsers < ActiveRecord::Migration
def self.up
create_table :users do |t|
t.string :name
t.string :email
t.integer :age

t.timestamps # add creation and modification timestamps
end
end

def self.down # undo the table creation
drop_table :users
end
end
</pre>

Note in the preceeding example, that the ActiveRecord’s migration scheme provides a means for backing out changes via the ‘’self.down’’ method. In addition, a table key ‘’id’’ is added to the new table without explicit definition and record creation and modification timestamps are included via the ‘’timestamps’’ method provided by ActiveRecord.

ActiveRecord manages associations between table elements and provides the means to define such associations in the model definition. For example, the ‘’User’’ class shown below defines a ‘’to_many’’ association with both the cheers and posts tables. Also note ActiveRecord’s integrated support for validation of table information when attempting an update.

<pre>
class User < ActiveRecord::Base

has_many :cheers
has_many :posts

validates_presence_of :name
validates_uniqueness_of :name
validates_length_of :name, :within => 3..20
end
</pre>

While ActiveRecord provides the flexibility to create more sophisticated table relationships to represent class hierarchy, its base scheme is a single table inheritance, which trades some storage efficiency for simplicity in the database design.

[[Image:3j_ks_pic2.jpg]]

'''Pros''' -
* Integrated with popular Rails development framework
* Dynamically created database search methods (eg User.find_by_address) ease db queries and make queries database syntax independent
* DB creation/management using the migrate scheme provides a means for backing out unwanted table changes
'''Cons''' -
* DB creation/management is decoupled from the model, requiring a separate utility (rake/migrate) that must be kept in sync with application

='''Sequel'''==

[http://sequel.rubyforge.org Sequel] was originally developed by Sharon Rosner and the first release was in March 2007. It is based on the active record pattern. Sequel and Active record share a lot of common features , for example association and inheritance. But Sequel handles these features in a much more flexible manner. Currently Sequel is at version 3.16.0. Initially Sequel was had three core modules - sequel, sequel_core and sequel_model.Starting from version 1.4 , sequel and sequel_model were merged. Sequel handles validations using a validation plug-in and helpers.

Some of the key features of sequel are,
* Connection Pooling
* Thread Safety
* Eager Loading / Lazy Loading
* Model Caching

<pre>
class CreateUser < Sequel::Migration
def up
create_table(:user) {
primary_key :id
String :name
String :password }
end
def down
drop_table(:user)
end
end # CreateUser.apply(DB, :up)
</pre>

=''' DataMapper'''=
http://www.gelens.org/2007/12/13/ruby_orm_datamapper/
Ruby ORM: DataMapper
There is a relative new ORM (Object Relational Mapper) for Ruby called “DataMapper”. Its goal is to create a fast, feature rich and thread-safe(!) ORM. DataMapper can be used standalone or as plugin for example Rails or Merb.
Finally some competition in the Ruby ORM world. Rails’ ActiveRecord is no longer the only usable production ORM. DataMapper’s developers made some radical different fundamental design decisions regarding to migrations and property declarations. Property declarations are now done in the Model itself and not in separate “migration”-files. Which is more elegant in my opinion.
Lately DataMapper is growing fast, it gets more attention and its feature list gets longer and is already superior to AR in terms of speed. A few weeks ago I started a new project using the new ruby framework Merb. Merb is also thread-safe and is in combination with DataMapper a really cool framework. By the way, did you know Rails is not thread-safe? Kinda sucky for a web framework to handle only one connection at a time. That’s the reason why people use multiple Mongrel servers when deploying Rails application. Not everyone I know seems to realize that. The bad thing is, there is NO plan to make it thread-safe :-/.
[http://blog.mattwynne.net/2008/05/23/datamapper-a-better-orm-for-ruby/]
DataMapper: A Better ORM for Ruby
One of the things that’s always irritated my about rails’ ActiveRecord framework is the way that the domain model lives in the database.Don’t get me wrong: it’s very clever, and a great showcase for ruby’s metaprogramming features, which will blow average C# / Java mind the mind when they first see it.
In rails, you build a database of your domain model, and create empty classes with the names of the domain entities (conventionally the singular of a database table name) which inherit from ActiveRecord. ActiveRecord then looks at your database, and using the magic of metaprogramming, hydrates your object with a bunch of properties that map to the database fields.
But I prefer to write my models in the code, and if you do too, you might want to take a look at DataMapper.

=Comparison of ORM Features=

{|cellspacing="0" border="1"
!style="width:10%"|Features
!style="width:30%"|ActiveRecord
!style="width:30%"|Sequel
!style="width:30%"|DataMapper
|-
! Databases 
| MySQL, PostgreSQL, SQLite, Oracle, SQLServer, and DB2
| ADO, DataObjects, DB2, DBI, Firebird, Informix, JDBC, MySQL, ODBC, OpenBase, Oracle, PostgreSQL and SQLite3
| N/A
|-
! Migrations 
| Yes
| Yes
| No
|-
! EagerLoading 
| Supported by scanning the SQL fragments
| Supported using eager (preloading) and eager_graph (joins)
| N/A
|-
! Flexible Overriding 
| No. Overriding is done using alias methods.
| Using methods and by calling 'super'
| N/A
|-
! Dynamic Finders 
| Yes. Uses 'Method Missing'
| No. Alternative is to use <Model>.FindOrCreate(:name=>"John")
| N/A
|}

 

=References=

[1] [http://ruby-doc.org/ Ruby language]

[2] [www.rubygarden.org/faq Fowler, C., The Ruby FAQ]

[3] [http://ar.rubyonrails.org/ Active Record]

[4] [http://sequel.rubyforge.org/ Sequel]

[5] [http://jeremyevans-pres.heroku.com/mwrc2009_presentation.html Sequel Presentation - By Jeremy Evans]

==External Links==

#[http://wxruby.rubyforge.org/wiki/wiki.pl WxRuby]
#[http://www.activestate.com/activetcl ActiveTcl for Windows]

CSC/ECE 517 Fall 2010/ch3 3j KS

2010-10-05T01:22:11Z

Kschidam: /* Comparison of ORM Features */

='''Object-relational Mapping for Ruby'''=

__TOC__

=Introduction=

[http://en.wikipedia.org/wiki/Object-relational_mapping Object-relational mapping (ORM)] provides developers with a set of tools that ease management of the relationships between objects and relational databases, thus allowing applications to be easily extended to add data persistence. For Ruby, several object-relational mapping options are available in addition to ActiveRecord, the ORM layer supplied with Rails.

=Overview=

Object-relational Mapping (ORM) frameworks unburden the designer of the complex translation between database and object space.

Typical ORM features:
* Automatic mapping from classes to database tables
** Class instance variables to database columns
** Class instances to table rows
* Aggregation and association relationships between mapped classes are managed
** Example, :has_many, :belongs_to associations in ActiveRecord
** Inheritance cases are mapped to tables
* Validation of data prior to table storage
* Class extensions to enable search, as well as creation, read, update, and deletion (CRUD) of instances/records
* Usually abstracts the database from program space in such a way that alternate database types can be easily chosen (SQLite, Oracle, etc)

The diagram below depicts a simple mapping of an object to a database table….

[[Image:3j_ks_pic1.jpg]]

When applied to Ruby, implementations of ORM often leverage the language’s [http://en.wikipedia.org/wiki/Metaprogramming metaprogramming] strengths to create intuitive application-specific methods and otherwise extend classes to support database functionality.

=Comparison of ORM products for Ruby=

==''' ActiveRecord '''==

[http://ar.rubyonrails.org/ ActiveRecord], originally created by David Heinemeier and released in 2003, became the de-facto ORM for Ruby since it was integrated in the widely-used Rails framework, however alternate ORMs for Ruby have been developed and Rails 3.x is ORM independent. ActiveRecord is an implementation of the active record design pattern, where a table is wrapped into a class and this class implements accessor methods for each column in the table. [http://en.wikipedia.org/wiki/Active_record_pattern]

To create a table, ActiveRecord makes use of a migration class rather than including table definition in the actual class being modeled. As an example, the following code creates a table ‘’users’’ to store a collection of class ‘’User’’ objects:
<pre>
class CreateUsers < ActiveRecord::Migration
def self.up
create_table :users do |t|
t.string :name
t.string :email
t.integer :age

t.timestamps # add creation and modification timestamps
end
end

def self.down # undo the table creation
drop_table :users
end
end
</pre>

Note in the preceeding example, that the ActiveRecord’s migration scheme provides a means for backing out changes via the ‘’self.down’’ method. In addition, a table key ‘’id’’ is added to the new table without explicit definition and record creation and modification timestamps are included via the ‘’timestamps’’ method provided by ActiveRecord.

ActiveRecord manages associations between table elements and provides the means to define such associations in the model definition. For example, the ‘’User’’ class shown below defines a ‘’to_many’’ association with both the cheers and posts tables. Also note ActiveRecord’s integrated support for validation of table information when attempting an update.

<pre>
class User < ActiveRecord::Base

has_many :cheers
has_many :posts

validates_presence_of :name
validates_uniqueness_of :name
validates_length_of :name, :within => 3..20
end
</pre>

While ActiveRecord provides the flexibility to create more sophisticated table relationships to represent class hierarchy, its base scheme is a single table inheritance, which trades some storage efficiency for simplicity in the database design.

[[Image:3j_ks_pic2.jpg]]

'''Pros''' -
* Integrated with popular Rails development framework
* Dynamically created database search methods (eg User.find_by_address) ease db queries and make queries database syntax independent
* DB creation/management using the migrate scheme provides a means for backing out unwanted table changes
'''Cons''' -
* DB creation/management is decoupled from the model, requiring a separate utility (rake/migrate) that must be kept in sync with application

=='''Sequel'''==

[http://sequel.rubyforge.org Sequel] was originally developed by Sharon Rosner and the first release was in March 2007. It is based on the active record pattern. Sequel and Active record share a lot of common features , for example association and inheritance. But Sequel handles these features in a much more flexible manner. Currently Sequel is at version 3.16.0. Initially Sequel was had three core modules - sequel, sequel_core and sequel_model.Starting from version 1.4 , sequel and sequel_model were merged. Sequel handles validations using a validation plug-in and helpers.

Some of the key features of sequel are,
* Connection Pooling
* Thread Safety
* Eager Loading / Lazy Loading
* Model Caching

<pre>
class CreateUser < Sequel::Migration
def up
create_table(:user) {
primary_key :id
String :name
String :password }
end
def down
drop_table(:user)
end
end # CreateUser.apply(DB, :up)
</pre>

==''' DataMapper'''==
http://www.gelens.org/2007/12/13/ruby_orm_datamapper/
Ruby ORM: DataMapper
There is a relative new ORM (Object Relational Mapper) for Ruby called “DataMapper”. Its goal is to create a fast, feature rich and thread-safe(!) ORM. DataMapper can be used standalone or as plugin for example Rails or Merb.
Finally some competition in the Ruby ORM world. Rails’ ActiveRecord is no longer the only usable production ORM. DataMapper’s developers made some radical different fundamental design decisions regarding to migrations and property declarations. Property declarations are now done in the Model itself and not in separate “migration”-files. Which is more elegant in my opinion.
Lately DataMapper is growing fast, it gets more attention and its feature list gets longer and is already superior to AR in terms of speed. A few weeks ago I started a new project using the new ruby framework Merb. Merb is also thread-safe and is in combination with DataMapper a really cool framework. By the way, did you know Rails is not thread-safe? Kinda sucky for a web framework to handle only one connection at a time. That’s the reason why people use multiple Mongrel servers when deploying Rails application. Not everyone I know seems to realize that. The bad thing is, there is NO plan to make it thread-safe :-/.
[http://blog.mattwynne.net/2008/05/23/datamapper-a-better-orm-for-ruby/]
DataMapper: A Better ORM for Ruby
One of the things that’s always irritated my about rails’ ActiveRecord framework is the way that the domain model lives in the database.Don’t get me wrong: it’s very clever, and a great showcase for ruby’s metaprogramming features, which will blow average C# / Java mind the mind when they first see it.
In rails, you build a database of your domain model, and create empty classes with the names of the domain entities (conventionally the singular of a database table name) which inherit from ActiveRecord. ActiveRecord then looks at your database, and using the magic of metaprogramming, hydrates your object with a bunch of properties that map to the database fields.
But I prefer to write my models in the code, and if you do too, you might want to take a look at DataMapper.

=Comparison of ORM Features=

{|cellspacing="0" border="1"
!style="width:10%"|Features
!style="width:30%"|ActiveRecord
!style="width:30%"|Sequel
!style="width:30%"|DataMapper
|-
! Databases 
| MySQL, PostgreSQL, SQLite, Oracle, SQLServer, and DB2
| ADO, DataObjects, DB2, DBI, Firebird, Informix, JDBC, MySQL, ODBC, OpenBase, Oracle, PostgreSQL and SQLite3
| N/A
|-
! Migrations 
| Yes
| Yes
| N/A
|-
! EagerLoading 
| Supported by scanning the SQL fragments
| Supported using eager (preloading) and eager_graph (joins)
| N/A
|-
! Flexible Overriding 
| No. Overriding is done using alias methods.
| Using methods and by calling 'super'
| N/A
|-
! Dynamic Finders 
| Yes. Uses 'Method Missing'
| No. Alternative is to use <Model>.FindOrCreate(:name=>"John")
| N/A
|}

=Conclusion=
Ruby ORM bla.

 

=References=

[1] [http://ruby-doc.org/ Ruby language]

[2] Fowler, C., The Ruby FAQ, www.rubygarden.org/faq

[3] , Active Record — Object-relation mapping put on rails, http://ar.rubyonrails.org/

==External Links==

#[http://wxruby.rubyforge.org/wiki/wiki.pl WxRuby]
#[http://www.activestate.com/activetcl ActiveTcl for Windows]

CSC/ECE 517 Fall 2010/ch3 3j KS

2010-10-05T01:19:15Z

Kschidam: /* Comparison of ORM Features */

='''Object-relational Mapping for Ruby'''=

__TOC__

=Introduction=

[http://en.wikipedia.org/wiki/Object-relational_mapping Object-relational mapping (ORM)] provides developers with a set of tools that ease management of the relationships between objects and relational databases, thus allowing applications to be easily extended to add data persistence. For Ruby, several object-relational mapping options are available in addition to ActiveRecord, the ORM layer supplied with Rails.

=Overview=

Object-relational Mapping (ORM) frameworks unburden the designer of the complex translation between database and object space.

Typical ORM features:
* Automatic mapping from classes to database tables
** Class instance variables to database columns
** Class instances to table rows
* Aggregation and association relationships between mapped classes are managed
** Example, :has_many, :belongs_to associations in ActiveRecord
** Inheritance cases are mapped to tables
* Validation of data prior to table storage
* Class extensions to enable search, as well as creation, read, update, and deletion (CRUD) of instances/records
* Usually abstracts the database from program space in such a way that alternate database types can be easily chosen (SQLite, Oracle, etc)

The diagram below depicts a simple mapping of an object to a database table….

[[Image:3j_ks_pic1.jpg]]

When applied to Ruby, implementations of ORM often leverage the language’s [http://en.wikipedia.org/wiki/Metaprogramming metaprogramming] strengths to create intuitive application-specific methods and otherwise extend classes to support database functionality.

=Comparison of ORM products for Ruby=

==''' ActiveRecord '''==

[http://ar.rubyonrails.org/ ActiveRecord], originally created by David Heinemeier and released in 2003, became the de-facto ORM for Ruby since it was integrated in the widely-used Rails framework, however alternate ORMs for Ruby have been developed and Rails 3.x is ORM independent. ActiveRecord is an implementation of the active record design pattern, where a table is wrapped into a class and this class implements accessor methods for each column in the table. [http://en.wikipedia.org/wiki/Active_record_pattern]

ActiveRecord uses a single table inheritance scheme, which trades off some storage efficiency for simplicity in the database design. Add a pic for to describe…

ActiveRecord manages associations between table elements and provides the means to define such associations in the model definition. For example, the User class shown below defines a ‘’to_many’’ association with both the cheers and posts tables. Also note ActiveRecord’s integrated support for validation of table information when attempting an update.

<pre>
class User < ActiveRecord::Base

has_many :cheers
has_many :posts

validates_presence_of :name
validates_uniqueness_of :name
validates_length_of :name, :within => 3..20
end
</pre>

'''Pros''' -
* Integrated with Rails development framework
* Dynamically created database search methods (eg User.find_by_address) ease db queries and make queries database syntax independent
'''Cons''' -
* DB creation/management is decoupled from the model, requiring a separate utility (rake/migrate) that must be kept in sync with application

=='''Sequel'''==

[http://sequel.rubyforge.org Sequel] was originally developed by Sharon Rosner and the first release was in March 2007. It is based on the active record pattern. Sequel and Active record share a lot of common features , for example association and inheritance. But Sequel handles these features in a much more flexible manner. Currently Sequel is at version 3.16.0. Initially Sequel was had three core modules - sequel, sequel_core and sequel_model.Starting from version 1.4 , sequel and sequel_model were merged. Sequel handles validations using a validation plug-in and helpers.

Some of the key features of sequel are,
* Connection Pooling
* Thread Safety
* Eager Loading / Lazy Loading
* Model Caching

<pre>
class CreateUser < Sequel::Migration
def up
create_table(:user) {
primary_key :id
String :name
String :password }
end
def down
drop_table(:user)
end
end # CreateUser.apply(DB, :up)
</pre>

==''' DataMapper'''==
http://www.gelens.org/2007/12/13/ruby_orm_datamapper/
Ruby ORM: DataMapper
There is a relative new ORM (Object Relational Mapper) for Ruby called “DataMapper”. Its goal is to create a fast, feature rich and thread-safe(!) ORM. DataMapper can be used standalone or as plugin for example Rails or Merb.
Finally some competition in the Ruby ORM world. Rails’ ActiveRecord is no longer the only usable production ORM. DataMapper’s developers made some radical different fundamental design decisions regarding to migrations and property declarations. Property declarations are now done in the Model itself and not in separate “migration”-files. Which is more elegant in my opinion.
Lately DataMapper is growing fast, it gets more attention and its feature list gets longer and is already superior to AR in terms of speed. A few weeks ago I started a new project using the new ruby framework Merb. Merb is also thread-safe and is in combination with DataMapper a really cool framework. By the way, did you know Rails is not thread-safe? Kinda sucky for a web framework to handle only one connection at a time. That’s the reason why people use multiple Mongrel servers when deploying Rails application. Not everyone I know seems to realize that. The bad thing is, there is NO plan to make it thread-safe :-/.
[http://blog.mattwynne.net/2008/05/23/datamapper-a-better-orm-for-ruby/]
DataMapper: A Better ORM for Ruby
One of the things that’s always irritated my about rails’ ActiveRecord framework is the way that the domain model lives in the database.Don’t get me wrong: it’s very clever, and a great showcase for ruby’s metaprogramming features, which will blow average C# / Java mind the mind when they first see it.
In rails, you build a database of your domain model, and create empty classes with the names of the domain entities (conventionally the singular of a database table name) which inherit from ActiveRecord. ActiveRecord then looks at your database, and using the magic of metaprogramming, hydrates your object with a bunch of properties that map to the database fields.
But I prefer to write my models in the code, and if you do too, you might want to take a look at DataMapper.

=Comparison of ORM Features=

{|cellspacing="0" border="1"
!style="width:10%"|Features
!style="width:30%"|ActiveRecord
!style="width:30%"|Sequel
!style="width:30%"|DataMapper
|-
! '''Databases'''
| MySQL, PostgreSQL, SQLite, Oracle, SQLServer, and DB2
| ADO, DataObjects, DB2, DBI, Firebird, Informix, JDBC, MySQL, ODBC, OpenBase, Oracle, PostgreSQL and SQLite3
| N/A
|-
! '''Migrations'''
| Yes
| Yes
| N/A
|-
! '''EagerLoading'''
| Supported by scanning the SQL fragments
| Supported using eager (preloading) and eager_graph (joins)
| N/A
|-
! '''Flexible Overriding'''
| No. Overriding is done using alias methods.
| Using methods and by calling 'super'
| N/A
|-
! '''Dynamic Finders'''
| Yes. Uses 'Method Missing'
| No. Alternative is to use <Model>.FindOrCreate(:name=>"John")
| N/A
|}

=Conclusion=
Ruby ORM bla.

 

=References=

[1] [http://ruby-doc.org/ Ruby language]

[2] Fowler, C., The Ruby FAQ, www.rubygarden.org/faq

[3] , Active Record — Object-relation mapping put on rails, http://ar.rubyonrails.org/

==External Links==

#[http://wxruby.rubyforge.org/wiki/wiki.pl WxRuby]
#[http://www.activestate.com/activetcl ActiveTcl for Windows]

CSC/ECE 517 Fall 2010/ch3 3j KS

2010-10-05T00:59:10Z

Kschidam: /* Comparison of ORM Features */

='''Object-relational Mapping for Ruby'''=

__TOC__

=Introduction=

[http://en.wikipedia.org/wiki/Object-relational_mapping Object-relational mapping (ORM)] provides developers with a set of tools that ease management of the relationships between objects and relational databases, thus allowing applications to be easily extended to add data persistence. For Ruby, several object-relational mapping options are available in addition to ActiveRecord, the ORM layer supplied with Rails.

=Overview=

Object-relational Mapping (ORM) frameworks unburden the designer of the complex translation between database and object space.

Typical ORM features:
* Automatic mapping from classes to database tables
** Class instance variables to database columns
** Class instances to table rows
* Aggregation and association relationships between mapped classes are managed
** Example, :has_many, :belongs_to associations in ActiveRecord
** Inheritance cases are mapped to tables
* Validation of data prior to table storage
* Class extensions to enable search, as well as creation, read, update, and deletion (CRUD) of instances/records
* Usually abstracts the database from program space in such a way that alternate database types can be easily chosen (SQLite, Oracle, etc)

The diagram below depicts a simple mapping of an object to a database table….

[[Image:3j_ks_pic1.jpg]]

When applied to Ruby, implementations of ORM often leverage the language’s [http://en.wikipedia.org/wiki/Metaprogramming metaprogramming] strengths to create intuitive application-specific methods and otherwise extend classes to support database functionality.

Perhaps add section w/ examples of typical Ruby ORM techniques here else just cover in each product…

=Comparison of ORM products for Ruby=

==''' ActiveRecord '''==

[http://ar.rubyonrails.org/ ActiveRecord], originally created by David Heinemeier and released in 2003, became the de-facto ORM for Ruby since it was integrated in the widely-used Rails framework, however alternate ORMs for Ruby have been developed and Rails 3.x is ORM independent. ActiveRecord is an implementation of the active record design pattern, where a table is wrapped into a class and this class implements accessor methods for each column in the table. [http://en.wikipedia.org/wiki/Active_record_pattern]

ActiveRecord uses a single table inheritance scheme, which trades off some storage efficiency for simplicity in the database design. Add a pic for to describe…

ActiveRecord manages associations between table elements and provides the means to define such associations in the model definition. For example, the User class shown below defines a ‘’to_many’’ association with both the cheers and posts tables. Also note ActiveRecord’s integrated support for validation of table information when attempting an update.

<pre>
class User < ActiveRecord::Base

has_many :cheers
has_many :posts

validates_presence_of :name
validates_uniqueness_of :name
validates_length_of :name, :within => 3..20
end
</pre>

'''Pros''' -
* Integrated with Rails development framework
* Dynamically created database search methods (eg User.find_by_address) ease db queries and make queries database syntax independent
'''Cons''' -
* DB creation/management is decoupled from the model, requiring a separate utility (rake/migrate) that must be kept in sync with application

=='''Sequel'''==

[http://sequel.rubyforge.org Sequel] was originally developed by Sharon Rosner and the first release was in March 2007. It is based on the active record pattern. Sequel and Active record share a lot of common features , for example association and inheritance. But Sequel handles these features in a much more flexible manner. Currently Sequel is at version 3.16.0. Initially Sequel was had three core modules - sequel, sequel_core and sequel_model.Starting from version 1.4 , sequel and sequel_model were merged. Sequel handles validations using a validation plug-in and helpers.

Some of the key features of sequel are,
* Connection Pooling
* Thread Safety
* Eager Loading / Lazy Loading
* Model Caching

<pre>
class CreateUser < Sequel::Migration
def up
create_table(:user) {
primary_key :id
String :name
String :password }
end
def down
drop_table(:user)
end
end # CreateUser.apply(DB, :up)
</pre>

==''' DataMapper'''==
http://www.gelens.org/2007/12/13/ruby_orm_datamapper/
Ruby ORM: DataMapper
There is a relative new ORM (Object Relational Mapper) for Ruby called “DataMapper”. Its goal is to create a fast, feature rich and thread-safe(!) ORM. DataMapper can be used standalone or as plugin for example Rails or Merb.
Finally some competition in the Ruby ORM world. Rails’ ActiveRecord is no longer the only usable production ORM. DataMapper’s developers made some radical different fundamental design decisions regarding to migrations and property declarations. Property declarations are now done in the Model itself and not in separate “migration”-files. Which is more elegant in my opinion.
Lately DataMapper is growing fast, it gets more attention and its feature list gets longer and is already superior to AR in terms of speed. A few weeks ago I started a new project using the new ruby framework Merb. Merb is also thread-safe and is in combination with DataMapper a really cool framework. By the way, did you know Rails is not thread-safe? Kinda sucky for a web framework to handle only one connection at a time. That’s the reason why people use multiple Mongrel servers when deploying Rails application. Not everyone I know seems to realize that. The bad thing is, there is NO plan to make it thread-safe :-/.
[http://blog.mattwynne.net/2008/05/23/datamapper-a-better-orm-for-ruby/]
DataMapper: A Better ORM for Ruby
One of the things that’s always irritated my about rails’ ActiveRecord framework is the way that the domain model lives in the database.Don’t get me wrong: it’s very clever, and a great showcase for ruby’s metaprogramming features, which will blow average C# / Java mind the mind when they first see it.
In rails, you build a database of your domain model, and create empty classes with the names of the domain entities (conventionally the singular of a database table name) which inherit from ActiveRecord. ActiveRecord then looks at your database, and using the magic of metaprogramming, hydrates your object with a bunch of properties that map to the database fields.
But I prefer to write my models in the code, and if you do too, you might want to take a look at DataMapper.

=Comparison of ORM Features=

{| class="wikitable sortable" border="1" style="font-size: 100%; text-align: left; width: auto;"
|-
! ''' Features '''
! ''' ActiveRecord '''
! ''' Sequel '''
! ''' DataMapper '''
|-
! '''Databases'''
| MySQL, PostgreSQL, SQLite, Oracle, SQLServer, and DB2
| ADO, DataObjects, DB2, DBI, Firebird, Informix, JDBC, MySQL, ODBC, OpenBase, Oracle, PostgreSQL and SQLite3
| N/A
|-
! '''Migrations'''
| Yes
| Yes
| N/A
|-
! '''EagerLoading'''
| Supported by scanning the SQL fragments
| Supported using eager (preloading) and eager_graph (joins)
| N/A
|-
! '''Flexible Overriding'''
| No. Overriding is done using alias methods.
| Using methods and by calling 'super'
| N/A
|-
! '''Dynamic Finders'''
| Yes. Uses 'Method Missing'
| No. Alternative is to use <Model>.FindOrCreate(:name=>"John")
| N/A
|}

=Conclusion=
Ruby ORM bla.

 

=References=

[1] [http://ruby-doc.org/ Ruby language]

[2] Fowler, C., The Ruby FAQ, www.rubygarden.org/faq

[3] , Active Record — Object-relation mapping put on rails, http://ar.rubyonrails.org/

==External Links==

#[http://wxruby.rubyforge.org/wiki/wiki.pl WxRuby]
#[http://www.activestate.com/activetcl ActiveTcl for Windows]

CSC/ECE 517 Fall 2010/ch3 3j KS

2010-10-05T00:56:01Z

Kschidam: /* Comparison of ORM Features */

='''Object-relational Mapping for Ruby'''=

__TOC__

=Introduction=

[http://en.wikipedia.org/wiki/Object-relational_mapping Object-relational mapping (ORM)] provides developers with a set of tools that ease management of the relationships between objects and relational databases, thus allowing applications to be easily extended to add data persistence. For Ruby, several object-relational mapping options are available in addition to ActiveRecord, the ORM layer supplied with Rails.

=Overview=

Object-relational Mapping (ORM) frameworks unburden the designer of the complex translation between database and object space.

Typical ORM features:
* Automatic mapping from classes to database tables
** Class instance variables to database columns
** Class instances to table rows
* Aggregation and association relationships between mapped classes are managed
** Example, :has_many, :belongs_to associations in ActiveRecord
** Inheritance cases are mapped to tables
* Validation of data prior to table storage
* Class extensions to enable search, as well as creation, read, update, and deletion (CRUD) of instances/records
* Usually abstracts the database from program space in such a way that alternate database types can be easily chosen (SQLite, Oracle, etc)

The diagram below depicts a simple mapping of an object to a database table….

[[Image:3j_ks_pic1.jpg]]

When applied to Ruby, implementations of ORM often leverage the language’s [http://en.wikipedia.org/wiki/Metaprogramming metaprogramming] strengths to create intuitive application-specific methods and otherwise extend classes to support database functionality.

Perhaps add section w/ examples of typical Ruby ORM techniques here else just cover in each product…

=Comparison of ORM products for Ruby=

==''' ActiveRecord '''==

[http://ar.rubyonrails.org/ ActiveRecord], originally created by David Heinemeier and released in 2003, became the de-facto ORM for Ruby since it was integrated in the widely-used Rails framework, however alternate ORMs for Ruby have been developed and Rails 3.x is ORM independent. ActiveRecord is an implementation of the active record design pattern, where a table is wrapped into a class and this class implements accessor methods for each column in the table. [http://en.wikipedia.org/wiki/Active_record_pattern]

ActiveRecord uses a single table inheritance scheme, which trades off some storage efficiency for simplicity in the database design. Add a pic for to describe…

ActiveRecord manages associations between table elements and provides the means to define such associations in the model definition. For example, the User class shown below defines a ‘’to_many’’ association with both the cheers and posts tables. Also note ActiveRecord’s integrated support for validation of table information when attempting an update.

<pre>
class User < ActiveRecord::Base

has_many :cheers
has_many :posts

validates_presence_of :name
validates_uniqueness_of :name
validates_length_of :name, :within => 3..20
end
</pre>

'''Pros''' -
* Integrated with Rails development framework
* Dynamically created database search methods (eg User.find_by_address) ease db queries and make queries database syntax independent
'''Cons''' -
* DB creation/management is decoupled from the model, requiring a separate utility (rake/migrate) that must be kept in sync with application

=='''Sequel'''==

[http://sequel.rubyforge.org Sequel] was originally developed by Sharon Rosner and the first release was in March 2007. It is based on the active record pattern. Sequel and Active record share a lot of common features , for example association and inheritance. But Sequel handles these features in a much more flexible manner. Currently Sequel is at version 3.16.0. Initially Sequel was had three core modules - sequel, sequel_core and sequel_model.Starting from version 1.4 , sequel and sequel_model were merged. Sequel handles validations using a validation plug-in and helpers.

Some of the key features of sequel are,
* Connection Pooling
* Thread Safety
* Eager Loading / Lazy Loading
* Model Caching

<pre>
class CreateUser < Sequel::Migration
def up
create_table(:user) {
primary_key :id
String :name
String :password }
end
def down
drop_table(:user)
end
end # CreateUser.apply(DB, :up)
</pre>

==''' DataMapper'''==
http://www.gelens.org/2007/12/13/ruby_orm_datamapper/
Ruby ORM: DataMapper
There is a relative new ORM (Object Relational Mapper) for Ruby called “DataMapper”. Its goal is to create a fast, feature rich and thread-safe(!) ORM. DataMapper can be used standalone or as plugin for example Rails or Merb.
Finally some competition in the Ruby ORM world. Rails’ ActiveRecord is no longer the only usable production ORM. DataMapper’s developers made some radical different fundamental design decisions regarding to migrations and property declarations. Property declarations are now done in the Model itself and not in separate “migration”-files. Which is more elegant in my opinion.
Lately DataMapper is growing fast, it gets more attention and its feature list gets longer and is already superior to AR in terms of speed. A few weeks ago I started a new project using the new ruby framework Merb. Merb is also thread-safe and is in combination with DataMapper a really cool framework. By the way, did you know Rails is not thread-safe? Kinda sucky for a web framework to handle only one connection at a time. That’s the reason why people use multiple Mongrel servers when deploying Rails application. Not everyone I know seems to realize that. The bad thing is, there is NO plan to make it thread-safe :-/.
[http://blog.mattwynne.net/2008/05/23/datamapper-a-better-orm-for-ruby/]
DataMapper: A Better ORM for Ruby
One of the things that’s always irritated my about rails’ ActiveRecord framework is the way that the domain model lives in the database.Don’t get me wrong: it’s very clever, and a great showcase for ruby’s metaprogramming features, which will blow average C# / Java mind the mind when they first see it.
In rails, you build a database of your domain model, and create empty classes with the names of the domain entities (conventionally the singular of a database table name) which inherit from ActiveRecord. ActiveRecord then looks at your database, and using the magic of metaprogramming, hydrates your object with a bunch of properties that map to the database fields.
But I prefer to write my models in the code, and if you do too, you might want to take a look at DataMapper.

=Comparison of ORM Features=

{| class="wikitable sortable" border="1" style="font-size: 100%; text-align: left; width: auto;"
|-
! ''' Features '''
! ''' ActiveRecord '''
! ''' Sequel '''
! ''' DataMapper '''
|-
! '''Databases'''
| MySQL, PostgreSQL, SQLite, Oracle, SQLServer, and DB2
| ADO, DataObjects, DB2, DBI, Firebird, Informix, JDBC, MySQL, ODBC, OpenBase, Oracle, PostgreSQL and SQLite3
| yes
|-
! '''Migrations'''
| Yes
| Yes
| yes
|-
! '''EagerLoading'''
| Supported by scanning the SQL fragments
| Supported using eager (preloading) and eager_graph (joins)
| yes
|-
! '''Flexible Overriding'''
| No. Overriding is done using alias methods.
| Using methods and by calling 'super'
| yes
|-
! '''Dynamic Finders'''
| yes
| yes
| yes
|}

<pre>
Code example
</pre>

=Conclusion=
Ruby ORM bla.

 

=References=

[1] [http://ruby-doc.org/ Ruby language]

[2] Fowler, C., The Ruby FAQ, www.rubygarden.org/faq

[3] , Active Record — Object-relation mapping put on rails, http://ar.rubyonrails.org/

==External Links==

#[http://wxruby.rubyforge.org/wiki/wiki.pl WxRuby]
#[http://www.activestate.com/activetcl ActiveTcl for Windows]

CSC/ECE 517 Fall 2010/ch3 3j KS

2010-10-05T00:54:04Z

Kschidam: /* Comparison of ORM Features */

='''Object-relational Mapping for Ruby'''=

__TOC__

=Introduction=

[http://en.wikipedia.org/wiki/Object-relational_mapping Object-relational mapping (ORM)] provides developers with a set of tools that ease management of the relationships between objects and relational databases, thus allowing applications to be easily extended to add data persistence. For Ruby, several object-relational mapping options are available in addition to ActiveRecord, the ORM layer supplied with Rails.

=Overview=

Object-relational Mapping (ORM) frameworks unburden the designer of the complex translation between database and object space.

Typical ORM features:
* Automatic mapping from classes to database tables
** Class instance variables to database columns
** Class instances to table rows
* Aggregation and association relationships between mapped classes are managed
** Example, :has_many, :belongs_to associations in ActiveRecord
** Inheritance cases are mapped to tables
* Validation of data prior to table storage
* Class extensions to enable search, as well as creation, read, update, and deletion (CRUD) of instances/records
* Usually abstracts the database from program space in such a way that alternate database types can be easily chosen (SQLite, Oracle, etc)

The diagram below depicts a simple mapping of an object to a database table….

[[Image:3j_ks_pic1.jpg]]

When applied to Ruby, implementations of ORM often leverage the language’s [http://en.wikipedia.org/wiki/Metaprogramming metaprogramming] strengths to create intuitive application-specific methods and otherwise extend classes to support database functionality.

Perhaps add section w/ examples of typical Ruby ORM techniques here else just cover in each product…

=Comparison of ORM products for Ruby=

==''' ActiveRecord '''==

[http://ar.rubyonrails.org/ ActiveRecord], originally created by David Heinemeier and released in 2003, became the de-facto ORM for Ruby since it was integrated in the widely-used Rails framework, however alternate ORMs for Ruby have been developed and Rails 3.x is ORM independent. ActiveRecord is an implementation of the active record design pattern, where a table is wrapped into a class and this class implements accessor methods for each column in the table. [http://en.wikipedia.org/wiki/Active_record_pattern]

ActiveRecord uses a single table inheritance scheme, which trades off some storage efficiency for simplicity in the database design. Add a pic for to describe…

ActiveRecord manages associations between table elements and provides the means to define such associations in the model definition. For example, the User class shown below defines a ‘’to_many’’ association with both the cheers and posts tables. Also note ActiveRecord’s integrated support for validation of table information when attempting an update.

<pre>
class User < ActiveRecord::Base

has_many :cheers
has_many :posts

validates_presence_of :name
validates_uniqueness_of :name
validates_length_of :name, :within => 3..20
end
</pre>

'''Pros''' -
* Integrated with Rails development framework
* Dynamically created database search methods (eg User.find_by_address) ease db queries and make queries database syntax independent
'''Cons''' -
* DB creation/management is decoupled from the model, requiring a separate utility (rake/migrate) that must be kept in sync with application

=='''Sequel'''==

[http://sequel.rubyforge.org Sequel] was originally developed by Sharon Rosner and the first release was in March 2007. It is based on the active record pattern. Sequel and Active record share a lot of common features , for example association and inheritance. But Sequel handles these features in a much more flexible manner. Currently Sequel is at version 3.16.0. Initially Sequel was had three core modules - sequel, sequel_core and sequel_model.Starting from version 1.4 , sequel and sequel_model were merged. Sequel handles validations using a validation plug-in and helpers.

Some of the key features of sequel are,
* Connection Pooling
* Thread Safety
* Eager Loading / Lazy Loading
* Model Caching

<pre>
class CreateUser < Sequel::Migration
def up
create_table(:user) {
primary_key :id
String :name
String :password }
end
def down
drop_table(:user)
end
end # CreateUser.apply(DB, :up)
</pre>

==''' DataMapper'''==
http://www.gelens.org/2007/12/13/ruby_orm_datamapper/
Ruby ORM: DataMapper
There is a relative new ORM (Object Relational Mapper) for Ruby called “DataMapper”. Its goal is to create a fast, feature rich and thread-safe(!) ORM. DataMapper can be used standalone or as plugin for example Rails or Merb.
Finally some competition in the Ruby ORM world. Rails’ ActiveRecord is no longer the only usable production ORM. DataMapper’s developers made some radical different fundamental design decisions regarding to migrations and property declarations. Property declarations are now done in the Model itself and not in separate “migration”-files. Which is more elegant in my opinion.
Lately DataMapper is growing fast, it gets more attention and its feature list gets longer and is already superior to AR in terms of speed. A few weeks ago I started a new project using the new ruby framework Merb. Merb is also thread-safe and is in combination with DataMapper a really cool framework. By the way, did you know Rails is not thread-safe? Kinda sucky for a web framework to handle only one connection at a time. That’s the reason why people use multiple Mongrel servers when deploying Rails application. Not everyone I know seems to realize that. The bad thing is, there is NO plan to make it thread-safe :-/.
[http://blog.mattwynne.net/2008/05/23/datamapper-a-better-orm-for-ruby/]
DataMapper: A Better ORM for Ruby
One of the things that’s always irritated my about rails’ ActiveRecord framework is the way that the domain model lives in the database.Don’t get me wrong: it’s very clever, and a great showcase for ruby’s metaprogramming features, which will blow average C# / Java mind the mind when they first see it.
In rails, you build a database of your domain model, and create empty classes with the names of the domain entities (conventionally the singular of a database table name) which inherit from ActiveRecord. ActiveRecord then looks at your database, and using the magic of metaprogramming, hydrates your object with a bunch of properties that map to the database fields.
But I prefer to write my models in the code, and if you do too, you might want to take a look at DataMapper.

=Comparison of ORM Features=

{| class="wikitable sortable" border="1" style="font-size: 100%; text-align: left; width: auto;"
|-
! ''' Features '''
! ''' ActiveRecord '''
! ''' Sequel '''
! ''' DataMapper '''
|-
! '''Databases'''
| MySQL, PostgreSQL, SQLite, Oracle, SQLServer, and DB2
| ADO, DataObjects, DB2, DBI, Firebird, Informix, JDBC, MySQL, ODBC, OpenBase, Oracle, PostgreSQL and SQLite3
| yes
|-
! '''Migrations'''
| Yes
| Yes
| yes
|-
! '''EagerLoading'''
| Supported by scanning the SQL fragments
| Supported using eager (preloading) and eager_graph (joins)
| yes
|-
! '''Flexible Overriding'''
| yes
| yes
| yes
|-
! '''Dynamic Finders'''
| yes
| yes
| yes
|}

<pre>
Code example
</pre>

=Conclusion=
Ruby ORM bla.

 

=References=

[1] [http://ruby-doc.org/ Ruby language]

[2] Fowler, C., The Ruby FAQ, www.rubygarden.org/faq

[3] , Active Record — Object-relation mapping put on rails, http://ar.rubyonrails.org/

==External Links==

#[http://wxruby.rubyforge.org/wiki/wiki.pl WxRuby]
#[http://www.activestate.com/activetcl ActiveTcl for Windows]

CSC/ECE 517 Fall 2010/ch3 3j KS

2010-10-05T00:50:56Z

Kschidam: /* Comparison of ORM Features */

='''Object-relational Mapping for Ruby'''=

__TOC__

=Introduction=

[http://en.wikipedia.org/wiki/Object-relational_mapping Object-relational mapping (ORM)] provides developers with a set of tools that ease management of the relationships between objects and relational databases, thus allowing applications to be easily extended to add data persistence. For Ruby, several object-relational mapping options are available in addition to ActiveRecord, the ORM layer supplied with Rails.

=Overview=

Object-relational Mapping (ORM) frameworks unburden the designer of the complex translation between database and object space.

Typical ORM features:
* Automatic mapping from classes to database tables
** Class instance variables to database columns
** Class instances to table rows
* Aggregation and association relationships between mapped classes are managed
** Example, :has_many, :belongs_to associations in ActiveRecord
** Inheritance cases are mapped to tables
* Validation of data prior to table storage
* Class extensions to enable search, as well as creation, read, update, and deletion (CRUD) of instances/records
* Usually abstracts the database from program space in such a way that alternate database types can be easily chosen (SQLite, Oracle, etc)

The diagram below depicts a simple mapping of an object to a database table….

[[Image:3j_ks_pic1.jpg]]

When applied to Ruby, implementations of ORM often leverage the language’s [http://en.wikipedia.org/wiki/Metaprogramming metaprogramming] strengths to create intuitive application-specific methods and otherwise extend classes to support database functionality.

Perhaps add section w/ examples of typical Ruby ORM techniques here else just cover in each product…

=Comparison of ORM products for Ruby=

==''' ActiveRecord '''==

[http://ar.rubyonrails.org/ ActiveRecord], originally created by David Heinemeier and released in 2003, became the de-facto ORM for Ruby since it was integrated in the widely-used Rails framework, however alternate ORMs for Ruby have been developed and Rails 3.x is ORM independent. ActiveRecord is an implementation of the active record design pattern, where a table is wrapped into a class and this class implements accessor methods for each column in the table. [http://en.wikipedia.org/wiki/Active_record_pattern]

ActiveRecord uses a single table inheritance scheme, which trades off some storage efficiency for simplicity in the database design. Add a pic for to describe…

ActiveRecord manages associations between table elements and provides the means to define such associations in the model definition. For example, the User class shown below defines a ‘’to_many’’ association with both the cheers and posts tables. Also note ActiveRecord’s integrated support for validation of table information when attempting an update.

<pre>
class User < ActiveRecord::Base

has_many :cheers
has_many :posts

validates_presence_of :name
validates_uniqueness_of :name
validates_length_of :name, :within => 3..20
end
</pre>

'''Pros''' -
* Integrated with Rails development framework
* Dynamically created database search methods (eg User.find_by_address) ease db queries and make queries database syntax independent
'''Cons''' -
* DB creation/management is decoupled from the model, requiring a separate utility (rake/migrate) that must be kept in sync with application

=='''Sequel'''==

[http://sequel.rubyforge.org Sequel] was originally developed by Sharon Rosner and the first release was in March 2007. It is based on the active record pattern. Sequel and Active record share a lot of common features , for example association and inheritance. But Sequel handles these features in a much more flexible manner. Currently Sequel is at version 3.16.0. Initially Sequel was had three core modules - sequel, sequel_core and sequel_model.Starting from version 1.4 , sequel and sequel_model were merged. Sequel handles validations using a validation plug-in and helpers.

Some of the key features of sequel are,
* Connection Pooling
* Thread Safety
* Eager Loading / Lazy Loading
* Model Caching

<pre>
class CreateUser < Sequel::Migration
def up
create_table(:user) {
primary_key :id
String :name
String :password }
end
def down
drop_table(:user)
end
end # CreateUser.apply(DB, :up)
</pre>

==''' DataMapper'''==
http://www.gelens.org/2007/12/13/ruby_orm_datamapper/
Ruby ORM: DataMapper
There is a relative new ORM (Object Relational Mapper) for Ruby called “DataMapper”. Its goal is to create a fast, feature rich and thread-safe(!) ORM. DataMapper can be used standalone or as plugin for example Rails or Merb.
Finally some competition in the Ruby ORM world. Rails’ ActiveRecord is no longer the only usable production ORM. DataMapper’s developers made some radical different fundamental design decisions regarding to migrations and property declarations. Property declarations are now done in the Model itself and not in separate “migration”-files. Which is more elegant in my opinion.
Lately DataMapper is growing fast, it gets more attention and its feature list gets longer and is already superior to AR in terms of speed. A few weeks ago I started a new project using the new ruby framework Merb. Merb is also thread-safe and is in combination with DataMapper a really cool framework. By the way, did you know Rails is not thread-safe? Kinda sucky for a web framework to handle only one connection at a time. That’s the reason why people use multiple Mongrel servers when deploying Rails application. Not everyone I know seems to realize that. The bad thing is, there is NO plan to make it thread-safe :-/.
[http://blog.mattwynne.net/2008/05/23/datamapper-a-better-orm-for-ruby/]
DataMapper: A Better ORM for Ruby
One of the things that’s always irritated my about rails’ ActiveRecord framework is the way that the domain model lives in the database.Don’t get me wrong: it’s very clever, and a great showcase for ruby’s metaprogramming features, which will blow average C# / Java mind the mind when they first see it.
In rails, you build a database of your domain model, and create empty classes with the names of the domain entities (conventionally the singular of a database table name) which inherit from ActiveRecord. ActiveRecord then looks at your database, and using the magic of metaprogramming, hydrates your object with a bunch of properties that map to the database fields.
But I prefer to write my models in the code, and if you do too, you might want to take a look at DataMapper.

=Comparison of ORM Features=

{| class="wikitable sortable" border="1" style="font-size: 100%; text-align: left; width: auto;"
|-
! ''' Features '''
! ''' ActiveRecord '''
! ''' Sequel '''
! ''' DataMapper '''
|-
! '''Databases'''
| MySQL, PostgreSQL, SQLite, Oracle, SQLServer, and DB2
| ADO, DataObjects, DB2, DBI, Firebird, Informix, JDBC, MySQL, ODBC, OpenBase, Oracle, PostgreSQL and SQLite3
| yes
|-
! '''Migrations'''
| Yes
| Yes
| yes
|-
! '''EagerLoading'''
| yes
| yes
| yes
|-
! '''Flexible Overriding'''
| yes
| yes
| yes
|-
! '''Dynamic Finders'''
| yes
| yes
| yes
|}

<pre>
Code example
</pre>

=Conclusion=
Ruby ORM bla.

 

=References=

[1] [http://ruby-doc.org/ Ruby language]

[2] Fowler, C., The Ruby FAQ, www.rubygarden.org/faq

[3] , Active Record — Object-relation mapping put on rails, http://ar.rubyonrails.org/

==External Links==

#[http://wxruby.rubyforge.org/wiki/wiki.pl WxRuby]
#[http://www.activestate.com/activetcl ActiveTcl for Windows]

CSC/ECE 517 Fall 2010/ch3 3j KS

2010-10-05T00:41:08Z

Kschidam: /* Comparison of ORM Features */

='''Object-relational Mapping for Ruby'''=

__TOC__

=Introduction=

[http://en.wikipedia.org/wiki/Object-relational_mapping Object-relational mapping (ORM)] provides developers with a set of tools that ease management of the relationships between objects and relational databases, thus allowing applications to be easily extended to add data persistence. For Ruby, several object-relational mapping options are available in addition to ActiveRecord, the ORM layer supplied with Rails.

=Overview=

Object-relational Mapping (ORM) frameworks unburden the designer of the complex translation between database and object space.

Typical ORM features:
* Automatic mapping from classes to database tables
** Class instance variables to database columns
** Class instances to table rows
* Aggregation and association relationships between mapped classes are managed
** Example, :has_many, :belongs_to associations in ActiveRecord
** Inheritance cases are mapped to tables
* Validation of data prior to table storage
* Class extensions to enable search, as well as creation, read, update, and deletion (CRUD) of instances/records
* Usually abstracts the database from program space in such a way that alternate database types can be easily chosen (SQLite, Oracle, etc)

The diagram below depicts a simple mapping of an object to a database table….

[[Image:3j_ks_pic1.jpg]]

When applied to Ruby, implementations of ORM often leverage the language’s [http://en.wikipedia.org/wiki/Metaprogramming metaprogramming] strengths to create intuitive application-specific methods and otherwise extend classes to support database functionality.

Perhaps add section w/ examples of typical Ruby ORM techniques here else just cover in each product…

=Comparison of ORM products for Ruby=

==''' ActiveRecord '''==

[http://ar.rubyonrails.org/ ActiveRecord], originally created by David Heinemeier and released in 2003, became the de-facto ORM for Ruby since it was integrated in the widely-used Rails framework, however alternate ORMs for Ruby have been developed and Rails 3.x is ORM independent. ActiveRecord is an implementation of the active record design pattern, where a table is wrapped into a class and this class implements accessor methods for each column in the table. [http://en.wikipedia.org/wiki/Active_record_pattern]

ActiveRecord uses a single table inheritance scheme, which trades off some storage efficiency for simplicity in the database design. Add a pic for to describe…

ActiveRecord manages associations between table elements and provides the means to define such associations in the model definition. For example, the User class shown below defines a ‘’to_many’’ association with both the cheers and posts tables. Also note ActiveRecord’s integrated support for validation of table information when attempting an update.

<pre>
class User < ActiveRecord::Base

has_many :cheers
has_many :posts

validates_presence_of :name
validates_uniqueness_of :name
validates_length_of :name, :within => 3..20
end
</pre>

'''Pros''' -
* Integrated with Rails development framework
* Dynamically created database search methods (eg User.find_by_address) ease db queries and make queries database syntax independent
'''Cons''' -
* DB creation/management is decoupled from the model, requiring a separate utility (rake/migrate) that must be kept in sync with application

=='''Sequel'''==

[http://sequel.rubyforge.org Sequel] was originally developed by Sharon Rosner and the first release was in March 2007. It is based on the active record pattern. Sequel and Active record share a lot of common features , for example association and inheritance. But Sequel handles these features in a much more flexible manner. Currently Sequel is at version 3.16.0. Initially Sequel was had three core modules - sequel, sequel_core and sequel_model.Starting from version 1.4 , sequel and sequel_model were merged. Sequel handles validations using a validation plug-in and helpers.

Some of the key features of sequel are,
* Connection Pooling
* Thread Safety
* Eager Loading / Lazy Loading
* Model Caching

<pre>
class CreateUser < Sequel::Migration
def up
create_table(:user) {
primary_key :id
String :name
String :password }
end
def down
drop_table(:user)
end
end # CreateUser.apply(DB, :up)
</pre>

==''' DataMapper'''==
http://www.gelens.org/2007/12/13/ruby_orm_datamapper/
Ruby ORM: DataMapper
There is a relative new ORM (Object Relational Mapper) for Ruby called “DataMapper”. Its goal is to create a fast, feature rich and thread-safe(!) ORM. DataMapper can be used standalone or as plugin for example Rails or Merb.
Finally some competition in the Ruby ORM world. Rails’ ActiveRecord is no longer the only usable production ORM. DataMapper’s developers made some radical different fundamental design decisions regarding to migrations and property declarations. Property declarations are now done in the Model itself and not in separate “migration”-files. Which is more elegant in my opinion.
Lately DataMapper is growing fast, it gets more attention and its feature list gets longer and is already superior to AR in terms of speed. A few weeks ago I started a new project using the new ruby framework Merb. Merb is also thread-safe and is in combination with DataMapper a really cool framework. By the way, did you know Rails is not thread-safe? Kinda sucky for a web framework to handle only one connection at a time. That’s the reason why people use multiple Mongrel servers when deploying Rails application. Not everyone I know seems to realize that. The bad thing is, there is NO plan to make it thread-safe :-/.
[http://blog.mattwynne.net/2008/05/23/datamapper-a-better-orm-for-ruby/]
DataMapper: A Better ORM for Ruby
One of the things that’s always irritated my about rails’ ActiveRecord framework is the way that the domain model lives in the database.Don’t get me wrong: it’s very clever, and a great showcase for ruby’s metaprogramming features, which will blow average C# / Java mind the mind when they first see it.
In rails, you build a database of your domain model, and create empty classes with the names of the domain entities (conventionally the singular of a database table name) which inherit from ActiveRecord. ActiveRecord then looks at your database, and using the magic of metaprogramming, hydrates your object with a bunch of properties that map to the database fields.
But I prefer to write my models in the code, and if you do too, you might want to take a look at DataMapper.

=Comparison of ORM Features=

{| class="wikitable sortable" border="1" style="font-size: 100%; text-align: left; width: auto;"
|-
! ''' Features '''
! ''' ActiveRecord '''
! ''' Sequel '''
! ''' DataMapper '''
|-
! '''Databases'''
| yes
| yes
| yes
|-
! '''Migrations'''
| yes
| yes
| yes
|-
! '''EagerLoading'''
| yes
| yes
| yes
|-
! '''Flexible Overriding'''
| yes
| yes
| yes
|-
! '''Dynamic Finders'''
| yes
| yes
| yes
|}

<pre>
Code example
</pre>

=Conclusion=
Ruby ORM bla.

 

=References=

[1] [http://ruby-doc.org/ Ruby language]

[2] Fowler, C., The Ruby FAQ, www.rubygarden.org/faq

[3] , Active Record — Object-relation mapping put on rails, http://ar.rubyonrails.org/

==External Links==

#[http://wxruby.rubyforge.org/wiki/wiki.pl WxRuby]
#[http://www.activestate.com/activetcl ActiveTcl for Windows]

CSC/ECE 517 Fall 2010/ch3 3j KS

2010-10-05T00:23:10Z

Kschidam:

='''Object-relational Mapping for Ruby'''=

__TOC__

=Introduction=

[http://en.wikipedia.org/wiki/Object-relational_mapping Object-relational mapping (ORM)] provides developers with a set of tools that ease management of the relationships between objects and relational databases, thus allowing applications to be easily extended to add data persistence. For Ruby, several object-relational mapping options are available in addition to ActiveRecord, the ORM layer supplied with Rails.

=Overview=

Object-relational Mapping (ORM) frameworks unburden the designer of the complex translation between database and object space.

Typical ORM features:
* Automatic mapping from classes to database tables
** Class instance variables to database columns
** Class instances to table rows
* Aggregation and association relationships between mapped classes are managed
** Example, :has_many, :belongs_to associations in ActiveRecord
** Inheritance cases are mapped to tables
* Validation of data prior to table storage
* Class extensions to enable search, as well as creation, read, update, and deletion (CRUD) of instances/records
* Usually abstracts the database from program space in such a way that alternate database types can be easily chosen (SQLite, Oracle, etc)

The diagram below depicts a simple mapping of an object to a database table….

[[Image:3j_ks_pic1.jpg]]

When applied to Ruby, implementations of ORM often leverage the language’s [http://en.wikipedia.org/wiki/Metaprogramming metaprogramming] strengths to create intuitive application-specific methods and otherwise extend classes to support database functionality.

Perhaps add section w/ examples of typical Ruby ORM techniques here else just cover in each product…

=Comparison of ORM products for Ruby=

==''' ActiveRecord '''==

[http://ar.rubyonrails.org/ ActiveRecord], originally created by David Heinemeier and released in 2003, became the de-facto ORM for Ruby since it was integrated in the widely-used Rails framework, however alternate ORMs for Ruby have been developed and Rails 3.x is ORM independent. ActiveRecord is an implementation of the active record design pattern, where a table is wrapped into a class and this class implements accessor methods for each column in the table. [http://en.wikipedia.org/wiki/Active_record_pattern]

ActiveRecord uses a single table inheritance scheme, which trades off some storage efficiency for simplicity in the database design. Add a pic for to describe…

ActiveRecord manages associations between table elements and provides the means to define such associations in the model definition. For example, the User class shown below defines a ‘’to_many’’ association with both the cheers and posts tables. Also note ActiveRecord’s integrated support for validation of table information when attempting an update.

<pre>
class User < ActiveRecord::Base

has_many :cheers
has_many :posts

validates_presence_of :name
validates_uniqueness_of :name
validates_length_of :name, :within => 3..20
end
</pre>

'''Pros''' -
* Integrated with Rails development framework
* Dynamically created database search methods (eg User.find_by_address) ease db queries and make queries database syntax independent
'''Cons''' -
* DB creation/management is decoupled from the model, requiring a separate utility (rake/migrate) that must be kept in sync with application

=='''Sequel'''==

[http://sequel.rubyforge.org Sequel] was originally developed by Sharon Rosner and the first release was in March 2007. It is based on the active record pattern. Sequel and Active record share a lot of common features , for example association and inheritance. But Sequel handles these features in a much more flexible manner. Currently Sequel is at version 3.16.0. Initially Sequel was had three core modules - sequel, sequel_core and sequel_model.Starting from version 1.4 , sequel and sequel_model were merged. Sequel handles validations using a validation plug-in and helpers.

Some of the key features of sequel are,
* Connection Pooling
* Thread Safety
* Eager Loading / Lazy Loading
* Model Caching

<pre>
class CreateUser < Sequel::Migration
def up
create_table(:user) {
primary_key :id
String :name
String :password }
end
def down
drop_table(:user)
end
end # CreateUser.apply(DB, :up)
</pre>

==''' DataMapper'''==
http://www.gelens.org/2007/12/13/ruby_orm_datamapper/
Ruby ORM: DataMapper
There is a relative new ORM (Object Relational Mapper) for Ruby called “DataMapper”. Its goal is to create a fast, feature rich and thread-safe(!) ORM. DataMapper can be used standalone or as plugin for example Rails or Merb.
Finally some competition in the Ruby ORM world. Rails’ ActiveRecord is no longer the only usable production ORM. DataMapper’s developers made some radical different fundamental design decisions regarding to migrations and property declarations. Property declarations are now done in the Model itself and not in separate “migration”-files. Which is more elegant in my opinion.
Lately DataMapper is growing fast, it gets more attention and its feature list gets longer and is already superior to AR in terms of speed. A few weeks ago I started a new project using the new ruby framework Merb. Merb is also thread-safe and is in combination with DataMapper a really cool framework. By the way, did you know Rails is not thread-safe? Kinda sucky for a web framework to handle only one connection at a time. That’s the reason why people use multiple Mongrel servers when deploying Rails application. Not everyone I know seems to realize that. The bad thing is, there is NO plan to make it thread-safe :-/.
[http://blog.mattwynne.net/2008/05/23/datamapper-a-better-orm-for-ruby/]
DataMapper: A Better ORM for Ruby
One of the things that’s always irritated my about rails’ ActiveRecord framework is the way that the domain model lives in the database.Don’t get me wrong: it’s very clever, and a great showcase for ruby’s metaprogramming features, which will blow average C# / Java mind the mind when they first see it.
In rails, you build a database of your domain model, and create empty classes with the names of the domain entities (conventionally the singular of a database table name) which inherit from ActiveRecord. ActiveRecord then looks at your database, and using the magic of metaprogramming, hydrates your object with a bunch of properties that map to the database fields.
But I prefer to write my models in the code, and if you do too, you might want to take a look at DataMapper.

=Comparison of ORM Features=
{| class="wikitable sortable" border="1" style="font-size: 100%; text-align: center; width: auto;"
|-
! '''Features'''
! '''ActiveRecord'''
! '''Sequel'''
! '''DataMapper'''
|-
! '''Databases'''
| yes
| yes
| yes
|-
! '''Migrations'''
| yes
| yes
| yes
|-
! '''EagerLoading'''
| yes
| yes
| yes
|-
! '''Flexible Overriding'''
| yes
| yes
| yes
|-
! '''Dynamic Finders'''
| yes
| yes
| yes
|}

<pre>
Code example
</pre>

=Conclusion=
Ruby ORM bla.

 

=References=

[1] [http://ruby-doc.org/ Ruby language]

[2] Fowler, C., The Ruby FAQ, www.rubygarden.org/faq

[3] , Active Record — Object-relation mapping put on rails, http://ar.rubyonrails.org/

==External Links==

#[http://wxruby.rubyforge.org/wiki/wiki.pl WxRuby]
#[http://www.activestate.com/activetcl ActiveTcl for Windows]

CSC/ECE 517 Fall 2010/ch3 3j KS

2010-10-05T00:12:42Z

Kschidam: Additional Sequel Changes

='''Object-relational Mapping for Ruby'''=

__TOC__

=Introduction=

[http://en.wikipedia.org/wiki/Object-relational_mapping Object-relational mapping (ORM)] provides developers with a set of tools that ease management of the relationships between objects and relational databases, thus allowing applications to be easily extended to add data persistence. For Ruby, several object-relational mapping options are available in addition to ActiveRecord, the ORM layer supplied with Rails.

=Overview=

Object-relational Mapping (ORM) frameworks unburden the designer of the complex translation between database and object space.

Typical ORM features:
* Automatic mapping from classes to database tables
** Class instance variables to database columns
** Class instances to table rows
* Aggregation and association relationships between mapped classes are managed
** Example, :has_many, :belongs_to associations in ActiveRecord
** Inheritance cases are mapped to tables
* Validation of data prior to table storage
* Class extensions to enable search, as well as creation, read, update, and deletion (CRUD) of instances/records
* Usually abstracts the database from program space in such a way that alternate database types can be easily chosen (SQLite, Oracle, etc)

The diagram below depicts a simple mapping of an object to a database table….

[[Image:3j_ks_pic1.jpg]]

When applied to Ruby, implementations of ORM often leverage the language’s [http://en.wikipedia.org/wiki/Metaprogramming metaprogramming] strengths to create intuitive application-specific methods and otherwise extend classes to support database functionality.

Perhaps add section w/ examples of typical Ruby ORM techniques here else just cover in each product…

=Comparison of ORM products for Ruby=

==''' ActiveRecord '''==

[http://ar.rubyonrails.org/ ActiveRecord], originally created by David Heinemeier and released in 2003, became the de-facto ORM for Ruby since it was integrated in the widely-used Rails framework, however alternate ORMs for Ruby have been developed and Rails 3.x is ORM independent. ActiveRecord is an implementation of the active record design pattern, where a table is wrapped into a class and this class implements accessor methods for each column in the table. [http://en.wikipedia.org/wiki/Active_record_pattern]

ActiveRecord uses a single table inheritance scheme, which trades off some storage efficiency for simplicity in the database design. Add a pic for to describe…

ActiveRecord manages associations between table elements and provides the means to define such associations in the model definition. For example, the User class shown below defines a ‘’to_many’’ association with both the cheers and posts tables. Also note ActiveRecord’s integrated support for validation of table information when attempting an update.

<pre>
class User < ActiveRecord::Base

has_many :cheers
has_many :posts

validates_presence_of :name
validates_uniqueness_of :name
validates_length_of :name, :within => 3..20
end
</pre>

'''Pros''' -
* Integrated with Rails development framework
* Dynamically created database search methods (eg User.find_by_address) ease db queries and make queries database syntax independent
'''Cons''' -
* DB creation/management is decoupled from the model, requiring a separate utility (rake/migrate) that must be kept in sync with application

=='''Sequel'''==

[http://sequel.rubyforge.org Sequel] was originally developed by Sharon Rosner and the first release was in March 2007. It is based on the active record pattern. Sequel and Active record share a lot of common features , for example association and inheritance. But Sequel handles these features in a much more flexible manner. Currently Sequel is at version 3.16.0. Initially Sequel was had three core modules - sequel, sequel_core and sequel_model.Starting from version 1.4 , sequel and sequel_model were merged. Sequel handles validations using a validation plug-in and helpers.

Some of the key features of sequel are,
* Connection Pooling
* Thread Safety
* Eager Loading / Lazy Loading
* Model Caching

<pre>
class CreateUser < Sequel::Migration
def up
create_table(:user) {
primary_key :id
String :name
String :password }
end
def down
drop_table(:user)
end
end # CreateUser.apply(DB, :up)
</pre>

==''' DataMapper'''==
http://www.gelens.org/2007/12/13/ruby_orm_datamapper/
Ruby ORM: DataMapper
There is a relative new ORM (Object Relational Mapper) for Ruby called “DataMapper”. Its goal is to create a fast, feature rich and thread-safe(!) ORM. DataMapper can be used standalone or as plugin for example Rails or Merb.
Finally some competition in the Ruby ORM world. Rails’ ActiveRecord is no longer the only usable production ORM. DataMapper’s developers made some radical different fundamental design decisions regarding to migrations and property declarations. Property declarations are now done in the Model itself and not in separate “migration”-files. Which is more elegant in my opinion.
Lately DataMapper is growing fast, it gets more attention and its feature list gets longer and is already superior to AR in terms of speed. A few weeks ago I started a new project using the new ruby framework Merb. Merb is also thread-safe and is in combination with DataMapper a really cool framework. By the way, did you know Rails is not thread-safe? Kinda sucky for a web framework to handle only one connection at a time. That’s the reason why people use multiple Mongrel servers when deploying Rails application. Not everyone I know seems to realize that. The bad thing is, there is NO plan to make it thread-safe :-/.
[http://blog.mattwynne.net/2008/05/23/datamapper-a-better-orm-for-ruby/]
DataMapper: A Better ORM for Ruby
One of the things that’s always irritated my about rails’ ActiveRecord framework is the way that the domain model lives in the database.Don’t get me wrong: it’s very clever, and a great showcase for ruby’s metaprogramming features, which will blow average C# / Java mind the mind when they first see it.
In rails, you build a database of your domain model, and create empty classes with the names of the domain entities (conventionally the singular of a database table name) which inherit from ActiveRecord. ActiveRecord then looks at your database, and using the magic of metaprogramming, hydrates your object with a bunch of properties that map to the database fields.
But I prefer to write my models in the code, and if you do too, you might want to take a look at DataMapper.

==Chart example==
{| class="wikitable sortable" border="1" style="font-size: 100%; text-align: center; width: auto;"
|-
! '''aaaaaa'''
! '''bbbbbbb'''
! '''cccc'''
! '''ddddddddd'''
|-
! '''AA'''
| yes
| yes
| yes
|-
! '''BBBBB'''
| yes
| yes
| yes
|-
! '''CCCC'''
| yes
| yes
| yes
|-
! '''DDDD'''
| yes
| yes
| yes
|-
! '''EEEE'''
| yes
| yes
| yes
|}

<pre>
Code example
</pre>

=Conclusion=
Ruby ORM bla.

 

=References=

[1] [http://ruby-doc.org/ Ruby language]

[2] Fowler, C., The Ruby FAQ, www.rubygarden.org/faq

[3] , Active Record — Object-relation mapping put on rails, http://ar.rubyonrails.org/

==External Links==

#[http://wxruby.rubyforge.org/wiki/wiki.pl WxRuby]
#[http://www.activestate.com/activetcl ActiveTcl for Windows]

CSC/ECE 517 Fall 2010/ch3 3j KS

2010-10-04T23:57:26Z

Kschidam:

CSC/ECE 517 Fall 2010/ch3 3j KS

2010-10-04T23:35:45Z

Kschidam:

='''Object-relational Mapping for Ruby'''=

__TOC__

=Introduction=

[http://en.wikipedia.org/wiki/Object-relational_mapping Object-relational mapping (ORM)] provides developers with a set of tools that ease management of the relationships between objects and relational databases, thus allowing applications to be easily extended to add data persistence. For Ruby, several object-relational mapping options are available in addition to ActiveRecord, the ORM layer supplied with Rails.

=Overview=

Object-relational Mapping (ORM) frameworks unburden the designer of the complex translation between database and object space.

Typical ORM features:
* Automatic mapping from classes to database tables
** Class instance variables to database columns
** Class instances to table rows
* Aggregation and association relationships between mapped classes are managed
** Example, :has_many, :belongs_to associations in ActiveRecord
** Inheritance cases are mapped to tables
* Validation of data prior to table storage
* Class extensions to enable search, as well as creation, read, update, and deletion (CRUD) of instances/records
* Usually abstracts the database from program space in such a way that alternate database types can be easily chosen (SQLite, Oracle, etc)

The diagram below depicts a simple mapping of an object to a database table….

[[Image:3j_ks_pic1.jpg]]

When applied to Ruby, implementations of ORM often leverage the language’s [http://en.wikipedia.org/wiki/Metaprogramming metaprogramming] strengths to create intuitive application-specific methods and otherwise extend classes to support database functionality.

Perhaps add section w/ examples of typical Ruby ORM techniques here else just cover in each product…

=Comparison of ORM products for Ruby=

==''' ActiveRecord '''==

[http://ar.rubyonrails.org/ ActiveRecord], originally created by David Heinemeier and released in 2003, became the de-facto ORM for Ruby since it was integrated in the widely-used Rails framework, however alternate ORMs for Ruby have been developed and Rails 3.x is ORM independent. ActiveRecord is an implementation of the active record design pattern, where a table is wrapped into a class and this class implements accessor methods for each column in the table. [http://en.wikipedia.org/wiki/Active_record_pattern]

ActiveRecord uses a single table inheritance scheme, which trades off some storage efficiency for simplicity in the database design. Add a pic for to describe…

ActiveRecord manages associations between table elements and provides the means to define such associations in the model definition. For example, the User class shown below defines a ‘’to_many’’ association with both the cheers and posts tables. Also note ActiveRecord’s integrated support for validation of table information when attempting an update.

<pre>
class User < ActiveRecord::Base

has_many :cheers
has_many :posts

validates_presence_of :name
validates_uniqueness_of :name
validates_length_of :name, :within => 3..20
end
</pre>

'''Pros''' -
* Integrated with Rails development framework
* Dynamically created database search methods (eg User.find_by_address) ease db queries and make queries database syntax independent
'''Cons''' -
* DB creation/management is decoupled from the model, requiring a separate utility (rake/migrate) that must be kept in sync with application

=='''Sequel'''==

[http://sequel.rubyforge.org]

* table definition and mapping to object structure explicitly made in ruby vs external tool (rake) as in RoR

prod description
http://sequel.rubyforge.org/rdoc/files/README_rdoc.html

Sequel: The Database Toolkit for Ruby
Sequel is a simple, flexible, and powerful SQL database access toolkit for Ruby.
Sequel provides thread safety, connection pooling and a concise DSL for constructing SQL queries and table schemas.
Sequel includes a comprehensive ORM layer for mapping records to Ruby objects and handling associated records.
Sequel supports advanced database features such as prepared statements, bound variables, stored procedures, savepoints, two-phase commit, transaction isolation, master/slave configurations, and database sharding.
Sequel currently has adapters for ADO, Amalgalite, DataObjects, DB2, DBI, Firebird, Informix, JDBC, MySQL, Mysql2, ODBC, OpenBase, Oracle, PostgreSQL and SQLite3.

'''Pros''' -
* zzz

'''Cons''' -
* zzz

==''' DataMapper'''==
http://www.gelens.org/2007/12/13/ruby_orm_datamapper/
Ruby ORM: DataMapper
There is a relative new ORM (Object Relational Mapper) for Ruby called “DataMapper”. Its goal is to create a fast, feature rich and thread-safe(!) ORM. DataMapper can be used standalone or as plugin for example Rails or Merb.
Finally some competition in the Ruby ORM world. Rails’ ActiveRecord is no longer the only usable production ORM. DataMapper’s developers made some radical different fundamental design decisions regarding to migrations and property declarations. Property declarations are now done in the Model itself and not in separate “migration”-files. Which is more elegant in my opinion.
Lately DataMapper is growing fast, it gets more attention and its feature list gets longer and is already superior to AR in terms of speed. A few weeks ago I started a new project using the new ruby framework Merb. Merb is also thread-safe and is in combination with DataMapper a really cool framework. By the way, did you know Rails is not thread-safe? Kinda sucky for a web framework to handle only one connection at a time. That’s the reason why people use multiple Mongrel servers when deploying Rails application. Not everyone I know seems to realize that. The bad thing is, there is NO plan to make it thread-safe :-/.
[http://blog.mattwynne.net/2008/05/23/datamapper-a-better-orm-for-ruby/]
DataMapper: A Better ORM for Ruby
One of the things that’s always irritated my about rails’ ActiveRecord framework is the way that the domain model lives in the database.Don’t get me wrong: it’s very clever, and a great showcase for ruby’s metaprogramming features, which will blow average C# / Java mind the mind when they first see it.
In rails, you build a database of your domain model, and create empty classes with the names of the domain entities (conventionally the singular of a database table name) which inherit from ActiveRecord. ActiveRecord then looks at your database, and using the magic of metaprogramming, hydrates your object with a bunch of properties that map to the database fields.
But I prefer to write my models in the code, and if you do too, you might want to take a look at DataMapper.

==Chart example==
{| class="wikitable sortable" border="1" style="font-size: 100%; text-align: center; width: auto;"
|-
! '''aaaaaa'''
! '''bbbbbbb'''
! '''cccc'''
! '''ddddddddd'''
|-
! '''AA'''
| yes
| yes
| yes
|-
! '''BBBBB'''
| yes
| yes
| yes
|-
! '''CCCC'''
| yes
| yes
| yes
|-
! '''DDDD'''
| yes
| yes
| yes
|-
! '''EEEE'''
| yes
| yes
| yes
|}

<pre>
Code example
</pre>

=Conclusion=
Ruby ORM bla.

 

=References=

[1] [http://ruby-doc.org/ Ruby language]

[2] Fowler, C., The Ruby FAQ, www.rubygarden.org/faq

[3] , Active Record — Object-relation mapping put on rails, http://ar.rubyonrails.org/

==External Links==

#[http://wxruby.rubyforge.org/wiki/wiki.pl WxRuby]
#[http://www.activestate.com/activetcl ActiveTcl for Windows]

CSC/ECE 517 Fall 2010/ch3 3j KS

2010-10-04T23:34:55Z

Kschidam: /* '''Sequel''' */

='''Object-relational Mapping for Ruby'''=

__TOC__

=Introduction=

[http://en.wikipedia.org/wiki/Object-relational_mapping Object-relational mapping (ORM)] provides developers with a set of tools that ease management of the relationships between objects and relational databases, thus allowing applications to be easily extended to add data persistence. For Ruby, several object-relational mapping options are available in addition to ActiveRecord, the ORM layer supplied with Rails.

=Overview=

Object-relational Mapping (ORM) frameworks unburden the designer of the complex translation between database and object space.

Typical ORM features:
* Automatic mapping from classes to database tables
** Class instance variables to database columns
** Class instances to table rows
* Aggregation and association relationships between mapped classes are managed
** Example, :has_many, :belongs_to associations in ActiveRecord
** Inheritance cases are mapped to tables
* Validation of data prior to table storage
* Class extensions to enable search, as well as creation, read, update, and deletion (CRUD) of instances/records
* Usually abstracts the database from program space in such a way that alternate database types can be easily chosen (SQLite, Oracle, etc)

The diagram below depicts a simple mapping of an object to a database table….

[[Image:3j_ks_pic1.jpg]]

When applied to Ruby, implementations of ORM often leverage the language’s [http://en.wikipedia.org/wiki/Metaprogramming metaprogramming] strengths to create intuitive application-specific methods and otherwise extend classes to support database functionality.

Perhaps add section w/ examples of typical Ruby ORM techniques here else just cover in each product…

=Comparison of ORM products for Ruby=

==''' ActiveRecord '''==

[http://ar.rubyonrails.org/ ActiveRecord], originally created by David Heinemeier and released in 2003, became the de-facto ORM for Ruby since it was integrated in the widely-used Rails framework, however alternate ORMs for Ruby have been developed and Rails 3.x is ORM independent. ActiveRecord is an implementation of the active record design pattern, where a table is wrapped into a class and this class implements accessor methods for each column in the table. [http://en.wikipedia.org/wiki/Active_record_pattern]

ActiveRecord uses a single table inheritance scheme, which trades off some storage efficiency for simplicity in the database design. Add a pic for to describe…

ActiveRecord manages associations between table elements and provides the means to define such associations in the model definition. For example, the User class shown below defines a ‘’to_many’’ association with both the cheers and posts tables. Also note ActiveRecord’s integrated support for validation of table information when attempting an update.

<pre>
class User < ActiveRecord::Base

has_many :cheers
has_many :posts

validates_presence_of :name
validates_uniqueness_of :name
validates_length_of :name, :within => 3..20
end
</pre>

'''Pros''' -
* Integrated with Rails development framework
* Dynamically created database search methods (eg User.find_by_address) ease db queries and make queries database syntax independent
'''Cons''' -
* DB creation/management is decoupled from the model, requiring a separate utility (rake/migrate) that must be kept in sync with application

=='''Sequel'''== [http://sequel.rubyforge.org]

* table definition and mapping to object structure explicitly made in ruby vs external tool (rake) as in RoR

prod description
http://sequel.rubyforge.org/rdoc/files/README_rdoc.html

Sequel: The Database Toolkit for Ruby
Sequel is a simple, flexible, and powerful SQL database access toolkit for Ruby.
Sequel provides thread safety, connection pooling and a concise DSL for constructing SQL queries and table schemas.
Sequel includes a comprehensive ORM layer for mapping records to Ruby objects and handling associated records.
Sequel supports advanced database features such as prepared statements, bound variables, stored procedures, savepoints, two-phase commit, transaction isolation, master/slave configurations, and database sharding.
Sequel currently has adapters for ADO, Amalgalite, DataObjects, DB2, DBI, Firebird, Informix, JDBC, MySQL, Mysql2, ODBC, OpenBase, Oracle, PostgreSQL and SQLite3.

'''Pros''' -
* zzz

'''Cons''' -
* zzz

==''' DataMapper'''==
http://www.gelens.org/2007/12/13/ruby_orm_datamapper/
Ruby ORM: DataMapper
There is a relative new ORM (Object Relational Mapper) for Ruby called “DataMapper”. Its goal is to create a fast, feature rich and thread-safe(!) ORM. DataMapper can be used standalone or as plugin for example Rails or Merb.
Finally some competition in the Ruby ORM world. Rails’ ActiveRecord is no longer the only usable production ORM. DataMapper’s developers made some radical different fundamental design decisions regarding to migrations and property declarations. Property declarations are now done in the Model itself and not in separate “migration”-files. Which is more elegant in my opinion.
Lately DataMapper is growing fast, it gets more attention and its feature list gets longer and is already superior to AR in terms of speed. A few weeks ago I started a new project using the new ruby framework Merb. Merb is also thread-safe and is in combination with DataMapper a really cool framework. By the way, did you know Rails is not thread-safe? Kinda sucky for a web framework to handle only one connection at a time. That’s the reason why people use multiple Mongrel servers when deploying Rails application. Not everyone I know seems to realize that. The bad thing is, there is NO plan to make it thread-safe :-/.
[http://blog.mattwynne.net/2008/05/23/datamapper-a-better-orm-for-ruby/]
DataMapper: A Better ORM for Ruby
One of the things that’s always irritated my about rails’ ActiveRecord framework is the way that the domain model lives in the database.Don’t get me wrong: it’s very clever, and a great showcase for ruby’s metaprogramming features, which will blow average C# / Java mind the mind when they first see it.
In rails, you build a database of your domain model, and create empty classes with the names of the domain entities (conventionally the singular of a database table name) which inherit from ActiveRecord. ActiveRecord then looks at your database, and using the magic of metaprogramming, hydrates your object with a bunch of properties that map to the database fields.
But I prefer to write my models in the code, and if you do too, you might want to take a look at DataMapper.

==Chart example==
{| class="wikitable sortable" border="1" style="font-size: 100%; text-align: center; width: auto;"
|-
! '''aaaaaa'''
! '''bbbbbbb'''
! '''cccc'''
! '''ddddddddd'''
|-
! '''AA'''
| yes
| yes
| yes
|-
! '''BBBBB'''
| yes
| yes
| yes
|-
! '''CCCC'''
| yes
| yes
| yes
|-
! '''DDDD'''
| yes
| yes
| yes
|-
! '''EEEE'''
| yes
| yes
| yes
|}

<pre>
Code example
</pre>

=Conclusion=
Ruby ORM bla.

 

=References=

[1] [http://ruby-doc.org/ Ruby language]

[2] Fowler, C., The Ruby FAQ, www.rubygarden.org/faq

[3] , Active Record — Object-relation mapping put on rails, http://ar.rubyonrails.org/

==External Links==

#[http://wxruby.rubyforge.org/wiki/wiki.pl WxRuby]
#[http://www.activestate.com/activetcl ActiveTcl for Windows]

CSC/ECE 517 Fall 2010/ch3 3j KS

2010-10-04T01:32:54Z

Kschidam: Initial Draft from Scott's document

='''Object-relational Mapping for Ruby'''=

__TOC__

=Introduction=

[http://en.wikipedia.org/wiki/Object-relational_mapping Object-relational mapping (ORM)] provides developers with a set of tools that ease management of the relationships between objects and relational databases, thus allowing applications to be easily extended to add data persistence. For Ruby, several object-relational mapping options are available in addition to ActiveRecord, the ORM layer supplied with Rails.

=Overview=

Object-relational Mapping (ORM) frameworks unburden the designer of the complex translation between database and object space.

Typical ORM features:
* Automatic mapping from classes to database tables
** Class instance variables to database columns
** Class instances to table rows
* Aggregation and association relationships between mapped classes are managed
** Example, :has_many, :belongs_to associations in ActiveRecord
** Inheritance cases are mapped to tables
* Validation of data prior to table storage
* Class extensions to enable search, as well as creation, read, update, and deletion (CRUD) of instances/records
* Usually abstracts the database from program space in such a way that alternate database types can be easily chosen (SQLite, Oracle, etc)

The diagram below depicts a simple mapping of an object to a database table….

[[Image:3j_ks_pic1.jpg]]

When applied to Ruby, implementations of ORM often leverage the language’s [http://en.wikipedia.org/wiki/Metaprogramming metaprogramming] strengths to create intuitive application-specific methods and otherwise extend classes to support database functionality.

Perhaps add section w/ examples of typical Ruby ORM techniques here else just cover in each product…

=Comparison of ORM products for Ruby=

==''' ActiveRecord '''==

[http://ar.rubyonrails.org/ ActiveRecord], originally created by David Heinemeier and released in 2003, became the de-facto ORM for Ruby since it was integrated in the widely-used Rails framework, however alternate ORMs for Ruby have been developed and Rails 3.x is ORM independent. ActiveRecord is an implementation of the active record design pattern, where a table is wrapped into a class and this class implements accessor methods for each column in the table. [http://en.wikipedia.org/wiki/Active_record_pattern]

ActiveRecord uses a single table inheritance scheme, which trades off some storage efficiency for simplicity in the database design. Add a pic for to describe…

ActiveRecord manages associations between table elements and provides the means to define such associations in the model definition. For example, the User class shown below defines a ‘’to_many’’ association with both the cheers and posts tables. Also note ActiveRecord’s integrated support for validation of table information when attempting an update.

<pre>
class User < ActiveRecord::Base

has_many :cheers
has_many :posts

validates_presence_of :name
validates_uniqueness_of :name
validates_length_of :name, :within => 3..20
end
</pre>

'''Pros''' -
* Integrated with Rails development framework
* Dynamically created database search methods (eg User.find_by_address) ease db queries and make queries database syntax independent
'''Cons''' -
* DB creation/management is decoupled from the model, requiring a separate utility (rake/migrate) that must be kept in sync with application

=='''Sequel'''==

[http://sequel.rubyforge.org]
* table definition and mapping to object structure explicitly made in ruby vs external tool (rake) as in RoR

prod description
http://sequel.rubyforge.org/rdoc/files/README_rdoc.html

Sequel: The Database Toolkit for Ruby
Sequel is a simple, flexible, and powerful SQL database access toolkit for Ruby.
Sequel provides thread safety, connection pooling and a concise DSL for constructing SQL queries and table schemas.
Sequel includes a comprehensive ORM layer for mapping records to Ruby objects and handling associated records.
Sequel supports advanced database features such as prepared statements, bound variables, stored procedures, savepoints, two-phase commit, transaction isolation, master/slave configurations, and database sharding.
Sequel currently has adapters for ADO, Amalgalite, DataObjects, DB2, DBI, Firebird, Informix, JDBC, MySQL, Mysql2, ODBC, OpenBase, Oracle, PostgreSQL and SQLite3.

'''Pros''' -
* zzz

'''Cons''' -
* zzz

==''' DataMapper'''==
http://www.gelens.org/2007/12/13/ruby_orm_datamapper/
Ruby ORM: DataMapper
There is a relative new ORM (Object Relational Mapper) for Ruby called “DataMapper”. Its goal is to create a fast, feature rich and thread-safe(!) ORM. DataMapper can be used standalone or as plugin for example Rails or Merb.
Finally some competition in the Ruby ORM world. Rails’ ActiveRecord is no longer the only usable production ORM. DataMapper’s developers made some radical different fundamental design decisions regarding to migrations and property declarations. Property declarations are now done in the Model itself and not in separate “migration”-files. Which is more elegant in my opinion.
Lately DataMapper is growing fast, it gets more attention and its feature list gets longer and is already superior to AR in terms of speed. A few weeks ago I started a new project using the new ruby framework Merb. Merb is also thread-safe and is in combination with DataMapper a really cool framework. By the way, did you know Rails is not thread-safe? Kinda sucky for a web framework to handle only one connection at a time. That’s the reason why people use multiple Mongrel servers when deploying Rails application. Not everyone I know seems to realize that. The bad thing is, there is NO plan to make it thread-safe :-/.
[http://blog.mattwynne.net/2008/05/23/datamapper-a-better-orm-for-ruby/]
DataMapper: A Better ORM for Ruby
One of the things that’s always irritated my about rails’ ActiveRecord framework is the way that the domain model lives in the database.Don’t get me wrong: it’s very clever, and a great showcase for ruby’s metaprogramming features, which will blow average C# / Java mind the mind when they first see it.
In rails, you build a database of your domain model, and create empty classes with the names of the domain entities (conventionally the singular of a database table name) which inherit from ActiveRecord. ActiveRecord then looks at your database, and using the magic of metaprogramming, hydrates your object with a bunch of properties that map to the database fields.
But I prefer to write my models in the code, and if you do too, you might want to take a look at DataMapper.

==Chart example==
{| class="wikitable sortable" border="1" style="font-size: 100%; text-align: center; width: auto;"
|-
! '''aaaaaa'''
! '''bbbbbbb'''
! '''cccc'''
! '''ddddddddd'''
|-
! '''AA'''
| yes
| yes
| yes
|-
! '''BBBBB'''
| yes
| yes
| yes
|-
! '''CCCC'''
| yes
| yes
| yes
|-
! '''DDDD'''
| yes
| yes
| yes
|-
! '''EEEE'''
| yes
| yes
| yes
|}

<pre>
Code example
</pre>

=Conclusion=
Ruby ORM bla.

 

=References=

[1] [http://ruby-doc.org/ Ruby language]

[2] Fowler, C., The Ruby FAQ, www.rubygarden.org/faq

[3] , Active Record — Object-relation mapping put on rails, http://ar.rubyonrails.org/

==External Links==

#[http://wxruby.rubyforge.org/wiki/wiki.pl WxRuby]
#[http://www.activestate.com/activetcl ActiveTcl for Windows]