An applet is a class file that is written to display graphics in web browser. We embed applets using <APPLET> HTML tags. When run in a web page, java applets are downloaded automatically and run by the web browser.

Now we will see how applet works using AWT(Abstract Windowing Toolkit) :

Most basic AWT class is java.awt.Componenet class, which all AWT visual components are based on. This class is directly derived from java.lang.object class. Another important AWT class is Container class. This class is derived from AWT Component class and it is the basis of AWT Containers, which can hold other components.

Hierarchy of APPLETS

java.lang.object

——– java.awt.Component

—— java.awt.Container

—– java.awt.Panel

—— java.applet.Applet

Example:

import java.applet.Applet

import java.awt.*;

/*

<Applet

CODE=applet.class

WIDTH=300

HEIGHT=200>

<Applet/>

*/

public class applet extends Applet

{

public void paint(Graphics g)

{

g.drawString("Hello, Welcome to the java world!!");

}

}

Explanation:

Paint method is used to display message in the applet. It is inherited from Component class. When applet is displayed paint method is called and we can place the code for drawing the applet in that method. This method is passed as object of the Graphics class. This object supports a method “drawString” which is used to draw string of text in the applet.

Graphics class is an AWT class, sowe import AWT class when we override the default paint method of the applet class.

Attributes of <APPLET> tag

<APPLET

[CODEBASE =  URL]

CODE = filename

[ALT = alternateText]

[NAME = instancename]

WIDTH = pixels

HEIGHT = pixels

[ALIGN = alignment]

[VSPACE = pixels]

[HSPACE = pixels]

>

[<PARAM  NAME = name  VALUE = value >]

</APPLET>

Explanation :

• CODEBASE – The URL that specifies the directory in which the applet code is to be found.
• CODE – The name of the applet file, including the extension .class.
• ALT – The text to be displayed if a browser supports applets but cant run this one for some reason.
• NAME – The name of the applet in the web browser. Applets must be given names if we want other applets to be able to find & interact with them.
• WIDTH – The width of the space reserved for the applet.
• HEIGHT – The height of the space reserved for the applet.
• ALIGN – Specifies the alignment of the applet. LEFT, RIGHT, TOP, BOTTOM, MIDDLE, BASELINE, TEXTTOP, ABSMIDDLE or ABSBOTTOM.
• VSPACE – The space allocated above & below the applet.
• HSPACE – The space allocated to the right & left around the applet.
• PARAM NAME – The name of a parameter to pass to the applet.
• PARAM  VALUE -  The value of a parameter.

The result of the above code appears as :

java applet

HTTP-GET:

Client requests a resource from server.
Server sends the resource to the client as a response.

HTTP-POST:

Client submits a resource to the server.
Server sends the acknowledgement to the client as a response.

SOAP:

Exchange of structured information between server and client.
Wider than HTTP-GET and HTTP-POST.
Can handle any communication in a distributive environment

*Note: A resource can be image,text file etc.

For a developer or admin, the transaction will be,

But did we estimate any failure condition in both of the cases shown above?

No.

So these cases do not follow the basic expectation of transaction that is to save from any kind of failure. Now, with our experience, we can define that Transaction is an ‘Expectation’ of a user and a developer. ‘Expectation of success’.

We also have a theoretical definition, which is very good for interview purpose and available everywhere on different sites.

“ Database transaction is collection of SQL queries which are fired sequentially to perform a single unit of work. To succeed, all queries should successfully run. If the sequences breaks with a failed query, then the unit of work will not happen and all the previous successfully run queries will also revert back.”

Here the aim is to successfully run the task or not run it at all.

To achieve this operation, all the best practices/concepts available were merged and laid the foundation of ACID rules, which should be followed to achieve any kind of successful transaction.

What are ACID properties or concepts?

First of all, they are concepts and not implementations. There are three part of implementation: Transaction, Commit and RollBack.

A=Atomicity : A single unit of work has to be atomic, either all steps of transaction completes so its a success or none of them like it never began. Failure is not an option.

To achieve a successful transaction, Commit statement should fire. or if any step fails, then a RollBack statement should fire, like the transaction never began.

C=Consistency : Consistency is more a related term and requires for a valid state of the database. A unit of work forms a transaction but there might be dependency which follows after a successful transaction or are beyond that unit of work. For example, a customer having multiple accounts, transfers money from his one account to other. In one case, the account was deducted the requested amount but other account was not updated with the new amount. It will leave the database in half finished state, which is not a desirable state. So database should remain consistent after a transaction.

I=Isolation : This concept is more related to exclusivity of transactions. When a transaction is happening, this transaction should have exclusive rights to perform the transaction. No other transaction should interfere with this transaction. To implement the concept, we can use Isolation levels in database.

D=Durability : This concept guarantees the availability of data after the transaction. It can be use of database backups and transaction logs that facilitate the restoration of committed transactions or hardware fail safe methods. The aim is clear which is ‘Never lose any data’.

Transaction Implementation Examples:

There are following commands used to control transactions.

COMMIT: Successful Transaction.

