A: Inheritance allows one class to reuse the state and behavior of another class. The derived class inherits the properties and method implementations of the base class and extends it by overriding methods and adding additional properties and methods.

Q: When should you use multiple inheritance?

A:There are three acceptable answers:- “Never,”"Rarely,” and “When the problem domain cannot be accurately modeled any other way.” Consider an Asset class, Building class, Vehicle class, and CompanyCar class. All company cars are vehicles. Some company cars are assets because the organizations own them. Others might be leased. Not all assets are vehicles. Money accounts are assets. Real estate holdings are assets. Some real estate holdings are buildings. Not
all buildings are assets. Ad infinitum. When you diagram these relationships, it becomes apparent that multiple inheritance is a likely and intuitive way to model this common problem domain. The applicant should understand, however, that multiple inheritance, like a chainsaw, is a useful tool that has its perils, needs respect, and is best avoided except when nothing else will do.

Q: Explain the IS A and HAS A class relationships. How would you implement each in a class design?

IS-A Relationship:-In object oriented programming,the concept of IS-A is a totally based on Inheritance.for eg: Car is a vehicle. Mango is a Fruit etc

HAS-A Relationship: In object-oriented programming has-a relationship is also known as composition.For eg A car is a composition of machine parts such as Engine,Carburetor etc.

Q: When is a template a better solution than a base class?

A: When you are designing a generic class to contain or otherwise manage objects of other types, when the format and behavior of those other types are unimportant to their containment or management, and particularly when those other types are unknown (thus, the generality) to the designer of the container or manager class.

Q: What is multiple inheritance(virtual inheritance)? What are its advantages and disadvantages?

A: Multiple Inheritance is the process whereby a child can be derived from more than one parent class. The advantage of multiple inheritance is that it allows a class to inherit the functionality of more than one base class thus allowing for modeling of complex relationships. The disadvantage of multiple inheritance is that it can lead to a lot of confusion(ambiguity) when two base classes implement a method with the same name.

Q: What a derived class inherits or doesn’t inherit?

A: Inherits:
Every data member defined in the parent class (although such members may not always be accessible in the derived class!)
Every ordinary member function of the parent class (although such members may not always be accessible in the derived class!)
The same initial data layout as the base class.

Doesn’t Inherit :
The base class’s constructors and destructor.
The base class’s assignment operator.
The base class’s friends

Courtesy

C++ Interview Questions
Compiled by Dr. Fatih Kocan, Wael Kdouh, and Kathryn Patterson
for the Data Structures in C++ course(CSE 3358) Spring 2008

A: By using the extern “C” linkage specification around the C function declarations.
Programmers should know about mangled function names and type-safe linkages. Then they should explain how the extern “C” linkage specification statement turns that feature off during compilation so that the linker properly links function calls to C functions.

Q: Is there anything you can do in C++ that you cannot do in C?

A: No. There is nothing you can do in C++ that you cannot do in C. After all you can write a C++ compiler in C.
Q: What are the differences between a struct in C and in C++?

A: In C++ a struct is similar to a class except for the default access specifier( refere to other question in the document). In C we have to include the struct keyword when declaring struct. In c++ we don’t have to.

Q: What does extern “C” int func(int *, Foo) accomplish?

A: It will turn o_ “name mangling” for func so that one can link to code compiled by a C compiler.

Q: What are the access privileges in C++? What is the default access level?

A: The access privileges in C++ are private, public and protected. The default access level assigned to members of a class is private. Private members of a class are accessible only within the class and by friends of the class. Protected members are accessible by the class itself and it’s sub-classes. Public members of a class can be accessed by anyone.

Q:How does C++ help with the tradeoff of safety vs. usability?

A: In C, encapsulation was accomplished by making things static in a compilation unit or module. This prevented another module from accessing the static stuff. (By the way, static data at file-scope is now deprecated in C++: don’t do that.)
Unfortunately this approach doesn’t support multiple instances of the data, since there is no direct support for making multiple instances of a module’s static data. If multiple instances were needed in C, programmers typically used a struct. But unfortunately C structs don’t support encapsulation. This exacerbates the tradeoff between safety (information hiding) and usability (multiple instances).In C++, you can have both multiple instances and encapsulation via a class. The public part of a class contains the class’s interface, which normally consists of the class’s public member functions and its friend functions. The private and/or protected parts of a class contain the class’s implementation, which is typically where the data lives. The end result is like an “encapsulated struct.” This reduces the tradeoff between safety (information hiding) and usability (multiple instances).

