PayPay Interview Preparation and Recruitment Process

A rollback transaction is a database operation that reverts changes made during a transaction, restoring the database to its previous state before the transaction began. It’s a key part of transaction management in databases to ensure data integrity and consistency.

Here's how it works:

Imagine you're transferring money between two bank accounts:

1. Debit $100 from Account A

2. Credit $100 to Account B

If something fails (like the system crashes after step 1 but before step 2), you don’t want Account A to lose money without Account B getting it. So the whole transaction is rolled back—it’s like it never happened.

Use Cases for Rollback

• Errors during the transaction (e.g. constraint violations, timeouts)

• Manual cancellation by user or system logic

• Data integrity checks fail

Key Concepts:

• BEGIN TRANSACTION: Starts a transaction

• COMMIT: Saves the changes permanently

• ROLLBACK: Undoes all changes since BEGIN TRANSACTION

Example (SQL):

BEGIN TRANSACTION;

UPDATE accounts SET balance = balance - 100 WHERE id = 1;
UPDATE accounts SET balance = balance + 100 WHERE id = 2;

-- Something goes wrong here
ROLLBACK;  -- Everything is undone

// Java program to determine if Binary tree is a sum tree
import java.io.*;
class Node
{
    int val;
    Node left, right, nextRight;
    Node(int item)
    {
        val = item;
        left = right = null;
    }
}

class Main
{
    public static Node root;   
    static int sum(Node node)
    {
        if(node == null)
        {
            return 0;
        }
        return (sum(node.left) + node.val+sum(node.right));
    }
   
    static int checkTree(Node node)
    {
        int sumleft, sumright;
       
        //Return true if node is NULL or a leaf node
        if(node == null || (node.left == null && node.right == null))
        {
            return 1;
        }
       
        // Add up nodes in left and right subtrees
        sumleft = sum(node.left);
        sumright = sum(node.right);
       
        if((node.val == sumleft + sumright) && checkTree(node.left) != 0 && checkTree(node.right) != 0)
        {
            return 1;
        }
        return 0;
    }
   
    // Driver code
    public static void main (String[] args)
    {
        Main tree=new Main();
        tree.root = new Node(40);
        tree.root.left = new Node(15);
        tree.root.right = new Node(5);
        tree.root.left.left = new Node(9);
        tree.root.left.right = new Node(6);
        tree.root.right.right = new Node(5);
        if(checkTree(root) != 0)
        {
            System.out.println("This is a SumTree!");
        }
        else
        {
            System.out.println("This is not a SumTree!");
        }
    }
}​

// Java program to determine if a string is palindrome
import java.util.*;
public class Main
{
    // Returns true if string is palindrome
    static boolean checkPalindrome(String s)
    {
        int i = 0, j = s.length() - 1;
        while (i < j)
        {
            if (s.charAt(i) != s.charAt(j))
                return false;
            i++;
            j--;
        }
        // Given string is a palindrome
        return true;
    }

//Driver method
    public static void main(String[] args)
    {
        Scanner sc=new Scanner(System.in);  
        System.out.println("Enter a string: ");
        String s= sc.nextLine();         
        //Convert the string to lowercase
        s = s.toLowerCase();
        if (checkPalindrome(s))
            System.out.print("Yes, the given string is a Palindrome!");
        else
            System.out.print("No, the given string is not a Palindrome!");
    }
}​

Enter a string:
Level
Yes, the given string is a Palindrome!​

Enter a string:
Scaler
No, the given string is not a Palindrome!​

import java.util.*;
import java.lang.*;
import java.io.*;
class Main
{
    static void printSubStr(String s, int low, int high)
    {
        for (int i = low; i <= high; ++i)
        System.out.print(s.charAt(i));
    }

    public static int longPalindromeSubstr(String s)
    {
        int l = s.length();
    
        // Every subString of length 1 is a palindrome
        int maxLength = 1, start = 0;
    
        // Mark start and end index with nested loop
        for (int i = 0; i < s.length(); i++)
        {
            for (int j = i; j < s.length(); j++)
            {
                int flag = 1;
    
                // Check for palindrome
                for (int n = 0; n < (j - i + 1) / 2; n++)
                    if (s.charAt(i + n) != s.charAt(j - n))
                        flag = 0;
    
                // Palindrome
                if (flag!=0 && (j - i + 1) > maxLength)
                {
                    start = i;
                    maxLength = j - i + 1;
                }
            }
        }
       
       System.out.print("Longest palindromic substring in given string is: ");
       printSubStr(s, start, start + maxLength - 1);
    
       return maxLength;
    }
    public static void main(String args[])
        {
        Scanner sc=new Scanner(System.in);  
        System.out.println("Enter a string: ");
        String s= sc.nextLine();
        System.out.println("\nLength: " + longPalindromeSubstr(s));
    }
}​

Enter a string:
Bananas
Longest palindromic substring in given string is: anana
Length: 5​

SET IMPLICIT_TRANSACTIONS ON​

SET IMPLICIT_TRANSACTIONS OFF​