BEGIN TRANSACTION

UPDATE Savings SET min_Amount=500

COMMIT TRANSACTION

ROLLBACK: No transaction if any step fails.

BEGIN CATCH

<..........>

ROLLBACK TRANSACTION

END CATCH

SAVEPOINT: Points to save the transaction before any ROLLBACK. No rollback of whole transaction.

SAVEPOINT SAVEPOINT_NAME;

//and

ROLLBACK TO SAVEPOINT_NAME; // to rollback till savepoint, created earlier.

SET TRANSACTION: Sets characteristics of a transaction.

SET TRANSACTION [ READ WRITE | READ ONLY ];

Sample:

A sample format:

BEGIN TRY

BEGIN TRANSACTION

<..........>

COMMIT TRANSACTION

END TRY

BEGIN CATCH

<..........>

ROLLBACK TRANSACTION

END CATCH

Next in line: Isolation Levels

We have clustered and non-clustered index in SQL, let’s see the difference, their operation and advantages each one have.

We have a basic understanding that indexes are created on columns and organized into B-Tree structure for faster retrieval of data so both clustered and non-clustered index follows the same.

But the difference is,

Clustered :

1. Clustered indexes physically [actual bits on the disk] sorts and stores the data rows in the table based on the index values. means,the rows are stored physically on the disk in the same order as the index

2. A clustered index determines the order so there can be only one clustered index per table.

3. As a rule, this should be applied to the most common column which is always a part of WHERE clauses for queries.

4. Any data operation in the Table (like inserts, updates and deletes) reorders the index as clustered follows a physical sort and storing.

5. All the data operation will be slower. This is an overhead or a disadvantage.

6. As a best practice, the clustered index should be on a column which is unique and increasing such as an identity column.

7. Columns with the data type of TEXT, NTEXT and IMAGE are not included.

Non-Clustered :

1. Non-Clustered index follows logical ordering of data rows. means,  rows of data might not follow the way the index is ordered or sorted.

2. The index values will not point to the data rows but will have the address of the data rows.

3. Try to understand it more clearly, if we are looking for a value in non-clustered index then we will not get the data row directly like in the case of clustered, we will get the row locator and with the help of that we can get the physical pointer (corresponding clustered index value) of the data row.

4. 999 non-clustered indexes can be created.

5. Can contain upto 1023 included columns.

6. Columns with the data type of TEXT, NTEXT and IMAGE are not included.

What is the relation between keys and indexes?

When we assign PRIMARY KEY / UNIQUE key on table columns, Indexes are automatically created.

Example:

Let’s create a Employee table:

Create Table Employee
(
EmpId int,

EmpName varchar(100) ,

Salary int,
)

Right now, there is no index. Apply index on EmpId.

CREATE UNIQUE INDEX idxEmpId ON Employee (EmpId);

If there is already a clustered index on Table then a unique non-clustered index gets created else a unique clustered index gets created.

While defining the index, you can explicitly  mention non-clustered to create a non-clustered index but before that a clustered should exist.

CREATE NONCLUSTERED INDEX idxEmpId ON Employee (EmpId);

Caution:

Always find a balance between indexes because

1. More number of indexes are a spoilsport for inserts/updates.

2. Less number of indexes will hit the performance.

My first thought about Indexes is that ‘It is a solution’. I assume that you will ask me ‘What was the problem behind it?’

The problem lies in the way our regular data is stored. We know that data is stored on the heap.

What is the Heap?

A heap file is an unordered set of records where Records can be inserted and deleted. Also, Records are uniquely identified by a record-id. We can use this record-id to retrieve the specific data.

Heap file supports sequential scan of records. We can run our SQL query to retrieve the data but efficiency will always be on the lower side.

If we make some explicit correction and introduce some kind of order to this unordered set of data, we can reach a certain level of efficiency.

What do we need to do?

We need to locate a column based on some specific requirements and used it as a reference to retrieve the entire row of data. When we fire a SQL query to search for a row of data by providing a conditional value, SQL Server first finds that value in this special column, and retrieve the corresponding entire row of data.This column is normally called as Index.

What are the specific requirements?

Indexes can be created on most columns in a table except if the data-type is large object (LOB) data types, such as image, text, and varchar(max). It may also uniquely identify the row. if not, the output result might contain more that one row.

How Index-Seek happens?

We need some knowledge of B-tree architecture to understand Index-seek.

Indexed column values are arranged as per leaf nodes shown above. Each of the group is referenced as pages and also pointed as index level pages.  When a SQL query is run having some conditional value on index. The query engine starts from the root level and follows down till the leaf node, narrowing down the result set. Once query engine reaches the index level, it identifies and retrieves the exact result set expected. For example, let’s search for a value 60 in indexed column, the query engine starts from the root level and traverse down towards the right side and finally reaches the leaf node level. Here, the query engine identifies the value 60.

This operation is called index-seek where instead of going for sequential scan of the whole table, a B-tree traversal is done to seek the value on an indexed column.

Next in line:

1) Clustered Index and Non-Clustered Index