Courtesy

C++ Interview Questions
Compiled by Dr. Fatih Kocan, Wael Kdouh, and Kathryn Patterson
for the Data Structures in C++ course(CSE 3358)
Spring 2008

select
aa.username,
bb.SID,
VALUE/100 cpu_usage_seconds
from
v$session a,
v$sesstat b,
v$statname c
where
b.STATISTIC# = c.STATISTIC#
and
NAME like ‘%CPU used by this session%’
and
b.SID = a.SID
and
a.status=’ACTIVE’
and
a.username is not null
order by VALUE desc;

• The performance of queries against the tables may improve because Oracle may have to search only one partition (one part of the table) instead of the entire table to resolve a query.
• The table may be easier to manage. Because the partitioned table’s data is stored in multiple parts, it may be easier to load and delete data in the partitions than in the large table.
• Backup and recovery operations may perform better. Because the partitions are smaller than the partitioned table, you may have more options for backing up and recovering the partitions than you would have for a single large table.

In Oracle we can partition a table by the following methods

Range Partitioning

Tables are partitioned by ranges of values.useful when dealing with data that has logical ranges into which it can be distributed.

eg:

create table Library
(      Title VARCHAR2(100) primary key,
Publisher VARCHAR2(20),
CategoryName VARCHAR2(20),
Rating VARCHAR2(2),
references CATEGORY(CategoryName)
)
partition by range (CategoryName)

table will be partitioned based on the values in the CategoryName

Hash Partitioning

A hash partition determines the physical placement of data by performing a hash function on the values of the partition key.In hash partitioning, consecutive values of the partition key are not generally stored in the same
partition. Hash partitioning distributes a set of records over a greater set of partitions than range partitioning does, potentially decreasing the likelihood for I/O contention.

To create a hash partition, use the partition by hash clause in place of partition by range

eg:

create table Library
(      Title VARCHAR2(100) primary key,
Publisher VARCHAR2(20),
CategoryName VARCHAR2(20),
Rating VARCHAR2(2),
references CATEGORY(CategoryName)
)
partition by hash (CategoryName)
partitions 16;

Use hash partitioning if your data does not easily lend itself to range partitioning, but you would like to partition for performance and manageability reasons.

List Partitioning

In list partitioning, you tell Oracle all the possible values and designate the partitions into which the corresponding rows should be inserted.

create table Library
(      Title VARCHAR2(100) primary key,
Publisher VARCHAR2(20),
CategoryName VARCHAR2(20),
Rating VARCHAR2(2),
references CATEGORY(CategoryName)
)
partition by list (CategoryName)

Creating Subpartitions

You can create subpartitions—that is, partitions of partitions. You can use subpartitions to combine all types of partitions: range partitions, list partitions, and hash partitions. For example, you can use hash partitions in combination with range partitions, creating hash partitions of the range
partitions. For very large tables, this composite partitioning may be an effective way of separating the data into manageable and tunable divisions.

Indexing Partitions

When you create a partitioned table, you should create an index on the table. The index may be partitioned according to the same range values used to partition the table. In the following listing,

create index index_library
on library(CategoryName)
local
(partition PART1
tablespace PART1_NDX_TS,
partition PART2
tablespace PART2_NDX_TS);

A C or C++  program that uses sql statements compiled in 3 steps

1.Pro*C precompiler recognizes the SQL statements in the program.

2.Pro*C precompiler replace the SQL statements with appropriate function call in SQL runtime library.

3.The compiler compiles the code as normal C or C++ code and produce the Executable.

Use of C in SQL :Syntax

EXEC SQL sql_statement;

All sql statements in the program should start with EXEC SQL and should ends with a ;(semi colon).

There is a restriction that You should declare the variables before executable statements.

