Microsoft.NET

……………………………………………….Expertise in .NET Technologies

Oracle Constraints – Part X

Posted by Ravi Varma Thumati on October 14, 2009

Maintaining security and integrity of a database is the most important factor. Such limitations have to be enforced on the data, and only that data which satisfies the conditions will actually be stored for analysis.

If the data gathered fails to satisfy the conditions set, it is rejected. This technique ensures that the data that is stored in the database will be valid, and has integrity. Rules, which are enforced on data being entered and prevents user from entering invalid data into tables are called constraints. Thus, constraints are super control data being entered in tables for permanent storage.

Oracle permits data constraints to be attached to table columns via SQL syntax that will check data for integrity. Once data constraints are part of a table column construction, the Oracle engine checks the data being entered into a table column against the data constraints. If the data passes this check, it is stored in the table, else the data is rejected. Even if a single column of the record being entered into the table fails a constraint, the entire record is rejected and not stored in the table. Both the “Create table” and “Alter table” SQL verbs can be used to write SQL sentences that attach constraints to a table column.

Until now we have created table without using any constraint, Hence the tables have not been given any instructions to filter what is being stored in the table.

The following are the types of integrity constraints

  • Domain Integrity constraints
  • Entity Integrity constraints
  • Referential Integrity constraint

Oracle allows programmers to define constraints

  • Column Level
  • Table Level

Column Level constraints

If data constraints are defined along with the column definition when creating or altering a table structure, they are column level constraints. Column level constraints are applied to the current column. The current column is the column that immediately precedes the constraints i.e. they are local to a specific column. Column level constraints cannot be applied if the data constraints span across the multiple columns in a table.

Table Level Constraint

If the data constraints are defined after defining all the table columns when creating or altering a table structure, it is a table level constraint. Table Level constraints mostly used when data constraints spans across multiple columns in a table.

Domain Integrity Constraints

These constraints set a range and any violations that take place will prevent the user from performing the manipulations that caused the breached.

Domain integrity constraints are classified into two types

  • Not Null constraint
  • Check constraint

Not Null Constraint

Often there may be records in a table that do not have values for every field, either because the information is not available at the time of data entry or because field is not applicable in every case. Oracle will place a null value in the column in the absence of a user-defined value. By default every column will accept null values.

A Null values is different from a blank or a zero. We can say that Null means undefined. Null are treated specially by Oracle. When a column is defined as not null, then that column becomes mandatory column. It implies that a value must be entered into the column. Remember that not null constraints can be applied on column level only.

Example

SQL> create table item_master

(item_code varchar(5) not null,

item_name varchar(25) constraint n1 not null,

item_rate number(7,2),

item_desc varchar(50));

Table created.

This declaration is specifying that first two columns will not accept null values.

In above command n1 is a user defined constraint name of item_name column. While constraint name assigned internally to item_code column, because we omit user-defined constraint name to it.

One can add not null constraint in existing table as follows:

SQL> alter table item_master modify item_desc not null;

While one can try to insert null value using

Insert into item_master(item_desc) values (null);

Will cause following error

ERROR at line 1:

ORA-02296: cannot enable (SCOTT.ITEM_MASTER.ITEM_DESC) – null values found

To drop not null constraint

Example:

SQL>Alter table item_master modify item_desc null;

Now item_desc column can accept Null values.

SQL> insert into item_master (item_desc) values (null);

1 row created.

Check Constraint

Business rule validations can be applied on a column using Check constraint. Check constraint must be specified by logical or boolean expressions.

A check constraint allows you to specify a condition on each row in a table.

Note:

  • A check constraint can NOT be defined on a VIEW.
  • The check constraint defined on a table must refer to only columns in that table. It can not refer to columns in other tables.
  • A check constraint can NOT include a SUBQUERY.

A check constraint can be defined in either a CREATE TABLE statement or an ALTER TABLE statement.

The syntax for creating a check constraint using a CREATE TABLE statement is:

CREATE TABLE table_name
(column1 datatype null/not null,
column2 datatype null/not null,

CONSTRAINT constraint_name CHECK (column_name condition) [DISABLE]
);

The DISABLE keyword is optional. If you create a check constraint using the DISABLE keyword, the constraint will be created, but the condition will not be enforced.

