Monday’s feedback is Tuesday’s features

The entire stand will be turned into a mini development lab to create a prototype for an Oracle schema version control tool over the course of the 3 exhibition days. Red Gate will be involving 100′s of people in rapid feedback sessions during 9 sprints to develop a paper prototype and then using this feedback to build an HTML prototype. The prototype will constantly evolve based on the feedback from Kscope attendees: features will be added, deleted and improved, and the prototype may even be scrapped completely several times. The main thing is that Oracle developers and DBAs can define how they want this tool to work, and this will go straight into the final product. Find out more…

A unique two-way learning experience

Participants will get to experience rapid prototyping, agile development and learn how a company like Red Gate develops software. At the same time Red Gate will gain loads of feedback on the features, UI and requirements for an Oracle version control tool. So if you’re making your way to Kscope12, please join in on stand 424 – 425 for a unique two-way learning experience. ODTUG Kscope12 runs from 24 – 28 June in San Antonio, Texas.

Not going to Kscope12? Join in here

Daily update

Kscope12 runs from 24 – 28 June in San Antonio, Texas. As the prototype progresses we’ll be keeping a blog post up-to-date on All Things Oracle.com and including photos. Please keep checking back to see how Kscope attendees and the Red Gate team are getting on and use the comments function to add your feedback.

Current version of the HTML prototype

A link to the most recent version of the HTML prototype will be put up after the first round of feedback and development sessions on Monday 25 June.

Fill out our quick survey

If you have some time now, please fill in Red Gate’s short survey: Oracle Database Source Control Survey

Be part of the Early Access program

Please email oracletools.info@red-gate.com with ‘Source Control for Oracle EAP’ as your subject line and Red Gate will be in touch.

How will the tool work?

The tool – currently named Source Control for Oracle – will connect to your existing version control system to automatically store a complete history of your Oracle database schema changes. With your database under source control (just like your application code) your development team can share, track and understand schema changes quickly and easily. Find out more…

And the bad news?  There’s nothing it can do about your teenage haircut.

Oracle Flashback Technology is a suite of features that enables Oracle application developers and database administrators to wind the clock back and examine their database objects and data in a previous state without having to resort to backup media.

In this series of articles I intend to outline the benefits of Oracle Flashback to application developers and to database administrators. This first installment will concentrate on the tools that will be of interest to application developers.

Oracle Flashback Technology is actually a collection of features that enables the developer to examine the database’s recent past in a number of ways:

Oracle Flashback Query:

Flashback query is a neat trick. It allows you run a query against your data as it was at past time. Imagine you accidentally delete a number of rows and commit your changes. With flashback query you can easily reach into the past and retrieve those lost rows.  Using the SELECT… AS OF syntax you can examine the ghost of data past by referencing its timestamp.

SELECT *
FROM emp AS OF TIMESTAMP TO_TIMESTAMP('2012-04-21 17:00:00','YYYY-MM-DD HH24:MI:SS');

And if you wanted to view those rows that you accidentally deleted 5 minutes ago?

SELECT *
FROM emp AS OF TIMESTAMP (SYSTIMESTAMP - INTERVAL '6' MINUTE)
MINUS
SELECT *
FROM emp;

Oracle Flashback Version Query:

While flashback query seems pretty much like magic, it actually comes with a cherry on it. Flashback Version Query has the power to not only resurrect bygone data, it can also give you important metadata about those rows. You can find out the exact chronology of the changes that have occurred to those rows – the whens and the whats. You do this using the SELECT … VERSIONS BETWEEN syntax referencing a start and end timestamp (you can also reference the System Change Number – SCN – if you prefer). Using this syntax you can query a number of pseudocolumns:

Imagine that those rows from the previous example were not simply deleted, but were updated and changed numerously, and you are interested in finding out the details of each edition that occurred to a particular row. You might write a query such as the following:

SELECT versions_starttime, versions_endtime, versions_operation, versions_xid, ename, sal
FROM  emp BETWEEN TIMESTAMP (systimestamp - interval '6' minute) AND systimestamp;

Edit a row or two in one of your database tables and give the above query a spin. It will immediately strike you how important the flashback version query pseudocolumns could be. Pay attention to versions_xid, we will need it to add a further layer of functionality to our flashback cake.

Oracle Flashback Transaction Query:

The versions_xid value that we got from the previous query is the internal id that Oracle assigns each transaction. It’s a hexadecimal value, seemingly unremarkable in itself; but using it we can rummage around in the FLASHBACK_TRANSACTION_QUERY data dictionary view and obtain further information about our query. Amongst the columns in this view are the following:

XID
START_TIMESTAMP
COMMIT_TIMESTAMP
LOGON_USER
OPERATION
UNDO_SQL

There are a few other columns in the view; one identifying the table and a few identifying the SCN. Describe the view yourself to get the full picture. However, do pay LOGON_USER and UNDO_SQL especial attention. Going back to our previous example, we can use this view to not only discover who deleted the missing rows, but also to allow Oracle generate for us the code it would take to undo the change.

SELECT logon_user, operation, start_timestamp, undo_sql
FROM flashback_transaction_query
WHERE xid in (
SELECT  versions_xid
FROM  emp BETWEEN TIMESTAMP (systimestamp - interval '6' minute) AND systimestamp);

DBMS_FLASHBACK

You know how, when you go to a really fancy store, they package your shopping up for you in a really nice bag? Well, that’s what Oracle have done with the DBMS_FLASHBACK package. The flashback technology is nothing short of amazing, but with DBMS_FLASHBACK they have wrapped it up and put a bow on it.

Using the tag team of DBMS_FLASHBACK.ENABLE_AT_TIME and DBMS_FLASHBACK.DISABLE, you can dial back your session to a past time and carry out select queries without having to bother with the SELECT…AS OF or SELECT … VERSIONS BETWEEN syntaxes. Using this package, the above example can be rewritten as follows:

EXECUTE DBMS_FLASHBACK.ENABLE_AT_TIME(systimestamp- interval '6' minute);

SELECT * FROM emp;

EXECUTE DBMS_FLASHBACK.DISABLE;

There are a few things you need to bear in mind, however. Only run select statements, no other DML and definitely no DDL statements. Also, you must follow each call to DBMS_FLASHBACK.ENABLE_AT_TIME with a call to DBMS_FLASHBACK.DISABLE before calling DBMS_FLASHBACK.ENABLE_AT_TIME again.

The DBMS_FLASHBACK package can also smooth out the hassle of restoring lost data for you. Using the TRANSACTION_BACKOUT procedure, Oracle will not only rollback any specified transactions, but also any dependent transactions that may have taken place as a result of them.

DBMS_FLASHBACK.BACKOUT_TRANSACTION

The default value of the options parameter is NOCASCADE. If your transaction has dependencies, you will want to use CASCADE instead. Also bear in mind that you will need to commit the changes the procedure has made. However, you will probably want to examine the reports that the procedure has created in USER_FLASHBACK_TXT_STATE and USER_FLASHBACK_TXT_REPORT (or DBA_FLASHBACK_TXN_STATE and DBA_FLASHBACK_TXN_REPORT, if you have the access to them) before saving the changes.

Conclusion:

No man, Oscar Wilde once said, is rich enough to buy back his past. Perhaps so, but with Oracle Flashback Technology we can make the mistakes of the past a little less expensive. Using the functionality I have outlined above, developers can either deal with spilt milk on a transaction by transaction basis as needed, or perhaps build a simple overlying application that can reverse time at the press of a button.

“The past is not dead,” William Faulkner once said. “In fact, it’s not even past.”

Perhaps he was an Oracle developer too.

In the next instalment in this series I will discuss the tools in the Oracle Flashback Technology locker that database administrators will find invaluable.

Oracle Restart is a component added to the 11gR2 in order to improve the high availability of different database resources. Database instances, listeners are resources that can be automatically restarted after a hardware or software failure or whenever the server host restarts. These components can be easily added to the Oracle Restart using the crsctl add command. In this article, I am going to show you how to add the Enterprise Manager Agent 12c component to the Oracle Restart.

The following procedure has been tested on 11.2.0.3 RAC environment under Redhat Enterprise Linux. Apply the following steps on each node of the cluster:

The procedure:

• The Agent cloud control 12c is installed under the /opt/agent12c directory.
• The agent can be started / Stopped by running $AGENT_HOME/bin/emctl start agent , $AGENT_HOME/bin/emctl stop agent commands, where $AGENT_HOME is /opt/agent12c/agent_inst in my case.