Declaring Host Variables

The C datatypes that can be used with Oracle include:

char
char[n]
int
short
long
float
double
VARCHAR[n]

A host variable reference must be prefixed with a colon “:” in SQL statements, but should not be prefixed with a colon in C statements.

Example

//use of Host variables in C program
int main()
{
int emp_no;
char *emp_name;

EXEC SQL INSERT INTO emp(empno, ename)
VALUES(:emp_no,:emp_name);
}

Declaring Pointers

int main()
{
int *emp_no;
char *emp_name;

//result will be written into *emp_no
EXEC SQL SELCT field_name INTO :emp_no WHERE —-

}

Declaring Arrays

int emp_number[50];
char name[50][11];
/* … */
EXEC SQL INSERT INTO emp(emp_number, name)
VALUES (:emp_number, :emp_name);

Embed C in SQL:SAMPLE PROGRAM

/* Begin program */

EXEC SQL INCLUDE SQLCA;

EXEC SQL BEGIN DECLARE SECTION
emp_name VARCHAR2(20)
emp_number integer
EXEC SQL END DECLARE SECTION

EXEC SQL WHENEVER SQLERROR STOP

EXEC SQL CONNECT frans

/* Formulate query */

EXEC SQL SELECT employee_name,employee_number
INTO emp_name,emp_number
FROM employees
WHERE emp_number = 185678

/* Print emp_name and emp_number */

EXEC SQL DISCONNECT

/* End program */

Program Explanation

List of Embedded SQL Statements in C

The following rules apply to embedded SQL statements in C:

* Do not split the EXEC SQL keyword pair between lines.

* You must use the SQL statement terminator. If you do not use it,This may cause indeterminate errors.

* C/C++ comments can be placed before the statement initializer or after the statement terminator.
* Multiple SQL statements and C/C++ statements may be placed on the same line.
* The SQL precompiler leaves carriage returns, line feeds, and TABs in a quoted string as is.
* SQL comments are allowed on any line that is part of an embedded SQL statement. These comments are not allowed in dynamically executed statements.

syntax for setting UTL_FILE_DIR is

alter system set UTL_FILE_DIR = '/tmp' scope=spfile;
Specifying multiple directories in the spfile

alter system set utl_file_dir='/tmp/dir1','/tmp/dir2','/tmp' scope=spfile

In the past(upto Oracle 8i), accessible directories for the UTL_FILE functions were specified in the initialization file using the UTL_FILE_DIR parameter. The disadvantage of the init param is that if it is used, it is valid for all USERS in the database. There is no way (other than totally disable utl_file for someone) to selectively restrict directories to someone.

From Oracle 9i, UTL_FILE_DIR access is not recommended. It is recommended that you use the CREATE DIRECTORY feature, which replaces UTL_FILE_DIR. Directory objects offer more flexibility and control to the UTL_FILE access.Moreover directories can be maintained dynamically (that is, without shutting down the database), and are consistent with other Oracle tools. CREATE DIRECTORY privilege is granted only to SYS and SYSTEM by default.

SELECT

horse_name, to_char(sum(decode(position,1,1,0))),
to_char(sum(decode(position,2,1,0))), to_char(sum(decode(position,3,1,0)))
FROM winners
GROUP BY horse_name

In the sum(decode(position,2,1,0)) construct, we are saying that if the horse’s finishing position is 2 (second), add one to the count of seconds. The results of this statement appear as follows:
Horse
Firsts
Seconds
Thirds
Wild Charm
1
2
2
The alternative statement without the decode involves scanning the table three times, rather than once, as in the previous statement.

SELECT horse_name
, count(w1.position)
, count(w2.position)
, count(w3.position)
FROM winners w1, winners w2, winners w3
WHERE w1.horse_name = w2.horse_name
AND w2.horse_name = w3.horse_name
AND w1.position = 1
AND w2.position = 2
AND w3.position = 3
GROUP BY horse_name;

YHAWUFX3V4PW

Setting up ALERT using DBMS_ALERT

Use the following Order to setting  up an alert

REGISTER-to record your interest in a particular alert.

WAITTONE-wait for a specific alert.