Create a client_master table with following check constraints.

  1. Data values being inserted into the column client_no must starts with the capital letter ‘C’
  2. Data values being inserted into the column name should be in upper case only.
  3. Only allow “Mumbai” or “Ahmedabad” values for the city column.

Check constraint defined at column level as per follows:

SQL> create table client_master (client_no varchar(6) check client_no

like ‘C%’), name varchar(20) check (name = upper(name)),address1

varchar(30), address2 varchar(30), city varchar(20) check (city in

(‘Mumbai’,’Ahemedabad’));

Table created.

Check constraint defined at table level as per follows:

SQL> create table client_master (client_no varchar(6), name varchar(20),

address1 varchar(30), address2 varchar(30),city varchar(20),check (client_no like ‘C%’),

check (name = upper(name)));

Table created.

Check constraint with Alter command

The syntax for creating a check constraint in an ALTER TABLE statement is:

ALTER TABLE table_name
add CONSTRAINT constraint_name CHECK (column_name condition) [DISABLE];

The DISABLE keyword is optional. If you create a check constraint using the DISABLE keyword, the constraint will be created, but the condition will not be enforced.

SQL> alter table client_master add constraint chk_city check (city

(‘Mumbai’,’Ahmedabad’));

Table altered.

Drop a Check Constraint

The syntax for dropping a check constraint is:

ALTER TABLE table_name
drop CONSTRAINT constraint_name;

For example:

ALTER TABLE suppliers
drop CONSTRAINT check_supplier_id;

In this example, we’re dropping a check constraint on the suppliers table called check_supplier_id.

Enable a Check Constraint

The syntax for enabling a check constraint is:

ALTER TABLE table_name
enable CONSTRAINT constraint_name;

For example:

ALTER TABLE suppliers
enable CONSTRAINT check_supplier_id;

In this example, we’re enabling a check constraint on the suppliers table called check_supplier_id.

Disable a Check Constraint

The syntax for disabling a check constraint is:

ALTER TABLE table_name
disable CONSTRAINT constraint_name;

For example:

ALTER TABLE suppliers
disable CONSTRAINT check_supplier_id;

In this example, we’re disabling a check constraint on the suppliers table called check_supplier_id.

Entity Integrity Constraints

This type of constraints are further classified into

  • Unique Constraint
  • Primary Key Constraint

Unique Constraint

The purpose of unique key is to ensure that information in the column(s) is unique i.e. the value entered in column(s) defined in the unique constraint must not be repeated across the column. A table may have many unique keys. If unique constraint is defined in more than one column (combination of columns), it is said to be composite unique key. Maximum combination of columns that a composite unique key can contain is 16.

What is a unique constraint?

A unique constraint is a single field or combination of fields that uniquely defines a record. Some of the fields can contain null values as long as the combination of values is unique.

Note:

In Oracle, a unique constraint can not contain more than 32 columns.

A unique constraint can be defined in either a CREATE TABLE statement or an ALTER TABLE statement.

What is the difference between a unique constraint and a primary key?

Primary Key

Unique Constraint

None of the fields that are part of the primary key can contain a null value. Some of the fields that are part of the unique constraint can contain null values as long as the combination of values is unique.

Oracle does not permit you to create both a primary key and unique constraint with the same columns.

Using a CREATE TABLE statement

The syntax for creating a unique constraint using a CREATE TABLE statement is:

CREATE TABLE table_name
(column1 datatype null/not null,
column2 datatype null/not null,

CONSTRAINT constraint_name UNIQUE (column1, column2, . column_n)
);

Example:

SQL> create table client_master (client_no varchar(6) Unique, name varchar(20), address1 varchar(30), address2 varchar(30),city );

Table created.

We could also create a unique constraint with more than one field as in the example below:

CREATE TABLE supplier

( supplier_id      numeric(10)           not null,

supplier_name                     varchar2(50)            not null,

contact_name                      varchar2(50),

CONSTRAINT supplier_unique UNIQUE (supplier_id, supplier_name)

);

Unique constraint defined at table level

Example:

SQL> create table client_master (client_no varchar(6), name varchar(20),

address1 varchar(30), address2 varchar(30),city varchar(20),

Unique(client_no));

OR

SQL> create table client_master (client_no varchar(6), name varchar(20),

address1 varchar(30), address2 varchar(30),city varchar(20),constraint

uni1 Unique (client_no));

Table created.

Unique constraint with alter command