Read the full article here: Auto Restart Enterprise Manager Cloud Control Agent 12c;

Oracle and SQL Server may both share a common language, but certain things are handled quite differently. Jonathan Lewis (OakTable Network, Oracle Ace Director) is used to seeing heap tables (almost) everywhere, but Grant Fritchey (Microsoft SQL Server MVP) is used to seeing clustered indexes (almost) everywhere. But which arrangement performs better? And is comparative performance even the right thing to measure?

In this live discussion, these two heavyweights in their respective technology areas will debate the pros and cons of Oracle Heap Tables and SQL Clustered Indexes. Jonathan and Grant may even play a few unexpected cards during the discussion. Be prepared for a lively exchange which will not only entertain, but will teach you key concepts on Oracle and SQL Server.

Please note: this webinar is offered free of charge, and places are strictly limited and offered on a first come, first serve basis.

Register your place now

There are three switches marked A, B and C on the wall outside the door, and one of these also works the lights but only when the door is locked shut. You are allowed to touch any or all switches as often as you like before you open the door and enter the room, but once inside, you must say “A”, “B”, or “C”.

You get one chance before the server room door locks and the alarm goes off. How do you know whether A, B or C is the right command? Please post your answers below.

Note: You obviously know the code to get into the room!

The video above is accompanied by the following downloadable resources:

• Presentation slides (.pdf)
• Resource Consumption Metrics Examples (.txt)
• Workload Repository SQL Report (awrsqlrpt_1_16411_16412.html)
• SQL Monitoring Report (0-6x2sh0kvzac0t-2.html)
• ASH Report for BIUAT/biuat1 (ashrpt_1_0505_1117.html)
• Download all resources (.zip)

SQL is utilized to return data via our applications to service user requests. Whether it’s a single customer lookup or a huge month end summary report, the SQL we write must gather the correct data and return it to the user.

Ensuring that the SQL you write can do this in a timely and efficient manner, both now and in the future, requires that you measure and evaluate what resources your query must use.

In this webinar, we’ll cover several methods for how to collect data that show you precisely how your SQL consumes resources:

• Using AUTOTRACE
• Using DBMS_XPLAN.DISPLAY_CURSOR
• Using Report SQL Monitor
• Using ASH (Active Session History) and AWR (Automatic Workload Repository) data

You’ll learn how to utilize the data to understand the work your SQL is doing and the resources it consumes; identify currently evident performance issues as well as areas that could be problematic in the future; and modify your SQL to use less resources more efficiently while still returning the desired results.

A live Q+A session with Karen Morton will follow the presentation.

Download your FREE eBook

Expert Oracle Database Architecture (Apress Media) provides a one-stop resource containing deep wisdom on the design, development and administration of Oracle applications, written by one of the world’s foremost Oracle experts, Thomas Kyte. This fully revised second edition covers the developments up to Oracle Database 11g. Each feature is taught in a proof-by-example manner, not only discussing what it is, but also how it works, how to implement software using it, and the common pitfalls associated with it.

Red Gate Software is pleased to offer you the chance to download the e-version of this book free of charge for a limited period.

• Fully revised to cover Oracle Database 11g
• Proof-by-example approach: Let the evidence be your guide
• Dives deeply into Oracle Databases’s most powerful features
• FREE eBook version (usual selling price = $41.99)
• Zip file includes .pdf, .mobi and .epub versions

What you’ll learn

• Develop an evidence-based approach to problem solving
• Manage transactions in highly concurrent environments
• Speed access to data through table and index design
• Manage files and memory structures for performance and reliability
• Scale up through partitioning and parallel processing
• Load and unload data to interface with external systems
• Think for yourself; don’t take Tom’s word for it!

Who this book is for

This book is aimed at Oracle Database administrators, at PL/SQL and Java developers writing code to be deployed inside the database, and at developers of external applications who use Oracle Database as a data store. It is the go-to book for those wishing to create efficient and scalable applications.

Download your FREE eBook

This video is a recording from the webinar broadcast by Red Gate on 24th January 2012.

You may’ve heard the idea that real developers don’t need tools, and the mark of a good developer is someone who can hand-code everything. But there are certain tasks where it doesn’t make sense to disregard using tools. In particular, critical tasks that need to be completed before an application or database update goes live.