WAITANY-wait for any of  your registred alerts

SIGNAL-use this when the condition for the alert is met and the transaction has been committed.

Using SIGNAL to Issue an Alert

The Syntax for the SIGNAL Procedure

PROCEDURE SIGNAL(alert_name IN VARCHAR2,message_sent IN VARCHAR2);

alert_name can be a maximum of 30 characters, and it is not case sensitive. “message_sent” can be up to 1,800 characters, which allows for a generous concatenation of text, variable names, and so on. This message is sent to the waiting session.It is common for multiple sessions to concurrently issue signals on the same alert. In this case, as each session issues the alert, it blocks all other concurrent sessions until it commits.The net effect of this behavior is that alerts can cause transactions to become serialized.

Registering for an Alert

Before you can even search for an alert, you must register the alert you want to monitor,which adds you to the master registration list. You take this first step by using the REGISTER procedure.

Syntax for using REGISTER procedure

PROCEDURE REGISTER(alert_name IN VARCHAR2);

alert_name is the name of the alert to monitor.

Waiting for a Specific Alert

If you want to monitor one alert, use the WAITONE Procedure
The Syntax for the WAITONE Procedure

PROCEDURE WAITONE(alert_name IN VARCHAR2,alert_message OUT VARCHAR2,alert_status OUT INTEGER,timeout IN NUMBER DEFAULT maxwait);

Waiting for Any Registered Alert

WAITANY procedure allows you to constantly monitor for any alert for which you have registered in the current session.

The Syntax for the WAITANY Procedure

PROCEDURE WAITANY(alert_name OUT VARCHAR2, alert_message OUT VARCHAR2, alert_status OUT INTEGER,timeout IN NUMBER DEFAULT maxwait);

Removing One Alert

To remove only one specific alert from the registration list, use the REMOVE procedure.

The Syntax for the REMOVE Procedure

PROCEDURE REMOVE(alert_name IN VARCHAR2);

Removing All Alerts

You can remove all registered alerts from the current session by placing a call to the procedure REMOVEALL procedure is as follows:

PROCEDURE REMOVEALL;

After the procedure is executed, all registered alerts are deleted. An implicit COMMIT is executed with this call.

What is ASM?

Features of ASM

• Automatic software d NN ata striping (RAID-0)
• Load balancing across physical disks
• Software RAID-1 data redundancy with double or triple mirrors
• Elimination of fragmentation
• Simplification of file management via support for Oracle Managed Files (OMF)
• Ease of maintenance

Creating the ASM Instance

To create the ASM instance with the DBCA, do the following:

• Start the Oracle DBCA.
• The DBCA presents a list of options for you to choose from. Select Configure Automatic Storage Management and click Next.
• The DBCA then prompts you for the SYS password for the new ASM instance to be created. Enter the password for the SYS account.
• Oracle then creates the ASM instance. A new window appears giving you the option to create new disk groups. You can choose to create disk groups or you can click Finish to complete the ASM instillation.
• The name of the resulting instance will be +ASM. You can log into the ASM instance

from SQL*Plus, as shown in this example:

C:\Documents and Settings\technooracle>Set ORACLE_SID=+ASM

C:\Documents and Settings\technooracle>Sqlplus sys/Robert as sysasm

SQL*Plus: Release 11.1.0.6.0 – Production on Mon Jul 14 19:55:33 2008

Copyright (c) 1982, 2007, Oracle. All rights reserved.

Connected to:

Oracle Database 11g Enterprise Edition Release 11.1.0.6.0 – Production

With the Partitioning, OLAP and Data Mining options

SQL> select instance_name from v$instance;

INSTANCE_NAME

—————-

+asm

Starting and Stopping the ASM Instance

Starting an ASM Instance

Starting an ASM instance is quite easy, as shown in this exercise.

1. The name of the resulting instance will be +ASM. You can log into the ASM instance

2. Now, start the ASM instance with the startup command:

SQL> startup

ASM instance started

Total System Global Area 83886080 bytes

Fixed Size 1247420 bytes

Variable Size 57472836 bytes

ASM Cache 25165824 bytes