The syntax for creating a unique constraint in an ALTER TABLE statement is:

ALTER TABLE table_name
add CONSTRAINT constraint_name UNIQUE (column1, column2, … column_n);

Example:

SQL> Alter table client_master add constraint uni1 Unique (client_no);

We could also create a unique constraint with more than one field as in the example below:

ALTER TABLE supplier
add CONSTRAINT supplier_unique UNIQUE (supplier_id, supplier_name);

Drop a Unique Constraint

The syntax for dropping a unique constraint is:

ALTER TABLE table_name
drop CONSTRAINT constraint_name;

For example:

ALTER TABLE supplier
drop CONSTRAINT supplier_unique;

In this example, we’re dropping a unique constraint on the supplier table called supplier_unique.

Disable a Unique Constraint

The syntax for disabling a unique constraint is:

ALTER TABLE table_name
disable CONSTRAINT constraint_name;

For example:

ALTER TABLE supplier
disable CONSTRAINT supplier_unique;

In this example, we’re disabling a unique constraint on the supplier table called supplier_unique.

Enable a Unique Constraint

The syntax for enabling a unique constraint is:

ALTER TABLE table_name
enable CONSTRAINT constraint_name;

For example:

ALTER TABLE supplier
enable CONSTRAINT supplier_unique;

In this example, we’re enabling a unique constraint on the supplier table called supplier_unique.

Primary Key Constraint

A primary key is one or on more columns(s) in a table to uniquely identify each row in the table. A primary key column in a table has a special attribute. It defines the column, as a mandatory column i.e. the column cannot be left blank and should have a unique value. Here by default not null constraint is attached with the column.

A multicolumn primary key is called a Composite primary key. The only function of a primary key in a table is to uniquely identify a row. A table can have only one primary key.

Note:

In Oracle, a primary key can not contain more than 32 columns.

A primary key can be defined in either a CREATE TABLE statement or an ALTER TABLE statement.

Using a CREATE TABLE statement

The syntax for creating a primary key using a CREATE TABLE statement is:

CREATE TABLE table_name
(column1 datatype null/not null,
column2 datatype null/not null,

CONSTRAINT constraint_name PRIMARY KEY (column1, column2, . column_n)
);

Primary key constraint at the column level

Example:

SQL> create table order_master (order_no varchar(5) constraint pr_ono

primary key, order_dt date, vencode varchar(5), order_status char(1),

del_dt date);

Table created.

SQL> insert into order_master values (‘O001’,’20-jun-01’, ‘V001’,

‘c’,’22-jun-01’);

1 row created.

SQL> insert into order_master values (‘O001’,’20-jun-01’, ‘V001’,‘c’,’22-jun-01’);

ERROR at line 1:

ORA-00001: unique constraint (SCOTT.PR_ONO) violated

If we insert already inserted order_no the above mentioned error will generate.

SQL> insert into order_master values (null,’20-jun-01’, ‘V001’,‘c’,’22-jun-01’);

ERROR at line 1:

ORA-01400 :cannot insert NULL into (“SCOTT”. “ORDER_MASTER” .”ORDER_NO”

)

If we try to insert null values it will generate error message.

Primary key defined at the table level

Example:

SQL> create table vendor_master (ven_code varchar(5), ven_name varchar(20), venadd1 varchar(15), venadd2 varchar(15),vencity varchar(15), constraint pr_ven primary key (ven_code));

Table created.

Composite Primary key defined at the table level: Composite Primary key is a primary key created with the combination of more than one key and combination values of both the fields should be unique

Example:

SQL> create table vendor_master (ven_code varchar(5), ven_name varchar(20), venadd1 varchar(15), venadd2 varchar(15),vencity varchar(15), constraint pr_com primary key (ven_code,ven_name));

Table created.

Primary key with alter command:

The syntax for creating a primary key in an ALTER TABLE statement is:

ALTER TABLE table_name
add CONSTRAINT constraint_name PRIMARY KEY (column1, column2, … column_n);

SQL> alter table emp_master add constraint pr_eno primary key (empno);

Table altered.

Disable a Primary Key

The syntax for disabling a primary key is:

ALTER TABLE table_name
disable CONSTRAINT constraint_name;

For example:

ALTER TABLE supplier
disable CONSTRAINT supplier_pk;

In this example, we’re disabling a primary key on the supplier table called supplier_pk.