Development models are also changing. Agile methodology is gaining traction as companies look to shorten the development cycle. Therefore, reducing the time spent on critical tasks such as smoothing out application inefficiencies or identifying differences between instances of your database is becoming even more crucial.

The Method R Workbench and the Deployment Suite for Oracle are featured during the presentation to demonstrate that using tools is a necessity, rather than an option, for efficient database and application development.

A Q+A session with Cary Millsap follows the presentation.

The traditional way to manage these resources was manually. The DBA was supposed to decide on which instance (or instances) these resources would run and would set them up accordingly. An example of this can be taken when you are configuring a service which has to be present on some nodes as Preferred and on another node(s) as Available. Although this kind of management works well, it’s not something that can scale for a cluster which has got a large number of nodes in it. Think about sitting and managing the instances over a 200 nodes cluster, it wouldn’t be very exciting would it?

Enter Server Pools

Grid computing is a concept within Oracle database which has been there since 10g. The basic meaning of grid computing is to divide the hard coupling of the availability of a resource over the machines thus letting the resources be available on a ‘wherever and whenever’ kind of basis. This means that there shouldn’t be a restriction on a said resource which must be present on a specific machine itself or can only be accessed from a specific machine. The very same concept is enhanced in 11.2 RAC with the introduction of Server Pools.

Server Pools allow the same functionality of logically dividing the cluster into small segments that can be used for varying workloads. But unlike the traditional mechanism available up to 11.1, which only allows this task by choosing the instances to run on nodes as Preferred & Available and running services using the same architecture, server pools offer a much larger list of attributes which help in the management of resources in a rather simple and transparent way. In server pools, the underlying hosts of the cluster are added (and removed) from the pools much more on-the-fly, and take the burden off the DBA’s shoulders for this task. With just a few parameters to take care of, the whole stack becomes much easier to govern and administer, while still being completely transparent yet powerful to manage all the types of different resources in the RAC clusterware environment, especially  when the number of the nodes go beyond two digits.

The built-in pools, Free and Generic

In 11.2, with the installation of the cluster, two pools get created by default-Free & Generic.

Generic Pool

When you upgrade your existing version of the clusterware to 11.2, all the nodes get mapped to the in-built Generic pool. This is an internally managed server pool and the modification of the attributes of this pool is not allowed. Besides the addition of the nodes of the previous cluster, in 11.2, when you create a database which is Admin-managed, that also becomes a part of the Generic Pool as a child pool of it.

Free Pool

This is another pool which gets created by default with the installation of the 11.2 clusterware. If it’s going to be a fresh installation of the clusterware environment, all the nodes would be attached to this pool first of all. From this pool only, the nodes would move to the manually created server pools. As like the Generic pool, this is also an internally managed pool but still some attributes are available to be modified by the dba like IMPORTANCE.

The following output is from a 3-node 11.2.0.1 cluster after a fresh installation with no database created over it:

[grid@host01 bin]$ srvctl config serverpool
 Server pool name: Free
 Importance: 0, Min: 0, Max: -1
 Candidate server names:
 Server pool name: Generic
 Importance: 0, Min: 0, Max: -1
 Candidate server names: host01,host02,host03
 [grid@host01 bin]$

Attributes of Server Pools

There are several attributes which can be set for the server pools. The following table (picked from Oracle documentation’s Clusterware Administration guide)  lists all the attributes, their meaning and possible values for them.

You can see these attributes and the available nodes and their properties by using the command CRSCTL like below:

[grid@host01 ~]$ crsctl status server
NAME=host01
STATE=ONLINE

NAME=host02
STATE=ONLINE

NAME=host03
STATE=ONLINE

And the below output is showing the complete set of attributes shown for these server pools:

[grid@host01 ~]$ crsctl status serverpool -p
NAME=Free
IMPORTANCE=0
MIN_SIZE=0
MAX_SIZE=-1
SERVER_NAMES=
PARENT_POOLS=
EXCLUSIVE_POOLS=
ACL=owner:grid:rwx,pgrp:oinstall:rwx,other::r-x

NAME=Generic
IMPORTANCE=0
MIN_SIZE=0
MAX_SIZE=-1
SERVER_NAMES=host01 host02 host03
PARENT_POOLS=
EXCLUSIVE_POOLS=
ACL=owner:grid:r-x,pgrp:oinstall:r-x,other::r-x