Shutting down the ASM instance is just as easy. A shutdown immediate, shutdown abort, or just a plain shutdown will do fine. If you execute a normal or immediate shutdown command on an ASM instance, that shutdown will fail if there is any database using that ASM instance. An error will be returned and the ASM instance will stay up. As a result, before you shut down the ASM instance, you will need to shut down all databases using that ASM instance.
You can perform a shutdown abort on the ASM instance. This will cause the ASM instance to shut down immediately and all of the associated databases will be shut down in an inconsistent state. This will require instance recovery when the databases are restarted, which can increase the time it takes to reopen the database. Oracle recommends that you not use the shutdown abort command when stopping an ASM instance.

The options for the STARTUP command are:

• FORCE – Performs a SHUTDOWN ABORT before restarting the ASM instance.
• MOUNT – Starts the ASM instance and mounts the disk groups specified by the ASM_DISKGROUPS parameter.
• NOMOUNT – Starts the ASM instance without mounting any disk groups.
• OPEN – This is not a valid option for an ASM instance.

The options for the SHUTDOWN command are:

• NORMAL – The ASM instance waits for all connected ASM instances and SQL sessions to exit then shuts down.
• IMMEDIATE – The ASM instance waits for any SQL transactions to complete then shuts down. It doesn’t wait for sessions to exit.
• TRANSACTIONAL – Same as IMMEDIATE.
• ABORT – The ASM instance shuts down instantly.

What is supported in ASM

Only Oracle files are supported:

* Database files
* Control files
* Online redo log files
* Archived redo log files
* Flash recovery area files
* RMAN files (image copy and backup)

These files are NOT supported:

* Installation files (in ORACLE_HOME, CRS_HOME)
* ORACLE_BASE files( including alert log, trace files, etc)
* CRS voting disk and OCR files
* Output data from UTL_FILE
* Any user or application specific files(e.g. XML or Java files)
* Oracle 9i external table files

Setting up SQL Trace

SQL Trace can be configured for instance-level use or for a session, for a session either within a current open session or from one session to another. Setting instance-wide tracing can cause serious performance problems. It is better for performance to enable tracing only from a current session or for a specific session. Not using instance-wide tracing can miss a lot of useful information. I am using instance-level tracing since I am not working on a production server database. Start by setting the TIMED_STATISTICS, TIMED_OS_STATISTICS, and MAX_DUMP_FILE_SIZE parameters.

TIMED_STATISTICS = TRUE
TIMED_OS_STATISTICS = 5
MAX_DUMP_FILE_SIZE = 1M

The effect on performance of setting the TIMED_STATISTICS parameter is negligible. The parameters previously shown enable collection of statistics including CPU and I/O statistics. TIMED_STATISTICS writes information to both trace files plus the V$SYSSTATS and V$SESSSTATS performance views. TIMED_OS_STATISTICS is a timing mechanism for statistics collection, triggering system statistics collection periodically.

The MAX_DUMP_FILE_SIZE parameter will truncate each trace file in the USER_DUMP_DEST directory, the default target directory for trace files, usually the $ORACLE_BASE/admin/$ORACLE_SID/ udump directory.

Next set the SQL_TRACE parameter to switch on SQL Trace. The TRACE_ENABLED parameter could also be set to TRUE but we will avoid that. Setting TRACE_ENABLED tends to produce copious amounts of detail, more relevant to Oracle support personnel than anything else.

SQL_TRACE = TRUE

Trace files contain generated statistics. In past versions of Oracle trace levels could be set. Oracle9i Database has a new parameter called STATISTICS_LEVEL which can be set to BASIC, TYPICAL, or ALL. The default is TYPICAL. Setting ALL would incur significant overhead and a noticeable effect on performance. In my database I will set the STATISTICS_LEVEL parameter to ALL to gather as much information as possible. Note that setting this parameter to ALL automatically sets the TIMED_OS_STATISTICS parameter to 5.

STATISTICS_LEVEL = ALL

Session-Level Tracing

