Wipro Interview Preparation and Recruitment Process

To delete duplicate rows from a table in SQL, you can use different methods depending on your database system (MySQL, PostgreSQL, SQL Server, Oracle, etc.). Here are common approaches:

1. Using ROW_NUMBER() (Preferred Method)

If your database supports ROW_NUMBER(), you can use it to identify and remove duplicates efficiently.

WITH CTE AS (
    SELECT 
        *, 
        ROW_NUMBER() OVER (PARTITION BY column1, column2 ORDER BY id) AS rn
    FROM table_name
)
DELETE FROM table_name
WHERE id IN (SELECT id FROM CTE WHERE rn > 1);

* Explanation :

• PARTITION BY column1, column2 groups duplicate rows based on selected columns.

• ROW_NUMBER() assigns a unique row number within each group.

• Deletes rows where rn > 1, keeping only the first occurrence.

2. Using DISTINCT to Create a New Table (Safe Method)

If direct deletion is risky, create a new table with only distinct records.

CREATE TABLE new_table AS
SELECT DISTINCT * FROM table_name;

DROP TABLE table_name;
ALTER TABLE new_table RENAME TO table_name;

* This ensures only unique records remain.

3. Using DELETE with GROUP BY (For Simple Cases)

For databases that don’t support ROW_NUMBER(), you can delete duplicates using GROUP BY and HAVING.

DELETE FROM table_name 
WHERE id NOT IN (
    SELECT MIN(id)
    FROM table_name 
    GROUP BY column1, column2
);

* Keeps only the row with the minimum id and deletes the rest.

CREATE PROCEDURE procedure_name  
AS  
sql_statement  
GO;  ?

EXEC procedure_name; ?

Self-Join: A self-join is a join which joins the table with itself, means that each row of the table is combined with itself and with every other row of the table. The table contains a FOREIGN KEY which references its PRIMARY KEY.

It shows the one-to-many relationship in a table also known as a unary relationship.

Now come to SQL outer join, all the content of both tables is integrated together either they are matched or not.

An outer join is of two types:

1. Left outer join (also known as left join): this join returns all the rows from left table combine with the matching rows of the right table. If you get no matching in the right table, it returns NULL values.

Syntax: Left outer join

• SELECT table1.column1, table2.column2.....
• FROM table1
• LEFTJOIN table2
• ON table1.column_field = table2.column_field;

2. Right outer join (also known as right join): this join returns all the rows from right table are combined with the matching rows of left table .If you get no column matching in the left table .it returns null value.

Basic syntax for right joins :

• SELECT table1.column1, table2.column2.....
• FROM table1
• RIGHT JOIN table2
• ON table1.column_field = table2.column_field;

DELETE FROM table_name [WHERE condition];

DELETE FROM table_name;

TRUNCATE TABLE employee;

//C
#include  
#include  
#define HRS 24      //Macro  
int main()  
{  
    printf("%d", HRS);  
    return 0;  
}

24

//C
#include  
int hrs()  
{  
    return 24;  
}  
int main()  
{  
    printf("%d", hrs());  //calling  
    return 0;  
}

24

 public class Sample
{
    public static void main(String[] args) throws InterruptedException
    {
        Sample s1 = new Sample();
        Sample s2 = new Sample();
          
        // Making the reference variable as null
        s1 = null;
          
        // Calling the system call function for garbage collection
        System.gc();
          
        // Making the reference variable as null
        s2 = null;
          
        // Calling for garbage collection through the getRuntime() method
        Runtime.getRuntime().gc();
      
    }
      
    @Override
    // This method is called on object once before garbage collecting it
    protected void finalize() throws Throwable
    {
        System.out.println("Garbage collector has been called");
        System.out.println("The Object whose garbage has been collected is : " + this);
    }
}

Garbage collector has been called
The Object whose garbage has been collected is : Sample@4251f172
Garbage collector has been called
The Object whose garbage has been collected is : Sample@481e8172

public interface List<E> <strong>extends</strong> Collection<E>

Sleep () method in Java has two variants one which takes millisecond as sleeping time while other which takes both millisecond and nanosecond for the sleeping duration.

Yield () method pause all the currently executing thread, and give a chance to execute those threads or processes that need to be run. The current thread will continue to run again if no other thread is available to execute.