NAME=ora.orcladm
IMPORTANCE=1
MIN_SIZE=0
MAX_SIZE=-1
SERVER_NAMES=host01 host02 host03
PARENT_POOLS=Generic
EXCLUSIVE_POOLS=
ACL=owner:oracle:rwx,pgrp:oinstall:rwx,other::r--

NAME=sp1
IMPORTANCE=2
MIN_SIZE=1
MAX_SIZE=2
SERVER_NAMES=
PARENT_POOLS=
EXCLUSIVE_POOLS=
ACL=owner:grid:rwx,pgrp:oinstall:rwx,other::r—

You can check the status of the server pools collectively but the default server pools, Generic and Free won’t be able to get completely described and only a limited view of both would be there. The Free can be still queried but the Generic server pool would remain completely inaccessible as is confirmed from the output below:

[grid@host01 bin]$ srvctl config serverpool -g Free
Server pool name: Free
Importance: 0, Min: 0, Max: -1
Candidate server names:

[grid@host01 bin]$ srvctl config serverpool -g Generic
PRKO-3160 : Server pool Generic is internally managed as part of administrator-
managed database configuration and therefore cannot be queried directly via srvpool object.

You can add your own server pools with the same command CRSCTL. The below command adds two server pools SP1, SP2 and then they are shown:

[grid@host01 ~]$ crsctl add serverpool sp1 -attr "MIN_SIZE=1, MAX_SIZE=1, IMPORTANCE=1"
[grid@host01 ~]$ crsctl add serverpool sp2 -attr "MIN_SIZE=1, MAX_SIZE=1, IMPORTANCE=2"
[grid@host01 ~]$ crsctl status server -f
NAME=host01
STATE=ONLINE
ACTIVE_POOLS=Free
STATE_DETAILS=

NAME=host02
STATE=ONLINE
ACTIVE_POOLS=sp2
STATE_DETAILS=

NAME=host03
STATE=ONLINE
ACTIVE_POOLS=sp1
STATE_DETAILS=

As expected, there is one host added to each of the pools and one node, which is unallocated, is still with the server pool FREE as an available host which can be allocated to either the existing pools or to a new one when it would be added.

Child Pools

Server pools can have the child pools under them as well. The child pools are going to have their own properties. The order in which the host allocated to them is going to be based on the IMPORTANCE parameter assigned to them. To understand the child pools, we can imagine a parent pool named as OLTP which represents the working of OLTP database. This parent pool now can have two further child pools, HR (human resource) and AP (account payable) . Now, we can have different attributes set up for the child pools depending on the importance that we want to give to each domain of the work. The hosts assigned are mutually exclusive within the parent pools. For the child pools, whether the same is possible for the child pools or not, would be based on the fact that what’s the value of the attribute EXCLUSIVE_POOL for them. If there is a string value assigned to this parameter and this is shared by two child pools, host assigned to one child pool can’t be shared by its other sibling.

The following is an excerpt of the output for two parent pools where child pools are added to them:

[grid@host01 ~]$ crsctl delete serverpool sp1[grid@host01 ~]$ crsctl delete serverpool sp2
[grid@host01 ~]$ crsctl add serverpool sp1 -attr "MIN_SIZE=1, MAX_SIZE=1, IMPORTANCE=1"
[grid@host01 ~]$ crsctl add serverpool sp2 -attr "MIN_SIZE=1, MAX_SIZE=1, IMPORTANCE=2"
[grid@host01 ~]$ crsctl status server -f
NAME=host01
STATE=ONLINE
ACTIVE_POOLS=Free
STATE_DETAILS=

NAME=host02
STATE=ONLINE
ACTIVE_POOLS=sp2
STATE_DETAILS=

NAME=host03
STATE=ONLINE
ACTIVE_POOLS=sp1
STATE_DETAILS=

[grid@host01 ~]$ asmca
[grid@host01 ~]$

[grid@host01 ~]$ crsctl add serverpool sp1 -attr "MIN_SIZE=1, MAX_SIZE=1, IMPORTANCE=2"

[grid@host01 ~]$ crsctl add serverpool sp_child1 -attr "PARENT_POOLS=sp1, MIN_SIZE=1, MAX_SIZE=1, IMPORTANCE=2"
[grid@host01 ~]$ crsctl status server -f
NAME=host01
STATE=ONLINE
ACTIVE_POOLS=Free
STATE_DETAILS=

NAME=host02
STATE=ONLINE
ACTIVE_POOLS=Free
STATE_DETAILS=

NAME=host03
STATE=ONLINE
ACTIVE_POOLS=sp1 sp_child1
STATE_DETAILS=

[grid@host01 ~]$ crsctl add serverpool sp_child2 -attr "PARENT_POOLS=sp1, MIN_SIZE=1, MAX_SIZE=1, IMPORTANCE=3"
[grid@host01 ~]$ crsctl status server -f
NAME=host01
STATE=ONLINE
ACTIVE_POOLS=Free
STATE_DETAILS=

NAME=host02
STATE=ONLINE
ACTIVE_POOLS=Free
STATE_DETAILS=

NAME=host03
STATE=ONLINE
ACTIVE_POOLS=sp1 sp_child1 sp_child2
STATE_DETAILS=

[grid@host01 ~]$
[grid@host01 ~]$ crsctl add serverpool sp2 -attr "MIN_SIZE=1, MAX_SIZE=1, IMPORTANCE=1"
[grid@host01 ~]$ crsctl status server -f
NAME=host01
STATE=ONLINE
ACTIVE_POOLS=Free
STATE_DETAILS=

NAME=host02
STATE=ONLINE
ACTIVE_POOLS=sp2
STATE_DETAILS=

NAME=host03
STATE=ONLINE
ACTIVE_POOLS=sp1 sp_child1 sp_child2
STATE_DETAILS=

[grid@host01 ~]$

[grid@host01 ~]$ crsctl add serverpool sp2_child1 -attr "PARENT_POOLS=sp2,MIN_SIZE=1, MAX_SIZE=1, IMPORTANCE=1"
[grid@host01 ~]$ crsctl status server -f
NAME=host01
STATE=ONLINE
ACTIVE_POOLS=Free
STATE_DETAILS=

NAME=host02
STATE=ONLINE
ACTIVE_POOLS=sp2 sp2_child1
STATE_DETAILS=

NAME=host03
STATE=ONLINE
ACTIVE_POOLS=sp1 sp_child1 sp_child2
STATE_DETAILS=

How the hosts are added to the server pools

The allocation of the hosts is going to be happening in the following order:

1. Generic Pool
2. Explicitly created pool
3. Free Pool

Oracle would keep on adding the hosts to the server pools as long as they have not been equal to the values of the MIN_SIZE and MAX_SIZE on the basis of the IMPORTANCE that’s assigned to the server pools. The hosts are going to be added exclusively to the pools i.e. the hosts added to one server pool won’t be shared with the other pools. The hosts can be shared by the child pools provided that there is no value set for the parameter EXCLUSIVE_POOLS which would restrict the host sharing within the child pools as well.

In the following example a few parent and child pools are created and the hosts are attached to them. We start by creating a parent pool SP1 and then for it, a child pool SP_CHILD1:

[grid@host01 Disk1]$ crsctl add serverpool sp1 -attr "MIN_SIZE=1, MAX_SIZE=1, IMPORTANCE=2"
[grid@host01 Disk1]$ crsctl status server
NAME=host01
STATE=ONLINE

NAME=host02
STATE=ONLINE

NAME=host03
STATE=ONLINE

[grid@host01 Disk1]$ crsctl status serverpool
NAME=Free
ACTIVE_SERVERS=host01 host03

NAME=Generic
ACTIVE_SERVERS=

NAME=sp1
ACTIVE_SERVERS=host02

[grid@host01 Disk1]$ crsctl add serverpool sp_child1 -attr "PARENT_POOLS=sp1, MIN_SIZE=1, MAX_SIZE=1, IMPORTANCE=2"
[grid@host01 Disk1]$ crsctl status serverpool
NAME=Free
ACTIVE_SERVERS=host01 host03

NAME=Generic
ACTIVE_SERVERS=

NAME=sp1
ACTIVE_SERVERS=host02

NAME=sp_child1
ACTIVE_SERVERS=host02

So we can see that one host-Host02 is attached to the child pool SP_CHILD1. Now we create another child pool SP_CHILD2:

[grid@host01 Disk1]$ crsctl add serverpool sp_child2 -attr "PARENT_POOLS=sp1, MIN_SIZE=1, MAX_SIZE=1, IMPORTANCE=3"
[grid@host01 Disk1]$ crsctl status serverpool
NAME=Free
ACTIVE_SERVERS=host01 host03

NAME=Generic
ACTIVE_SERVERS=

NAME=sp1
ACTIVE_SERVERS=host02

NAME=sp_child1
ACTIVE_SERVERS=host02

NAME=sp_child2
ACTIVE_SERVERS=host02

Since we haven’t set the parameter EXCLUSIVE_POOLS, the same host host02 is shared by both the children.

Now, let’s add another parent pool SP2:

[grid@host01 Disk1]$ crsctl add serverpool sp2 -attr "MIN_SIZE=1, MAX_SIZE=1, IMPORTANCE=3"
[grid@host01 Disk1]$ crsctl status serverpool
NAME=Free
ACTIVE_SERVERS=host01

NAME=Generic
ACTIVE_SERVERS=

NAME=sp1
ACTIVE_SERVERS=host02

NAME=sp2
ACTIVE_SERVERS=host03

NAME=sp_child1
ACTIVE_SERVERS=host02

NAME=sp_child2
ACTIVE_SERVERS=host02

So there is one server that is in the Free pool now-Host01 and there are two hosts , Host02 and Host03 which are shared by two pools SP2 and SP1 and two children SP_CHILD1 and SP_CHILD2.

In the below lines, we are again creating a few parent, and child pools underlying them.

[grid@host01 ~]$ crsctl status serverpool
NAME=Free
ACTIVE_SERVERS=host01 host03

NAME=Generic
ACTIVE_SERVERS=

NAME=sp1
ACTIVE_SERVERS=host02

[grid@host01 ~]$ crsctl add serverpool sp_child1 -attr "PARENT_POOLS=sp1, MIN_SIZE=1, MAX_SIZE=1, IMPORTANCE=2"
[grid@host01 ~]$ crsctl status serverpool
NAME=Free
ACTIVE_SERVERS=host01 host03

NAME=Generic
ACTIVE_SERVERS=

NAME=sp1
ACTIVE_SERVERS=host02

NAME=sp_child1
ACTIVE_SERVERS=host02

[grid@host01 ~]$ crsctl add serverpool sp_child2 -attr "PARENT_POOLS=sp1, MIN_SIZE=1, MAX_SIZE=1, IMPORTANCE=1"
[grid@host01 ~]$ crsctl status serverpool
NAME=Free
ACTIVE_SERVERS=host01 host03

NAME=Generic
ACTIVE_SERVERS=

NAME=sp1
ACTIVE_SERVERS=host02

NAME=sp_child1
ACTIVE_SERVERS=host02

NAME=sp_child2
ACTIVE_SERVERS=host02

So we have one parent pool with two children and they are sharing the node Host02. Now we add into this another parent pool SP2 and also try to add a child pool under it, but with the same name that is assigned to another child pool of SP1 parent pool:

[grid@host01 ~]$

[grid@host01 ~]$ crsctl add serverpool sp2 -attr "MIN_SIZE=1, MAX_SIZE=1, IMPORTANCE=4"
[grid@host01 ~]$ crsctl status serverpool
NAME=Free
ACTIVE_SERVERS=host03

NAME=Generic
ACTIVE_SERVERS=

NAME=sp1
ACTIVE_SERVERS=host02

NAME=sp2
ACTIVE_SERVERS=host01

NAME=sp_child1
ACTIVE_SERVERS=host02

NAME=sp_child2
ACTIVE_SERVERS=host02

[grid@host01 ~]$ crsctl add serverpool sp_child1 -attr "PARENT_POOLS=sp2, MIN_SIZE=1, MAX_SIZE=1, IMPORTANCE=1"
CRS-2595: Server pool 'sp_child1' has already been registered
CRS-4000: Command Add failed, or completed with errors.

So clearly we can see that’s not possible to be done. But after using a distinct name, it is done:

[grid@host01 ~]$ crsctl add serverpool sp2_child1 -attr "PARENT_POOLS=sp2, MIN_SIZE=1, MAX_SIZE=1, IMPORTANCE=1"
[grid@host01 ~]$ crsctl status serverpool
NAME=Free
ACTIVE_SERVERS=host03

NAME=Generic
ACTIVE_SERVERS=

NAME=sp1
ACTIVE_SERVERS=host02