Specific sessions can be traced. Tracing at the session level can help to remove tracing overhead from the database in general and focus on a specific session. Personally I have never seen the value in using the session level of tracing. There is far too much information produced. There are easier ways of tracking down problems than using session-level tracing. This command traces the current session. Tracing a specific session may be most applicable to tracking down some really nasty SQL code such as in a pre-release application, or one which should not have been released, or perhaps in an ad hoc SQL environment.

ALTER SESSION SET SQL_TRACE = TRUE;

This command will trace a session other than the current session, someone else’s session.

DBMS_SYSTEM_SET_SQL_TRACE_IN SESSION(SID, SERIAL#, TRUE);

$ORACLE_SID_ora_<pid>.trc

SELECT spid FROM v$process
WHERE addr = (SELECT paddr FROM v$session
      WHERE audsid = USERENV('sessionid'));

Using SQL Trace

So the next logical step is to make use of SQL Trace. I have now set up my Oracle Database configuration parameter file (init.ora) with various parameter changes.

TIMED_STATISTICS = TRUE
TIMED_OS_STATISTICS=5
MAX_DUMP_FILE_SIZE = 1M
SQL_TRACE = TRUE
STATISTICS_LEVEL = ALL
Now I bounce my database to instantiate these configuration parameter changes.

Tip Some of these parameters can be updated online using the ALTER SYSTEM command.

The next step is starting up my highly active concurrent database scripting (see Appendix B). These scripts use the DBMS_JOBS package to repetitively execute a slew of database changes to my Accounts schema, from multiple concurrently executed database jobs using the DBMS_JOBS package. Since I am running sessions using the DBMS_JOBS package I have to be able to find trace files for each session. So let’s change the process identifier query to access multiple sessions, and find a trace file that way. So how do I find the appropriate sessions? Log into a database administrator user such as SYSTEM and execute a query something like this.

SELECT audsid, username, saddr, paddr, sid, serial#
FROM v$session WHERE username = ‘ACCOUNTS’ AND audsid != 0;
Then I change my process identifier finding query and find a filename.

SELECT ‘c:\oracle\admin\test\udump\test_ora_’||spid||’.trc’
“Trace File”
FROM v$process
WHERE addr = (
SELECT paddr FROM V$SESSION
WHERE username = ‘ACCOUNTS’ AND audsid != 0);
Trace File
—————————————————
c:\oracle\admin\test\udump\test_ora_972.trc

Trace files can look like the gibberish shown below. Not really very easy to interpret is it? Yes that is sarcastic; certainly the very lowest form of wit but apt in this case. This is where TKPROF comes into play.

======================
PARSING IN CURSOR #3 len=56 dep=1 uid=0 oct=3 lid=0
tim=13822711723 hv=4049165760 ad=’67f67898′
select order#,columns,types from access$ where d_obj#=:1
END OF STMT
PARSE #3:c=0,e=145,p=0,cr=0,cu=0,mis=0,r=0,dep=1,og=4,
tim=13822711703
EXEC #3:c=0,e=136,p=0,cr=0,cu=0,mis=0,r=0,dep=1,og=4,
tim=13822714183
FETCH #3:c=0,e=114,p=0,cr=3,cu=0,mis=0,r=1,dep=1,og=4,
tim=13822714826
FETCH #3:c=0,e=78,p=0,cr=2,cu=0,mis=0,r=1,dep=1,og=4,
tim=13822715459
FETCH #3:c=0,e=67,p=0,cr=2,cu=0,mis=0,r=1,dep=1,og=4,
tim=13822716065
FETCH #3:c=0,e=64,p=0,cr=2,cu=0,mis=0,r=1,dep=1,og=4,
tim=13822716662
FETCH #3:c=0,e=65,p=0,cr=2,cu=0,mis=0,r=1,dep=1,og=4,
tim=13822717260
FETCH #3:c=0,e=42,p=0,cr=1,cu=0,mis=0,r=0,dep=1,og=4,
tim=13822717850
STAT #3 id=1 cnt=5 pid=0 pos=1 obj=97 op=’TABLE ACCESS BY
INDEX ROWID ACCESS$ ‘
STAT #3 id=2 cnt=5 pid=1 pos=1 obj=129 op=’INDEX RANGE
SCAN I_ACCESS1 ‘