Enable a Primary Key

The syntax for enabling a primary key is:

ALTER TABLE table_name
enable CONSTRAINT constraint_name;

For example:

ALTER TABLE supplier
enable CONSTRAINT supplier_pk;

In this example, we’re enabling a primary key on the supplier table called supplier_pk.

Referential Integrity Constraint

In this category there is only one constraint and it is Foreign Key & References to establish a “parent-child” or a “master-detail” relationship between two tables having a common column, we make use of referential integrity constraint.

Foreign key represent relationships between tables. A foreign key is a column whose values are derived from the primary key or unique key. The table in which the foreign key is defined is called a foreign table or Detail table. The table that defines the primary or unique keys and is referenced by the foreign key is called the Primary table or Master table.

The master table can be referenced in the foreign key definition by using references keyword. If the column name is not specified, by default, Oracle references the primary key in the master table. The existence of a foreign key implies that the table with the foreign key is related to the master table from which the foreign key is derived. A foreign key must have a corresponding primary key or a unique key value in a master table.

Principles of Foreign Key Constraint

  • Rejects an insert or update of a value in a particular column, if a corresponding value does not exist in the master table.
  • Deletion of rows from the Master table is not possible if detail table having corresponding values.
  • Primary key or unique key must in Master table.
  • Requires that the Foreign key column(s) and reference column(s) have same data type

The referenced table is called the parent table while the table with the foreign key is called the child table. The foreign key in the child table will generally reference a primary key in the parent table.

A foreign key can be defined in either a CREATE TABLE statement or an ALTER TABLE statement.

Using a CREATE TABLE statement

The syntax for creating a foreign key using a CREATE TABLE statement is:

CREATE TABLE table_name
(column1 datatype null/not null,
column2 datatype null/not null,

CONSTRAINT fk_column
FOREIGN KEY (column1, column2, … column_n)
REFERENCES parent_table (column1, column2, … column_n)
);

References constraint defined at column level

Example:

SQL> create table order_detail (order_no varchar(5) constraint fk_ono

References order_master(order_no), item_code varchar(5), qty_ord number(5), qty_deld number(5));

Table created.

The above command creates order_detail table with foreign key on order_no column, which refer order_master table’s order_no column.

The referential integrity constraint does not use foreign key keyword to identify the columns that make up the foreign key. Because the constraint is defined at column level; the foreign key automatically enforced on the column

Foreign key constraint defined at table level

Example:

SQL>create table order_detail (order_no varchar(5), item_code varchar(5),

qty_ord number(5), qty_deld number(5), constraint fk_ono references

order_master (order_no));

Table created.

We will insert records in order_detail table and see what happens.

SQL>insert into order_detail values (‘O001’, ’I001’ ,10 , 10);

1 row created.

SQL>insert into order_detail values (‘O002’, ’I001’ , 10, 10);

ERROR at line 1:

ORA-02291: integrity constraint (SCOTT.FK_ONO) violated – parent key not found

If we try to insert value, which is not available in parent table the above mention error occur.

Foreign Key Constraint with alter command

The syntax for creating a foreign key in an ALTER TABLE statement is:

ALTER TABLE table_name
add CONSTRAINT constraint_name
FOREIGN KEY (column1, column2, … column_n)
REFERENCES parent_table (column1, column2, … column_n);

SQL> alter table order_detail add constraint fk_icode foreign key (order_no) references order_master(order_no);

Table altered.

Remember that when we add constraint at table level foreign key keyword is must. Suppose we try to delete record from order_master and corresponding values are available in order_detail (detail table) it will give an error.

SQL> delete from order_master where order_no = ‘O001’;

ERROR at line 1:

ORA-02292: integrity constraint (SCOTT.FK_ONO) violated – child record found

On Delete Cascade clause

The on delete cascade option is used with foreign key. When the on delete cascade option is specified in the foreign key definition, if the user deletes a record in the master table, all the corresponding records   in the detail table along with the master table record will be deleted.

Example:

SQL> alter table order_detail add constraint fk_icode foreign key (item_code) references item_master(item_code) on delete cascade;

Table altered.

To drop constraint drop option is used with alter table command.

Syntax:

SQL> Alter Table <Table Name> Drop Constraint <Constraint Name>;

Example:

SQL> alter table order_detail drop constraint fk_icode;

Table altered.