Wrapper class in Java provides the mechanism to convert primitive into object and object into primitive. The eight classes of the java.lang package is known as wrapper classes in java.

The list of eight wrapper classes is given below :

Order of precedence is used with the operators. When a number of operators are used in an expression, it evaluates with the priority of the operators.

Associativity is used to check whether an expression is evaluated from left-to-right or right-to-left.

Order of precedence example:

(5 > 2 + 5 && 4)  

The given expression is equivalent to:

(5 > (2 + 5)) && 4)  

The expression (2 + 5) will executes first and the result will be 7
Then after first part of the expression (5 > 7) executes and gives 0 (false) as an output
Finally, (0 && 4) executes and gives 0 (false).

Associativity:

4 * 2 / 4  

Here, operators * and / have the same precedence. Both "*" and "/" are left to right associative, i.e., the expression on the left is executed first and moves towards the right.

Thus, the expression above is equivalent to :

((4 * 2) / 4)  
i.e., (4 * 2) executes first and the result will be 8 (true)  
then, (8 / 4) executes and the final output will be 2 (true)  

//Javascript
function fib(n){
  let [x, y] = [0, 1]
  while (n > 0){
    [x, y] = [y, x + y]
    n -= 1
  }
  return x
}

//C++ program to find the LCM of n elements of an array
#include <bits/stdc++.h>
using namespace std;
 
typedef long long int ll;
 
//the function that finds
//GCD of 'x' and 'y'
int GCD(int x, int y)
{
    if (y == 0)
        return x;
    return GCD(y, x % y);
}
 
//Driver Code
int main()
{
    int a[] = { 11, 7, 3, 9, 4 };
    int len = sizeof(a) / sizeof(a[0]);
    
    // Initializing result which will store the lcm
    ll res = a[0];
 
    // res contains LCM of a[0], ..a[i]
    // after i'th iteration,
    for (int i = 1; i < len; i++)
        res = (((a[i] * res)) /
                (GCD(a[i], res)));
 
    cout<<res<<endl;
    return 0;
}

2772

// C++
#include
#include
 
using namespace std;
 
class IB
{
    public:
    IB() {}
    IB(const IB &b)
    {
        cout<<"Copy constructor is called "<<endl;
    }
      
    IB& operator = (const IB &b)
    {
        cout<<"Assignment operator is called "<<endl;
        return *this;
    }
};
 
// Driver code
int main()
{
    IB b1, b2;
    b2 = b1;
    IB b3 = b1;
    getchar();
    return 0;
}

Assignment operator is called
Copy constructor is called

Data abstraction in DBMS is a process of hiding irrelevant details from users. Because database systems are made of complex data structures, so it makes accessible the user interaction with the database.

Following are three levels of data abstraction:

Physical level: It is the lowest level of abstraction. It describes how data are stored.

Logical level: It is the next higher level of abstraction. It describes what data are stored in the database and what the relationship among those data is.

View level: It is the highest level of data abstraction. It describes only part of the entire database.

Yes, it is possible to declare an anonymous class that both implements an interface and extends a class in Java. However, since Java does not support multiple inheritance, the anonymous class can only extend one class and optionally implement one or more interfaces.

Syntax

Superclass obj = new Superclass() {
    @Override
    public void methodFromSuperclass() {
        System.out.println("Overridden method from superclass");
    }
    
    @Override
    public void methodFromInterface() {
        System.out.println("Implemented method from interface");
    }
};

Example: Implementing an Interface While Extending a Class

// Parent class
class Parent {
    void show() {
        System.out.println("Parent class method");
    }
}

// Interface
interface MyInterface {
    void display();
}

public class Main {
    public static void main(String[] args) {
        // Anonymous class extending Parent and implementing MyInterface
        Parent obj = new Parent() {
            @Override
            public void show() {
                System.out.println("Overridden show() from anonymous class");
            }

            public void display() {
                System.out.println("Implemented display() from anonymous class");
            }
        };

        obj.show(); // Calls overridden method

        // To call display(), we need a type cast
        if (obj instanceof MyInterface) {
            ((MyInterface) obj).display();
        }
    }
}

Key Points :

• The anonymous class extends Parent.

• It implements MyInterface.

• Since the reference type is Parent, we need typecasting to call interface methods.