NAME=sp2
ACTIVE_SERVERS=host01

NAME=sp2_child1
ACTIVE_SERVERS=host01

NAME=sp_child1
ACTIVE_SERVERS=host02

NAME=sp_child2
ACTIVE_SERVERS=host02

Database management changes in 11.2 -to use server pools

To incorporate the usage of server pools, there is a change introduced in the database itself. From 11.2 onwards, there would be two types of databases available, Admin Managed and Policy Managed. Choosing either one would make you use the server pools though it would vary whether those server pools would be explicitly created by you or would be the default one available already.

Admin managed database

This is sort of the same as the traditional database type i.e. where a DBA is responsible to manage the allocation of the resources and instances explicitly on the available instances, and also the instances on the respective nodes. This database type would assign the instances to a child pool of the default pool available Generic pool. Having the Generic pool as the parent, no modification of the child pools of the Admin managed database’s instances would be allowed for the DBA to be done by their self. Depending on the number of nodes being chosen initially for the database, the instances would be started on each one of them. By default, with a fresh installation of 11.2 RAC, all the nodes would get added to the Generic pool and in the upgrade, all the nodes of the previous version would also be added to the Generic pool. Although this type seems to be much simpler and like the older versions and techniques of managing the instances, this can’t be used when the number of nodes pass a number which is difficult to manage by a DBA, for example 100. In that case, the next type of the 11.2 database would be helpful-Policy Managed database.

Policy Managed Database

This type of database administration is meant to make DBAs’ life simpler by not letting them worry about managing each of their instances on each node individually, but to use a server pool to manage the instances. By using server pools, the administrative tasks to manage the database becomes much simpler.

From 11.2 , DBCA (Database Configuration Assistant) offers both the options for creating a database.  To check that a database is admin-managed or policy-managed, we can use the command SRVCTL like below:

[grid@host01 Disk1]$ srvctl config database -d orcladm
Database unique name: orcladm
Database name: orcladm
Oracle home: /u01/app/oracle/product/11.2.0/dbhome_1
Oracle user: oracle
Spfile: +FRA/orcladm/spfileorcladm.ora
Domain:
Start options: open
Stop options: immediate
Database role: PRIMARY
Management policy: AUTOMATIC
Server pools: orcladm
Database instances: orcladm1,orcladm2
Disk Groups: FRA
Services:
Database is administrator managed

So we can see that the database ORCLADM is Admin Managed. To convert this database to Policy managed, you can proceed as follows:

[grid@host01 Disk1]$ srvctl stop database -d orcladm
[grid@host01 Disk1]$ srvctl modify database -d orcladm -g orclsp

Here ORCLSP is a server pool over which the database ORCLADM would be running and we can confirm it using the same command SRVCTL:

[grid@host01 Disk1]$ srvctl config database -d orcladm
Database unique name: orcladm
Database name: orcladm
Oracle home: /u01/app/oracle/product/11.2.0/dbhome_1
Oracle user: oracle
Spfile: +FRA/orcladm/spfileorcladm.ora
Domain:
Start options: open
Stop options: immediate
Database role: PRIMARY
Management policy: AUTOMATIC
Server pools: orclsp
Database instances:
Disk Groups: FRA
Services:
Database is policy managed

Now, the database management is Policy Managed.

Conclusion

It’s not (yet) very common to have cluster nodes with a very large number but that’s not something which is going to take a very long time to change either. And when this would happen, the management of the clusterware resources would essentially get a huge benefit from server pools. Hopefully, this short article should give you an idea about server pools and how to get started with them.

Reference: Clusterware Administration guide (11.2)

This video is a recording from the webinar broadcast by Red Gate on 29th March 2012.

Oracle Database administrators have to cope with numerous challenges when migrating an existing non-cluster environment to a cluster environment. One of the most significant challenges a DBA faces is to migrate/convert an existing single instance to RAC.

Oracle provides several easy methods to carry out the procedure, so it is important to know which method best fits your needs and requirements.

The core objective of this presentation is to give you an overview about different methods for migrating an existing single instance to RAC, and help you find the most suitable one for your situation. The session will also explain how to perform the migration in order to minimize the downtime and to improve (speed up) the migration duration whilst dealing with VLDB.

A live Q+A with Syed Jaffar Hussain follows the presentation.