Set Null on Delete

Foreign Keys with “set null on delete”

A foreign key with a “set null on delete” means that if a record in the parent table is deleted, then the corresponding records in the child table will have the foreign key fields set to null. The records in the child table will not be deleted.

A foreign key with a “set null on delete” can be defined in either a CREATE TABLE statement or an ALTER TABLE statement.

Using a CREATE TABLE statement

The syntax for creating a foreign key using a CREATE TABLE statement is:

CREATE TABLE table_name
(column1 datatype null/not null,
column2 datatype null/not null,

CONSTRAINT fk_column
FOREIGN KEY (column1, column2, … column_n)
REFERENCES parent_table (column1, column2, … column_n)
ON DELETE SET NULL
);

For example:

CREATE TABLE supplier

( supplier_id      numeric(10)           not null,

supplier_name                     varchar2(50)            not null,

contact_name                      varchar2(50),

CONSTRAINT supplier_pk PRIMARY KEY (supplier_id)

);

CREATE TABLE products

( product_id     numeric(10)            not null,

supplier_id     numeric(10),

CONSTRAINT fk_supplier

FOREIGN KEY (supplier_id)

REFERENCES supplier(supplier_id)

ON DELETE SET NULL

);

In this example, we’ve created a primary key on the supplier table called supplier_pk. It consists of only one field – the supplier_id field. Then we’ve created a foreign key called fk_supplier on the products table that references the supplier table based on the supplier_id field.

Because of the set null on delete, when a record in the supplier table is deleted, all corresponding records in the products table will have the supplier_id values set to null.

Using an ALTER TABLE statement

The syntax for creating a foreign key in an ALTER TABLE statement is:

ALTER TABLE table_name
add CONSTRAINT constraint_name
FOREIGN KEY (column1, column2, … column_n)
REFERENCES parent_table (column1, column2, … column_n)
ON DELETE SET NULL;

For example:

ALTER TABLE products
add CONSTRAINT fk_supplier
FOREIGN KEY (supplier_id)
REFERENCES supplier(supplier_id)
ON DELETE SET NULL;

In this example, we’ve created a foreign key “with a set null on delete” called fk_supplier that references the supplier table based on the supplier_id field.

Drop a foreign key

The syntax for dropping a foreign key is:

ALTER TABLE table_name drop CONSTRAINT constraint_name;

For example:

If you had created a foreign key as follows:

CREATE TABLE supplier

( supplier_id       numeric(10)  not null,

supplier_name                         varchar2(50)         not null,

contact_name varchar2(50),

CONSTRAINT supplier_pk PRIMARY KEY (supplier_id)

);

CREATE TABLE products

( product_id     numeric(10)            not null,

supplier_id     numeric(10)            not null,

CONSTRAINT fk_supplier

FOREIGN KEY (supplier_id)

REFERENCES supplier(supplier_id)

);

In this example, we’ve created a primary key on the supplier table called supplier_pk. It consists of only one field – the supplier_id field. Then we’ve created a foreign key called fk_supplier on the products table that references the supplier table based on the supplier_id field.

If we then wanted to drop the foreign key called fk_supplier, we could execute the following command:

ALTER TABLE products
drop CONSTRAINT fk_supplier;

Disable a foreign key

The syntax for disabling a foreign key is:

ALTER TABLE table_name
disable CONSTRAINT constraint_name;

For example:

If you had created a foreign key as follows:

CREATE TABLE supplier

( supplier_id       numeric(10)  not null,

supplier_name                         varchar2(50)         not null,

contact_name varchar2(50),

CONSTRAINT supplier_pk PRIMARY KEY (supplier_id)

);

CREATE TABLE products

( product_id     numeric(10)            not null,

supplier_id     numeric(10)            not null,

CONSTRAINT fk_supplier

FOREIGN KEY (supplier_id)

REFERENCES supplier(supplier_id)

);

In this example, we’ve created a primary key on the supplier table called supplier_pk. It consists of only one field – the supplier_id field. Then we’ve created a foreign key called fk_supplier on the products table that references the supplier table based on the supplier_id field.

If we then wanted to disable the foreign key called fk_supplier, we could execute the following command:

ALTER TABLE products
disable CONSTRAINT fk_supplier;

Enable a foreign key

The syntax for enabling a foreign key is:

ALTER TABLE table_name
enable CONSTRAINT constraint_name;

For example:

If you had created a foreign key as follows:

CREATE TABLE supplier

( supplier_id       numeric(10)  not null,

supplier_name                         varchar2(50)         not null,

contact_name varchar2(50),

CONSTRAINT supplier_pk PRIMARY KEY (supplier_id)

);

CREATE TABLE products

( product_id     numeric(10)            not null,

supplier_id     numeric(10)            not null,

CONSTRAINT fk_supplier

FOREIGN KEY (supplier_id)

REFERENCES supplier(supplier_id)

);

In this example, we’ve created a primary key on the supplier table called supplier_pk. It consists of only one field – the supplier_id field. Then we’ve created a foreign key called fk_supplier on the products table that references the supplier table based on the supplier_id field.

If the foreign key had been disabled and we wanted to enable it, we could execute the following command:

ALTER TABLE products
enable CONSTRAINT fk_supplier;

Indexes

What is an Index?

An index is a performance-tuning method of allowing faster retrieval of records. An index creates an entry for each value that appears in the indexed columns. By default, Oracle creates B-tree indexes.

Create an Index

The syntax for creating a index is:

CREATE [UNIQUE] INDEX index_name
ON table_name (column1, column2, . column_n)
[ COMPUTE STATISTICS ];

UNIQUE indicates that the combination of values in the indexed columns must be unique.

COMPUTE STATISTICS tells Oracle to collect statistics during the creation of the index. The statistics are then used by the optimizer to choose a “plan of execution” when SQL statements are executed.

For example:

CREATE INDEX supplier_idx
ON supplier (supplier_name);

In this example, we’ve created an index on the supplier table called supplier_idx. It consists of only one field – the supplier_name field.

We could also create an index with more than one field as in the example below:

CREATE INDEX supplier_idx
ON supplier (supplier_name, city);

We could also choose to collect statistics upon creation of the index as follows:

CREATE INDEX supplier_idx
ON supplier (supplier_name, city)
COMPUTE STATISTICS;

Create a Function-Based Index

In Oracle, you are not restricted to creating indexes on only columns. You can create function-based indexes.

The syntax for creating a function-based index is:

CREATE [UNIQUE] INDEX index_name
ON table_name (function1, function2, . function_n)
[ COMPUTE STATISTICS ];

For example:

CREATE INDEX supplier_idx
ON supplier (UPPER(supplier_name));

In this example, we’ve created an index based on the uppercase evaluation of the supplier_name field.

However, to be sure that the Oracle optimizer uses this index when executing your SQL statements, be sure that UPPER(supplier_name) does not evaluate to a NULL value. To ensure this, add UPPER(supplier_name) IS NOT NULL to your WHERE clause as follows:

SELECT supplier_id, supplier_name, UPPER(supplier_name)
FROM supplier
WHERE UPPER(supplier_name) IS NOT NULL
ORDER BY UPPER(supplier_name);

Rename an Index

The syntax for renaming an index is:

ALTER INDEX index_name
RENAME TO new_index_name;

For example:

ALTER INDEX supplier_idx
RENAME TO supplier_index_name;

In this example, we’re renaming the index called supplier_idx to supplier_index_name.

Collect Statistics on an Index

If you forgot to collect statistics on the index when you first created it or you want to update the statistics, you can always use the ALTER INDEX command to collect statistics at a later date.

The syntax for collecting statistics on an index is:

ALTER INDEX index_name
REBUILD COMPUTE STATISTICS;

For example:

ALTER INDEX supplier_idx
REBUILD COMPUTE STATISTICS;

In this example, we’re collecting statistics for the index called supplier_idx.

Drop an Index

The syntax for dropping an index is:

DROP INDEX index_name;

For example:

DROP INDEX supplier_idx;

In this example, we’re dropping an index called supplier_idx.

Advertisements

2 Responses to “Oracle Constraints – Part X”

  1. I couldn’t currently have asked for a more rewarding blog. You’re ever present to provide excellent guidance, going straight to the point for quick understanding of your readers. You’re really a terrific professional in this subject matter. Thanks for currently being there for folks like me.

  2. I¡¯m delighted that I’ve noticed this weblog. Finally something not a junk, which we undergo extremely frequently. The website is lovingly serviced and saved as much as date. So it must be, thanks for sharing this with us.

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s

 
%d bloggers like this: