package com.ukg.bi.conversationalreporting.service;

import com.google.cloud.vertexai.api.*;
import com.google.cloud.vertexai.generativeai.*;
import com.ukg.bi.conversationalreporting.configuration.ConversationalReportingConfigProperties;
import com.ukg.bi.conversationalreporting.configuration.SpringConfig;
import com.ukg.bi.conversationalreporting.constant.ConversationalReportingConstants;
import com.ukg.bi.conversationalreporting.dto.SummaryStreaming;
import com.ukg.bi.conversationalreporting.entity.AuditEntity;
import com.ukg.bi.conversationalreporting.sse.ResponseEmitter;
import com.ukg.bi.conversationalreporting.util.DateTimeUtil;
import com.ukg.bi.conversationalreporting.util.JsonParsingUtil;
import com.ultimatesoftware.bi.lookerdatatestframework.data.collection.DataCollection;
import lombok.extern.slf4j.Slf4j;
import net.logstash.logback.encoder.org.apache.commons.lang.StringEscapeUtils;
import org.springframework.cloud.sleuth.annotation.NewSpan;
import org.springframework.scheduling.annotation.Async;
import org.springframework.scheduling.annotation.AsyncResult;
import org.springframework.stereotype.Service;

import java.util.*;
import java.util.concurrent.CompletableFuture;

@Slf4j
@Service
public class FunctionalCallingServiceImpl implements FunctionalCallingService {

    private final ConversationalReportingConfigProperties config;
    private final PredictionService predictionService;
    private final SpringConfig springConfig;
    private final SummaryStreamingService summaryStreamingService;
    private final LocalizationService localizationService;
    private final FeatureFlagService featureFlagService;

    public FunctionalCallingServiceImpl(ConversationalReportingConfigProperties config,
                                        PredictionService predictionService,
                                        SpringConfig springConfig,
                                        SummaryStreamingService summaryStreamingService,
                                        LocalizationService localizationService,
                                        FeatureFlagService featureFlagService) {
        this.config = config;
        this.predictionService = predictionService;
        this.springConfig = springConfig;
        this.summaryStreamingService = summaryStreamingService;
        this.localizationService = localizationService;
        this.featureFlagService = featureFlagService;
    }

    @Async
    @NewSpan("functional-calling-ai-predict-summary")
    @Override
    public CompletableFuture<String> generateSummary(String question, DataCollection dataCollection,
                                                     AuditEntity auditEntity, ResponseEmitter emitter,
                                                     SummaryStreaming summaryStreaming, String localeCode) {
        auditEntity.setSummarizationStartDateTime(DateTimeUtil.getCurrentLocalDateTime());
        String noDataMessage = localizationService.isLocalizationEnabled()
                ? localizationService.getNoDataMessage(Objects.toString(localeCode, ""))
                : ConversationalReportingConstants.NO_DATA_ERROR_MESSAGE;

        if (dataCollection.getRows().isEmpty()) {
            auditEntity.setCfEndDateTime(DateTimeUtil.getCurrentLocalDateTime());
            return AsyncResult.forValue(noDataMessage).completable();
        }

        try {
            String systemInstruction = ConversationalReportingConstants.SUMMARIZATION_SYSTEM_INSTRUCTION;

            GenerativeModel model= new GenerativeModelFactory(config, springConfig, predictionService).createModel(systemInstruction);


            FunctionDeclaration functionDeclaration = FunctionDeclaration.newBuilder()
                    .setName(ConversationalReportingConstants.GENERATE_SUMMARY)
                    .setDescription(ConversationalReportingConstants.FUNCTION_CALLING_DESCRIPTION)
                    .setParameters(
                            Schema.newBuilder()
                                    .setType(Type.OBJECT)
                                    .putProperties(ConversationalReportingConstants.FUNCTION_CALLING_SUMMARY, Schema.newBuilder()
                                            .setType(Type.ARRAY)
                                            .setDescription(ConversationalReportingConstants.FUNCTION_CALLING_SUMMARY_DESCRIPTION)
                                            .setItems(Schema.newBuilder()
                                                    .setType(Type.STRING)
                                                    .build())
                                            .build())
                                    .putProperties(ConversationalReportingConstants.FUNCTION_CALLING_AREA_TO_EXPLORE, Schema.newBuilder()
                                            .setType(Type.ARRAY)
                                            .setDescription(ConversationalReportingConstants.FUNCTION_CALLING_AREA_TO_EXPLORE_DESCRIPTION)
                                            .setItems(Schema.newBuilder()
                                                    .setType(Type.STRING)
                                                    .build())
                                            .build())
                                    .addRequired(ConversationalReportingConstants.FUNCTION_CALLING_SUMMARY)
                                    .addRequired(ConversationalReportingConstants.FUNCTION_CALLING_AREA_TO_EXPLORE)
                                    .build())
                    .build();

            Tool tool = Tool.newBuilder()
                    .addFunctionDeclarations(functionDeclaration)
                    .build();

            GenerativeModel modelWithTools = model.withTools(Collections.singletonList(tool));
            ChatSession chat = modelWithTools.startChat();

            StringBuilder summaryPrompt = createInstance(dataCollection,localeCode,question);
            ResponseStream<GenerateContentResponse> responseStream = chat.sendMessageStream(summaryPrompt.toString());

            if (summaryStreaming.isSummaryStreamingEnabled()) {
                summaryStreamingService.startSummaryStreaming(responseStream, emitter, summaryStreaming);
            } else {
                responseStream.stream().forEach(response -> summaryStreaming.getSummaryBuilder().append(response.getCandidates(0).getContent().getParts(0).getText()));
            }


            return AsyncResult.forValue(summaryStreaming.getSummaryBuilder().toString()).completable();


        } catch (Exception e) {
            auditEntity.setSummarizationError(ConversationalReportingConstants.VERTEX_AI_SUMMARIZATION_API_EXCEPTION + e);
            log.error(ConversationalReportingConstants.VERTEX_AI_SUMMARIZATION_API_EXCEPTION, e);
            return AsyncResult.forValue(ConversationalReportingConstants.SUMMARIZATION_NOT_FETCHED).completable();
        } finally {
            auditEntity.setSummarizationEnddateTime(DateTimeUtil.getCurrentLocalDateTime());
        }
    }

    private StringBuilder createInstance(DataCollection dataCollection, String localeCode, String question) {

        StringBuilder instance = new StringBuilder();

        if (localizationService.isLocalizationEnabled()) {
            instance.append(String.format(ConversationalReportingConstants.SUMMARIZATION_LOCALIZATION_PREFIX, localeCode, localeCode))
                    .append("\n\n");
        }
        instance.append(ConversationalReportingConstants.SUMMARIZATION_QUESTION_PROMPT)
                .append(question)
                .append("\n\n")
                .append(ConversationalReportingConstants.SUMMARIZATION_INSTANCE_PREFIX)
                .append(formatData(dataCollection))
                .append(ConversationalReportingConstants.CLOSED_CURLY_BRACE)
                .append("\n");

        return instance.append(dataCollection.getRows().size());
    }


    private static String formatData(DataCollection dataCollection) {
        return StringEscapeUtils.escapeJava(StringEscapeUtils.escapeJava(
                JsonParsingUtil.getJSONString(dataCollection)));
    }
}

interface

package com.ukg.bi.conversationalreporting.service;
import com.ukg.bi.conversationalreporting.dto.SummaryStreaming;
import com.ukg.bi.conversationalreporting.entity.AuditEntity;
import com.ukg.bi.conversationalreporting.sse.ResponseEmitter;
import com.ultimatesoftware.bi.lookerdatatestframework.data.collection.DataCollection;

import java.util.concurrent.CompletableFuture;
public interface FunctionalCallingService {
    CompletableFuture<String> generateSummary(String question, DataCollection dataCollection, AuditEntity auditEntity, ResponseEmitter emitter, SummaryStreaming summaryStreaming, String localeCode);

}

generative model

package com.ukg.bi.conversationalreporting.service;

import com.google.cloud.vertexai.generativeai.GenerativeModel;
import com.ukg.bi.conversationalreporting.configuration.ConversationalReportingConfigProperties;
import com.ukg.bi.conversationalreporting.configuration.SpringConfig;

import org.springframework.stereotype.Component;

@Component
public class GenerativeModelFactory {

    private final ConversationalReportingConfigProperties config;
    private final SpringConfig springConfig;
    private final PredictionService predictionService;

    public GenerativeModelFactory(ConversationalReportingConfigProperties config, SpringConfig springConfig,PredictionService predictionService) {
        this.config = config;
        this.springConfig = springConfig;
        this.predictionService = predictionService;
    }

    public GenerativeModel createModel(String systemInstruction) {
        return predictionService.generativeModel(
                config.getVertex().getModel(),
                springConfig.vertexAI(),
                systemInstruction
        );
    }
}

constant

// Functional calling
    public static final String GENERATE_SUMMARY = "generateSummary";
    public static final String FUNCTION_CALLING_DESCRIPTION = "Generate a structured summary with key points and exploration areas";
    public static final String FUNCTION_CALLING_SUMMARY = "summary";
    public static final String FUNCTION_CALLING_SUMMARY_DESCRIPTION = "3 key summary bullet points";
    public static final String FUNCTION_CALLING_AREA_TO_EXPLORE = "areas_to_explore";
    public static final String FUNCTION_CALLING_AREA_TO_EXPLORE_DESCRIPTION = "3 follow-up questions/topics in form of bullet points";




public static final String SUMMARIZATION_SYSTEM_INSTRUCTION = "Please summarize the data in three concise points that are easy for a non-technical audience, such as a manager or CEO, to understand. "
            + "Additionally, identify three relevant areas to explore that may be important for decision-making. Be detailed and relevant to the data being summarized .\n"
            + "And make area to explore are not in the form of questions"
            + "Ensure that all numerical counts and figures are accurately reflected. Do not round or estimate numbers.\n"
            + "Use only the total records provided in the input as the definitive count for the list data question, without recalculating or adjusting.\n\n"
            + "Please follow this format exactly:\n\n" +
            "## Summary:\n" +
            "1) ...\n" +
            "2) ...\n" +
            "3) ...\n" +
            "\n" +
            "## Areas to Explore:\n" +
            "1) ...\n" +
            "2) ...\n" +
            "3) ...\n";

Async

package com.ukg.bi.conversationalreporting.service;

import com.ukg.bi.conversationalreporting.constant.ConversationalReportingConstants;
import com.ukg.bi.conversationalreporting.dto.EmbedLookResponse;
import com.ukg.bi.conversationalreporting.dto.SummaryStreaming;
import com.ukg.bi.conversationalreporting.dto.UserContextDto;
import com.ukg.bi.conversationalreporting.entity.AuditEntity;
import com.ukg.bi.conversationalreporting.exception.AsyncThreadException;
import com.ultimatesoftware.bi.lookerdatatestframework.data.collection.DataCollection;
import lombok.extern.slf4j.Slf4j;
import org.openapitools.client.model.Query;
import org.springframework.cloud.sleuth.annotation.NewSpan;
import org.springframework.scheduling.annotation.Async;
import org.springframework.scheduling.annotation.AsyncResult;
import org.springframework.stereotype.Service;

import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.concurrent.CompletableFuture;

@Slf4j
@Service
public class AsyncServiceImpl implements AsyncService {
    private final LookerAPIService lookerAPIService;
    private final EmbedLookService embedLookService;
    private final SummarizationService summarizationService;
    private final UserContextService userContextService;
    private final ExploreQueryFacade exploreQueryFacade;
    private final FunctionalCallingServiceImpl functionalCallingServiceImpl;

    public AsyncServiceImpl(LookerAPIService lookerAPIService, EmbedLookService embedLookService,
                            SummarizationService summarizationService, UserContextService userContextService, ExploreQueryFacade exploreQueryFacade, FunctionalCallingServiceImpl functionalCallingServiceImpl) {
        this.lookerAPIService = lookerAPIService;
        this.embedLookService = embedLookService;
        this.summarizationService = summarizationService;
        this.userContextService = userContextService;
        this.exploreQueryFacade = exploreQueryFacade;
        this.functionalCallingServiceImpl = functionalCallingServiceImpl;
    }

    @Async
    @NewSpan("retrieve-summary")
    @Override
    public CompletableFuture<String> getSummary(String nlQuestion, Query lookerQuery, AuditEntity auditEntity, DataCollection dataCollection, String localeCode) {
        try {
            String summarization = functionalCallingServiceImpl.generateSummary(nlQuestion, dataCollection, auditEntity, null, new SummaryStreaming(), localeCode).get();
            return AsyncResult.forValue(summarization).completable();
        } catch (Exception e) {
            log.error("Exception occurred while executing the async thread for summary.", e);
            throw new AsyncThreadException(ConversationalReportingConstants.ASYNC_THREAD_EXCEPTION, e);
        }
    }

    @Async
    @NewSpan("retrieve-looker-data-and-summary")
    @Override
    public CompletableFuture<List<Object>> retrieveLookerDataAndSummary(String nlQuestion, Query lookerQuery, Long userId, AuditEntity auditEntity, UserContextDto userContext) {
        try {
            DataCollection dataCollection = lookerAPIService.runInlineQuery(lookerQuery, userId, auditEntity).get();

            String summarization = functionalCallingServiceImpl.generateSummary(nlQuestion, dataCollection, auditEntity, null, new SummaryStreaming(), userContext.getLocaleCode()).get();

            return AsyncResult.forValue(Arrays.asList(dataCollection, summarization)).completable();
        } catch (Exception e) {
            log.error("Exception occurred while executing the async thread for looker data and summary.", e);
            throw new AsyncThreadException(ConversationalReportingConstants.ASYNC_THREAD_EXCEPTION, e);
        }
    }

    @Async
    @NewSpan("get-embed-look-response")
    @Override
    public CompletableFuture<EmbedLookResponse> getEmbedLookResponse(Map<String, String> requestHeaders, AuditEntity auditEntity, Query lookerQuery,
                                                                     UserContextDto userContext, Long userId) {
        try {
            return embedLookService.embedLook(requestHeaders, lookerQuery, userContext, userId, auditEntity);
        } catch (Exception e) {
            log.error("Exception occurred while executing the async thread for embed look response", e);
            throw new AsyncThreadException(ConversationalReportingConstants.ASYNC_THREAD_EXCEPTION, e);
        }
    }

    @Async
    @NewSpan("get-user-id")
    @Override
    public CompletableFuture<Long> getUserId(UserContextDto userContext, AuditEntity auditEntity) {
        try {
            return userContextService.getUserIdFromImpersonatedUserContext(userContext, auditEntity);
        } catch (Exception e) {
            log.error("Exception occurred while executing the async thread for user id", e);
            throw new AsyncThreadException(ConversationalReportingConstants.ASYNC_THREAD_EXCEPTION, e);
        }
    }

    @Async
    @NewSpan("get-predicted-explore-query")
    @Override
    public CompletableFuture<Query> getPredictedExploreQuery(String nlQuestion, String predictedExplore, String tmsTenantId, AuditEntity auditEntity) {
        try {
            return exploreQueryFacade.getExploreQueryPredictionService().predictExploreQuery(nlQuestion, auditEntity, predictedExplore, tmsTenantId);
        } catch (Exception e) {
            log.error("Exception occurred while executing the async thread for predicted explore query", e);
            throw new AsyncThreadException(ConversationalReportingConstants.ASYNC_THREAD_EXCEPTION, e);
        }
    }

}

SSE

package com.ukg.bi.conversationalreporting.service;

import com.ukg.bi.conversationalreporting.constant.ConversationalReportingConstants;
import com.ukg.bi.conversationalreporting.constant.FeatureFlags;
import com.ukg.bi.conversationalreporting.dto.ConversationalReportingResponse;
import com.ukg.bi.conversationalreporting.dto.ConversationalReportingResponseComponent;
import com.ukg.bi.conversationalreporting.dto.ConversationalReportingResponseMarkdown;
import com.ukg.bi.conversationalreporting.dto.ExpandableResultItem;
import com.ukg.bi.conversationalreporting.dto.SummaryStreaming;
import com.ukg.bi.conversationalreporting.dto.UserContextDto;
import com.ukg.bi.conversationalreporting.entity.AuditEntity;
import com.ukg.bi.conversationalreporting.enumeration.ExploreType;
import com.ukg.bi.conversationalreporting.enumeration.LaunchDarklyUserContextAttribute;
import com.ukg.bi.conversationalreporting.exception.StreamingException;
import com.ukg.bi.conversationalreporting.sse.ResponseEmitter;
import com.ukg.bi.conversationalreporting.util.ExploreUtils;
import com.ukg.bi.conversationalreporting.util.JsonParsingUtil;
import com.ultimatesoftware.bi.lookerdatatestframework.data.collection.DataCollection;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang.StringUtils;
import org.openapitools.client.model.Query;
import org.springframework.stereotype.Service;

import java.io.IOException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.CompletionException;
import java.util.concurrent.atomic.AtomicReference;
import java.util.function.Function;

@Slf4j
@Service
public class ConversationalReportingSseServiceImpl implements ConversationalReportingSseService {
    private final ConversationalReportingResponseService responseService;
    private final UserContextService userContextService;
    private final SummarizationService summarizationService;
    private final FeatureFlagService featureFlagService;
    private final LookerFacade lookerFacade;
    private final ExploreQueryFacade exploreQueryFacade;
    private final VertexExploreClassifierService vertexExploreClassifierService;
    private final LocalizationService localizationService;
    private final ShowCalculationService showCalculationService;
    private final FunctionalCallingServiceImpl functionalCallingServiceImpl;

    public ConversationalReportingSseServiceImpl(ConversationalReportingResponseService responseService, UserContextService userContextService, SummarizationService summarizationService, FeatureFlagService featureFlagService, LocalizationService localizationService, LookerFacade lookerFacade, ExploreQueryFacade exploreQueryFacade, VertexExploreClassifierService vertexExploreClassifierService, ShowCalculationService showCalculationService, FunctionalCallingServiceImpl functionalCallingServiceImpl) {
        this.responseService = responseService;
        this.lookerFacade = lookerFacade;
        this.userContextService = userContextService;
        this.summarizationService = summarizationService;
        this.featureFlagService = featureFlagService;
        this.localizationService = localizationService;
        this.exploreQueryFacade = exploreQueryFacade;
        this.vertexExploreClassifierService = vertexExploreClassifierService;
        this.showCalculationService = showCalculationService;
        this.functionalCallingServiceImpl = functionalCallingServiceImpl;
    }

    @Override
    public void process(String nlQuestion, Map<String, String> requestHeaders, UserContextDto userContext, AuditEntity auditEntity, ResponseEmitter emitter) {
        String originalNlQuestion = nlQuestion;
        String tmsTenantId = userContext.getTmsTenantId();

        String predictedExplore = vertexExploreClassifierService.classifyExplore(nlQuestion, auditEntity);
        predictedExplore = ExploreUtils.getCleanPredictedExplore(predictedExplore);

        if (predictedExplore.equals(ExploreType.REPORTING_CAPABILITIES.getValue())) {
            String reportingCapabilitiesExplore = localizationService.isLocalizationEnabled() ? localizationService.getReportingCapabilitiesExplore(Objects.toString(userContext.getLocaleCode(), StringUtils.EMPTY)) : ConversationalReportingConstants.REPORTING_CAPABILITIES_MESSAGE;
            emitter.sendData(responseService.getSummaryOnlyResponse(reportingCapabilitiesExplore));
            return;
        }

        if (predictedExplore.equals(ExploreType.OUT_OF_SCOPE.getValue())) {
            String outOfScopeExplore = localizationService.isLocalizationEnabled() ? localizationService.getOutOfScopeExplore(Objects.toString(userContext.getLocaleCode(), StringUtils.EMPTY)) : ConversationalReportingConstants.OUT_OF_SCOPE_ERROR_MESSAGE;
            emitter.sendData(responseService.getSummaryOnlyResponse(outOfScopeExplore));
            return;
        }

        auditEntity.setExploreUsed(predictedExplore);

        if (featureFlagService.isFeatureEnabled(FeatureFlags.USER_INTEGRATION_KEY_ENABLED, LaunchDarklyUserContextAttribute.TENANT_ID.getValue(), userContext.getTmsTenantId())) {
            userContext.setAttributes(userContextService.populateUserAttributes(userContext.getTmsTenantId(), userContext.getUserIntegrationKey(), userContext.getLocaleCode()));
            nlQuestion = exploreQueryFacade.getDynamicNERService().dynamicNER(userContext.getTmsTenantId(), userContext.getUserIntegrationKey(), nlQuestion, auditEntity, userContext);
        } else {
            userContext.setAttributes(userContextService.populateUserAttributes(userContext.getTmsTenantId(), userContext.getUserEeId(), userContext.getLocaleCode()));
            nlQuestion = exploreQueryFacade.getDynamicNERService().dynamicNER(userContext.getTmsTenantId(), userContext.getUserEeId(), nlQuestion, auditEntity, userContext);
        }
        emitter.sendProgress(ConversationalReportingConstants.DYNAMIC_NER_WEIGHTAGE);

        CompletableFuture<Query> queryCompletableFuture = exploreQueryFacade.getExploreQueryPredictionService().predictExploreQuery(nlQuestion, auditEntity, predictedExplore, tmsTenantId);

        CompletableFuture<Long> userIdCompletableFuture = userContextService.getUserIdFromImpersonatedUserContext(userContext, auditEntity);

        CompletableFuture.allOf(queryCompletableFuture, userIdCompletableFuture).join();

        Query lookerQuery = queryCompletableFuture.join();
        emitter.sendProgress(ConversationalReportingConstants.PREDICT_EXPLORE_QUERY_WEIGHTAGE);

        Long userId = userIdCompletableFuture.join();
        log.debug("NL Question: {}, Explore Query : {}, User ID : {}", nlQuestion, lookerQuery, userId);
        emitter.sendProgress(ConversationalReportingConstants.IMPERSONATED_USER_CONTEXT_WEIGHTAGE);

        CompletableFuture<DataCollection> serializedLookerResponse = null;

        boolean noDataMessageFlag = isNoDataMessageEnabled(tmsTenantId);
        boolean showCalculationFlag = isShowCalculationEnabled(tmsTenantId);
        if (noDataMessageFlag) {
            serializedLookerResponse = lookerFacade.getLookerAPIService().runInlineQuery(lookerQuery, userId, auditEntity);
        }

        SummaryStreaming summaryStreaming = new SummaryStreaming();
        summaryStreaming.setSummaryStreamingEnabled(featureFlagService.isFeatureEnabled(FeatureFlags.SUMMARY_STREAMING_ENABLED, LaunchDarklyUserContextAttribute.TENANT_ID.getValue(), tmsTenantId));

        CompletableFuture<ConversationalReportingResponse> embedFuture = embedLook(requestHeaders, auditEntity, lookerQuery, userContext, userId);

        CompletableFuture<ConversationalReportingResponse> summaryFuture = summarize(serializedLookerResponse, lookerQuery, userId, auditEntity, originalNlQuestion, emitter, summaryStreaming, tmsTenantId, userContext.getLocaleCode());

        CompletableFuture<String> showCalculationMarkdown;
        CompletableFuture<String> updatedCalculationMarkdown;

        if (showCalculationFlag && !Objects.isNull(showCalculationService)) {
            showCalculationMarkdown = showCalculationService.predictShowCalculation(lookerQuery, userContext.getLocaleCode());
            updatedCalculationMarkdown = showCalculationMarkdown.thenApply(existingMarkdown ->
                    existingMarkdown + localizationService.getCRDocuments(Objects.toString(userContext.getLocaleCode(), ""))
            );
        } else {
            updatedCalculationMarkdown = null;
        }
        if (noDataMessageFlag && serializedLookerResponse.join().getRows().isEmpty()) {
            String noDataMessage = isLocalizationEnabled() ? localizationService.getNoDataMessage(Objects.toString(userContext.getLocaleCode(), "")) : ConversationalReportingConstants.NO_DATA_ERROR_MESSAGE;
            emitter.sendData(responseService.getSummaryOnlyResponse(noDataMessage));
            if (showCalculationFlag) {
                sendShowCalculation(emitter, null, null, updatedCalculationMarkdown, userContext.getLocaleCode(), true);
                emitter.sendProgress(ConversationalReportingConstants.SHOW_CALC_WEIGHTAGE);
            }
            return;
        }
        //send the embed and summary responses in correct order
        AtomicReference<Throwable> finalExceptionRef = new AtomicReference<>();
        sendEmbedData(emitter, embedFuture, finalExceptionRef);
        emitter.sendProgress(ConversationalReportingConstants.EMBED_LOOK_WEIGHTAGE);
        sendSummaryData(emitter, embedFuture, summaryFuture, finalExceptionRef, summaryStreaming);
        emitter.sendProgress(ConversationalReportingConstants.SUMMARIZATION_WEIGHTAGE);
        if (showCalculationFlag) {
            sendShowCalculation(emitter, summaryFuture, finalExceptionRef, updatedCalculationMarkdown, userContext.getLocaleCode(), false);
            emitter.sendProgress(ConversationalReportingConstants.SHOW_CALC_WEIGHTAGE);
        }
        Throwable finalException = finalExceptionRef.get();
        if (finalException != null) {
            throw new StreamingException("Error while processing NL question", finalException);
        }
    }

    private CompletableFuture<ConversationalReportingResponse> summarize(CompletableFuture<DataCollection> serializedLookerResponse, Query lookerQuery, Long userId, AuditEntity auditEntity, String originalNlQuestion, ResponseEmitter emitter, SummaryStreaming summaryStreaming, String tmsTenantId, String localeCode) {
        if (isNoDataMessageEnabled(tmsTenantId)) {
            return functionalCallingServiceImpl.generateSummary(originalNlQuestion, serializedLookerResponse.join(), auditEntity, emitter, summaryStreaming, localeCode).thenApply(responseService::getSummaryOnlyResponse);
        }

        // When noDataMessageEnabled is false then this block will be executed.
        // Later we will remove this block when we will remove noDataMessageEnabled flag.
        return lookerFacade.getLookerAPIService().runInlineQuery(lookerQuery, userId, auditEntity).thenCompose(dataCollection -> functionalCallingServiceImpl.generateSummary(originalNlQuestion, dataCollection, auditEntity, emitter, summaryStreaming, localeCode)).thenApply(responseService::getSummaryOnlyResponse);
    }

    private CompletableFuture<ConversationalReportingResponse> embedLook(Map<String, String> requestHeaders, AuditEntity auditEntity, Query lookerQuery, UserContextDto userContext, Long userId) {
        return lookerFacade.getEmbedLookService().embedLook(requestHeaders, lookerQuery, userContext, userId, auditEntity).thenApply(embedResponse -> new ConversationalReportingResponse(Collections.singletonList(embedResponse)));
    }

    private static void sendEmbedData(ResponseEmitter emitter, CompletableFuture<ConversationalReportingResponse> embedFuture, AtomicReference<Throwable> finalException) {
        embedFuture.thenAccept(emitter::sendData).exceptionally(handleException(finalException)).join();
    }

    private static <T> Function<Throwable, ? extends T> handleException(AtomicReference<Throwable> finalException) {
        return e -> {
            finalException.getAndAccumulate(e, (current, newException) -> {
                //removing unnecessary wrapper
                Throwable actualNewException = newException instanceof CompletionException ? newException.getCause() : newException;

                //composing exceptions
                if (current == null) {
                    return actualNewException;
                } else {
                    current.addSuppressed(actualNewException);
                    return current;
                }
            });
            return null;
        };
    }

    private void sendSummaryData(ResponseEmitter emitter, CompletableFuture<ConversationalReportingResponse> embedFuture, CompletableFuture<ConversationalReportingResponse> summaryFuture, AtomicReference<Throwable> finalException, SummaryStreaming summaryStreaming) {

        if (summaryStreaming.isSummaryStreamingEnabled()) {
            embedFuture.whenComplete((embedResponse, e) -> {

                summaryStreaming.setStartEmitting(true);
                summaryFuture.thenAccept((summaryResponse) -> {
                    if (!summaryStreaming.isEmitted()) {
                        emitter.sendData(summaryResponse);
                    }
                }).exceptionally(handleException(finalException)).join();
            });
        } else {
            embedFuture.whenComplete((embedResponse, e) -> summaryFuture.thenAccept(emitter::sendData).exceptionally(handleException(finalException)).join());
        }
    }

    private void sendShowCalculation(ResponseEmitter emitter, CompletableFuture<ConversationalReportingResponse> summaryFuture, AtomicReference<Throwable> finalException, CompletableFuture<String> showCalculationMarkdown, String localeCode, boolean isLookerResponseEmpty) {

        if (Objects.isNull(showCalculationMarkdown)) {
            log.debug("Calculation result is null, skipping show calculation");
            return;
        }

        try {
            if (isLookerResponseEmpty) {
                handleShowCalcFuture(emitter, showCalculationMarkdown, localeCode);
            } else {
                handleSummaryFuture(emitter, summaryFuture, finalException, showCalculationMarkdown, localeCode);
            }
        } catch (Exception e) {
            log.error("Error in sendShowCalculation: {}", e.getMessage(), e);
            finalException.compareAndSet(null, e);
        }
    }

    private void handleShowCalcFuture(ResponseEmitter emitter, CompletableFuture<String> showCalculationMarkdown, String localeCode) {
        showCalculationMarkdown.thenAccept(response -> {
            sendCalcResponse(emitter, localeCode, response);
        }).exceptionally(ex -> {
            log.error("Error in calculation result: {}", ex.getMessage(), ex);
            return null;
        }).join();
    }

    private void handleSummaryFuture(ResponseEmitter emitter, CompletableFuture<ConversationalReportingResponse> summaryFuture, AtomicReference<Throwable> finalException, CompletableFuture<String> calcResult, String localeCode) {

        summaryFuture.thenAccept(summaryResponse -> {
            try {
                handleCalcResult(emitter, calcResult, localeCode);
            } catch (Exception e) {
                log.error("Error in summaryFuture.thenAccept: {}", e.getMessage(), e);
            }
        }).exceptionally(ex -> {
            finalException.compareAndSet(null, ex);
            return null;
        });
    }

    private void handleCalcResult(ResponseEmitter emitter, CompletableFuture<String> showCalculationMarkdown, String localeCode) {
        showCalculationMarkdown.thenAccept(response -> {
            sendCalcResponse(emitter, localeCode, response);
        }).exceptionally(ex -> {
            log.error("Error in calculation result: {}", ex.getMessage(), ex);
            return null;
        });
    }

    private void sendCalcResponse(ResponseEmitter emitter, String localeCode, String response) {
        if (!StringUtils.isEmpty(response)) {
            try {
                List<ConversationalReportingResponseComponent> markdownList = buildExpandableResponse(response, localeCode);
                log.debug("Send Calculation is in progress and data is: {}", markdownList);
                emitter.sendData(new ConversationalReportingResponse(markdownList));
            } catch (Exception e) {
                log.error("Error processing calculation result: {}", e.getMessage(), e);
            }
        }
    }

    private List<ConversationalReportingResponseComponent> buildExpandableResponse(String calculationResult, String localeCode) throws IOException, IOException {
        List<ConversationalReportingResponseComponent> markdownList = new ArrayList<>();

        String additionalInformation = isLocalizationEnabled()
                ? localizationService.getAdditionalInformationHeader(Objects.toString(localeCode, ""))
                : ConversationalReportingConstants.EXPANDABLE_TITLE_DATA;

        ExpandableResultItem expandableResponse = new ExpandableResultItem();
        expandableResponse.setInitialState(ConversationalReportingConstants.EXPANDABLE_INITIAL_STATE);
        expandableResponse.setTitle(new ConversationalReportingResponseMarkdown<>(ConversationalReportingConstants.EXPANDABLE_TITLE_TYPE,
                additionalInformation));

        List<ConversationalReportingResponseComponent> resultList = new ArrayList<>();
        resultList.add(new ConversationalReportingResponseMarkdown<>(ConversationalReportingConstants.EXPANDABLE_RESULT_TYPE, calculationResult));
        expandableResponse.setResults(resultList);

        String jsonString = JsonParsingUtil.writeValueAsString(expandableResponse);
        markdownList.add(new ConversationalReportingResponseMarkdown<>(ConversationalReportingConstants.EXPANDABLE_TYPE, JsonParsingUtil.readTree(jsonString)));
        return markdownList;
    }

    private boolean isNoDataMessageEnabled(String tmsTenantId) {
        return featureFlagService.isFeatureEnabled(FeatureFlags.NO_DATA_MESSAGE_ENABLED, LaunchDarklyUserContextAttribute.TENANT_ID.getValue(), tmsTenantId);
    }

    private boolean isShowCalculationEnabled(String tmsTenantId) {
        return featureFlagService.isFeatureEnabled(FeatureFlags.SHOW_CALCULATION_ENABLED, LaunchDarklyUserContextAttribute.TENANT_ID.getValue(), tmsTenantId);
    }

    private boolean isLocalizationEnabled() {
        return featureFlagService.isFeatureEnabled(FeatureFlags.LOCALIZATION_ENABLED);
    }
}

Solution -> Disagreements can sometimes arise between coworkers and management. If the disagreement is with a senior colleague, I try to understand their point of view and identify any flaws in my approach to implementing a feature, as there is a reason they hold a senior position. However, if I still find the outcome unconvincing, I discuss it with my team lead.

If the issue is with my team lead — for example, if I was not given due credit for my work — I reach out to the dedicated managers responsible for employee well-being.

Question 2-> Can you please talk about your strengths and weaknesses?

Strength -> 1) Self Improvement -> I am always willing to improve in all aspects by taking constructive criticism and trying to learn new things, professionally and in personal space as well.

2) I am self-aware -> I acknowledge my weaknesses and work on improving them.

3) I am highly productive most days -> I manage to finish my work before the deadline and focus on my physical health and social well-being.

4) I am very good at problem-solving skills.

Weakness->

1. Delegation-> I am not very good at delegation work given to me, I try to finish on my own as I want to control all aspects of that feature or enhancement. I am actively improving In it through taking management courses.
2. Giving an estimate of how much time will it take.

Question 3-> What made you want to work for us?

• > JAVA development.
• single person doing all the work
• > learning curve is much better for faster growth.
• > will be able to work with a vast spectrum of technologies.

Question 4-> What does success mean to you?

> stable job

> good work culture.

>Efforts are recognized.

> financial, physical and mental satisfaction.

Question 5-> How do you prioritize work for your team and yourself?

> The tasks given to us are divided into priority groups.

Question 6-> Long-term goals?

> working on a product that we are building from scratch.

> Learning new high-end and new in-market technologies.

> leading a team.

> And becoming a reliable developer, where I have knowledge of full stack , devops.

Interview Questions:-

1. How are RestAPI Stateless?

Statefull -> stores Client information on their server.

Instead, each request made by the client must have all the required information (like username and pass). This is called Stateless architecture.

2. Explain HTTP methods:-

3. Explain the HTTP status code:-

4. What is URI?

5. What are the best practices in making the URI for RESTFul Web Services?

6. What is the difference between Rest and Soap Architecture?

7. What are the tools to test and develop Rest APIs?

POSTMAN

8. PROS and CONS of REST APIs:-

9. What are the core components of HTTP response?

Status codes indicate the success or failure of the request like 200 is for success, 400 is for client-side error and 500 is for server-side error.

HTTP version indicates the version of HTTP we are using.

The response Header contains response metadata like content type, content length, date etc.

Response Body which contains the return data.

The response should always have a response body.

S- single responsibility principle

O- Open/Close Principle

L- Liskov Substitution Principle

I- Interface Segmented Principle

D- Dependency Inversion Principle

The invoice class does not follow the single responsibility principle because it has more than reason to change. 3 reasons to change.

Correct way is →

the wrong way to add a feature as we should not modify the live class we should extend it.

Not behaving according to the Liskov principle as it is breaking the behaviour of the parent class.

wrong way

khaali vhi method define kr rha hai jo iske mtlb ke hai.

these are concrete classes (wrong way)

Correct way.

// how to solve Liskov problem.

this will create problem. As the hasEngine() function in parent class is not expecting return type null.

Solution would be to use function in parent class which are generic and common to all the child classes.

Now this will not give us any sort of error.

Single Responsibility Principle:-

Wrong way:-

class marker{

        public String color;
        public int size;
        public int prize;
        marker(String color,int size,int prize){
            this.color=color;
            this.prize=prize;
            this.size=size;
        }
    }

    class Invoice{
        marker mkr;
        int quantity;
        Invoice(marker mkr,int quantity){
            this.mkr=mkr;
            this.quantity=quantity;
        }

        public int calculate(marker mkr,int quantity){
            return mkr.prize*quantity;
        }

        public void saveToDB(){
        // saving to DB -> instead of this create a seperate dao class

        }

        public void print(){

        // printing the Invoice

        }
    }

Correct way:-

class marker{

        public String color;
        public int size;
        public int prize;
        marker(String color,int size,int prize){
            this.color=color;
            this.prize=prize;
            this.size=size;
        }
    }

    class Invoice{
        marker mkr;
        int quantity;
        Invoice2(marker mkr,int quantity){
            this.mkr=mkr;
            this.quantity=quantity;
        }

        public int calculate(marker mkr,int quantity){
            return mkr.prize*quantity;
        }
    }

    class InvoiceDao{
        Invoice inv;

        InvoiceDao(Invoice inv){
            this.inv=inv;
        }

        public void saveToDB(){

        }
    }

    class InvoicePrint{
        Invoice inv;
        InvoicePrint(Invoice inv){
            this.inv=inv;
        }

        public void PrintDB(){
            
        }

    }

O- Open/Close Principle

Wrong ways:-

// before modification

class InvoiceDao{
        Invoice inv;

        InvoiceDao(Invoice inv){
            this.inv=inv;
        }

        public void saveToDB(){

        }
    }


// after adding new SaveTOfile feature  (modifying same class)

class InvoiceDao{
        Invoice inv;

        InvoiceDao(Invoice inv){
            this.inv=inv;
        }

        public void saveToDB(){

        }
        public void saveToFile(){
        }
    }

Correct way:-

// before modification
class InvoiceDao{
        Invoice inv;

        InvoiceDao(Invoice inv){
            this.inv=inv;
        }

        public void saveToDB(){

        }
    }



// after modification

interface InvoiceDao{
        public void save(Invoice2 inv);
    }

    class saveToDB implements InvoiceDao{

    
        @Override
        public void save(Invoice2 inv) {
            
        }

    }

    class saveToFile implements InvoiceDao{
        @Override
        public void save(Invoice2 inv) {
            
        }
    }

D- Dependency Inversion Principle

wrong ways:-

class manager{


        public void manageDeveloper(Developer dev){

        }
        public void manageTester(Tester tr){
        }
    }


    class Developer{

    }
    
    class Tester{

    }

If we want to add a new kind of role then we need to update the manager class as well(a new function needs to be written).

Correct way:-

class manager{


        public void manageEmployee(Employee employee){

        }
        
    }

    public interface Employee {
    
        
    }
    class Developer implements Employee{

    }
    
    class Tester implements Employee{

    }

It is the ability of a CPU to execute multiple threads independently at the same time but share the process resources simultaneously. Its main purpose is to provide simultaneous execution of multiple threads to utilize the CPU time as much as possible. It is a Java feature where one can subdivide the specific program into two or more threads to make the execution of the program fast and easy.

2. What is the difference between run() and start() ?

start()- > new thread is created + run()

start(): In simple words, the start() method is used to start or begin the execution of a newly created thread. When the start() method is called, a new thread is created and this newly created thread executes the task that is kept in the run() method. One can call the start() method only once.

run(): In simple words, the run() method is used to start or begin the execution of the same thread. When the run() method is called, no new thread is created as in the case of the start() method. This method is executed by the current thread. One can call the run() method multiple times.

3. What is Thread in Java?

Threads are basically the lightweight and smallest unit of processing that can be managed independently by a scheduler. Threads are referred to as parts of a process that simply let a program execute efficiently with other parts or threads of the process at the same time.

4. What are the two ways of implementing thread in Java?

There are basically two ways of implementing thread in java as given below:-

a. Extending the Thread class

b. Implementing Runnable interface in Java

5. What’s the difference between thread and process?

6. What’s the difference between class lock and object lock?

Object Lock:

• Locks a specific object (instance) of a class.
• When a thread holds the object lock, other threads can’t access synchronized instance methods on the same object.

public class MyClass {
    public synchronized void instanceMethod() {
        // Only one thread can access this method per object
    }
}

Class Lock:

• Locks the entire class, not just one instance.
• When a thread holds the class lock, no thread can access synchronized static methods across all instances.

public class MyClass {
    public static synchronized void staticMethod() {
        // Only one thread can access this method for the entire class
    }
}

Key Difference:

• Object Lock: For instance methods, locks per object.
• Class Lock: For static methods, locks the entire class.

7. What are the wait() and sleep() methods?

wait(): As the name suggests, it is a non-static method that causes the current thread to wait and go to sleep until some other threads call the notify () or notifyAll() method for the object’s monitor (lock). It simply releases the lock and is mostly used for inter-thread communication. It is defined in the object class, and should only be called from a synchronized context.

sleep(): As the name suggests, it is a static method that pauses or stops the execution of the current thread for some specified period. It doesn’t release the lock while waiting and is mostly used to introduce a pause on execution. It is defined in the thread class, and no need to call from a synchronized context.

8. Difference between Notify() and NotifyAll();

9. What is Runnable and Callable Interface? Write the difference between them.

Both interfaces are generally used to encapsulate tasks that are needed to be executed by another thread.

Running Interface: This interface is basically available in Java right from the beginning. It is simply used to execute code on a concurrent thread.
Callable Interface: This interface is basically a new one that was introduced as a part of the concurrency package. It addresses the limitation of runnable interfaces along with some major changes like generics, enum, static imports, variable argument methods, etc. It uses generics to define the return type of object.

10. Name the method that is used to register a thread in a thread scheduler.

Ans-> start()

11. What is Thread pool ?

A Thread pool is simply a collection of pre-initialized or worker threads at the start-up that can be used to execute tasks and put back in the pool when completed. It is referred to as pool threads in which a group of fixed-size threads is created. By reducing the number of application threads and managing their lifecycle, one can mitigate the issue of performance using a thread pool. Using threads, performance can be enhanced and better system stability can occur. To create the thread pools, java.util.concurrent.Executors class usually provides factory methods.

12. DeadLock Example ?

13. Explain volatile variables in Java?

This keyword cannot be used with classes and methods, instead can be used with variables. It is simply used to achieve thread-safety. If you mark any variable as volatile, then all the threads can read its value directly from the main memory rather than CPU cache, so that each thread can get an updated value of the variable.

14. How do threads communicate with each other?

Threads can communicate using three methods i.e., wait(), notify(), and notifyAll().

15. Can two threads execute two methods (static and non-static concurrently)?

Yes, it is possible. If both the threads acquire locks on different objects, then they can execute concurrently without any problem

16. What is the purpose of the finalize() method?

The finalize () method is a method of Object class specially used to perform cleanup operations on unmanaged resources just before garbage collection. It is not at all intended to be called a normal method. After the complete execution of the finalize() method, the object gets destroyed automatically.

17. What is ConcurrentHashMap and Hashtable? In Java, why is ConcurrentHashMap considered faster than Hashtable?

ConcuurentHashMap:- Does not lock whole map(Avoids read locks)

HashTable:- Locks whole HashMap.

ConcurrentHashMap: it allows concurrent read and write operations to the map. It only locks a certain portion of the map while doing iteration to provide thread safety so that other readers can still have access to the map without waiting for iteration to complete.

Hashtable: It does not provide any lock-free read, unlike ConcurrentHashMap. It just locks the entire map while doing iteration.

ConcurrentHashMap and Hashtable, both are thread-safe but ConcurrentHashMap generally avoids read locks and improves performance, unlike Hashtable. ConcurrentHashMap also provides lock-free reads, unlike Hashtable. Therefore, ConcurrentHashMap is considered faster than Hashtable especially when the number of readers is more as compared to the number of writers.

18. What is Thread Starvation?

Thread starvation is basically a situation or condition where a thread won’t be able to have regular access to shared resources and therefore is unable to proceed or make progress. This is because other threads have high priority and occupy the resources for too long. This usually happens with low-priority threads that do not get CPU for its execution to carry on.

19. What is Livelock? What happens when it occurs?

Similar to deadlock, livelock is also another concurrency problem. In this case, the state of threads changes between one another without making any progress. Threads are not blocked but their execution is stopped due to the unavailability of resources.

20. Can you start a thread twice?

No, it’s not at all possible to restart a thread once a thread gets started and completes its execution. Thread only runs once and if you try to run it for a second time, then it will throw a runtime exception i.e., java.lang.IllegalThreadStateException.

21. What is context switching ?

It is referred to as switching of CPU from one thread or process to another one. It allows multiple processes to share the same CPU. In context switching, the state of thread or process is stored so that the execution of the thread can be resumed later if required.

22. What are Cyclic Barrier and CountDown Latch?

Both are required for managing multithreaded programming.

CountDownLatch -

a. Enables main threads to wait until mandatory operations are performed and completed by other threads.

b. It makes sure that a thread waits until the execution in another thread is complete before it starts its execution.

c. One cannot reuse the same CountDownLatch once the count reaches 0.

Cyclic Barrier-

a. A CyclicBarrier in Java is a synchronization aid that allows a set of threads to all wait for each other to reach a common barrier point. It’s useful when you want to coordinate actions across multiple threads. Once all threads have reached the barrier, they are allowed to proceed.

b. Unlike CountDownLatch, a CyclicBarrier can be reused after the waiting threads are released.

23 . What is Thread Scheduler and Time Slicing?

Thread Scheduler: It is a component of JVM that is used to decide which thread will execute next if multiple threads are waiting to get the chance of execution. By looking at the priority assigned to each thread that is READY, the thread scheduler selects the next run to execute. To schedule the threads, it mainly uses two mechanisms: Preemptive Scheduling and Time slicing scheduling.

Time Slicing: It is especially used to divide CPU time and allocate them to active threads. In this, each thread will get a predefined slice of time to execute. When the time expires, a particular thread has to wait till other threads get their chances to use their time in a round-robin fashion. Every running thread will get executed for a fixed time period.

24. What is a shutdown hook?

A shutdown hook is simply a thread that is invoked implicitly before JVM shuts down. It is one of the most important features of JVM because it provides the capacity to do resource cleanup or save the application state when JVM shuts down. By calling the halt(int) method of the Runtime class, the shutdown hook can be stopped. Using the following method, one can add a shutdown hook.

25. What is busy spinning?

26 . What will happen if we don’t override the thread class run() method?Nothing will happen as such if we don’t override the run() method. The compiler will not show any error. It will execute the run() method of the thread class and we will just don’t get any output because the run() method is with an empty implementation.

27. Is it possible to call the run() method directly to start a new thread?

No, it’s not possible at all. You need to call the start method to create a new thread otherwise run method won’t create a new thread. Instead, it will execute in the current thread.

28. Is it possible that each thread can have its stack in multithreaded programming?

Of course, it is possible. In multithreaded programming, each thread maintains its own separate stack area in memory because of which every thread is independent of each other rather than dependent.

29. What is the synchronization process? Why use it?

Synchronization is basically a process in Java that enables a simple strategy for avoiding thread interference and memory consistency errors. This process makes sure that resources will be only used one thread at a time when one thread tries to access a shared resource. It can be achieved in three different ways as given below:

• The synchronized method
• By synchronized block
• By static synchronization

30. What is the lock interface? Why is it better to use a lock interface rather than a synchronized block.?

The Lock interface in Java, introduced in Java 5 as part of the java.util.concurrent.locks package, provides a more flexible and sophisticated locking mechanism compared to the traditional synchronized blocks or methods. It offers greater control over lock acquisition and release and allows features that synchronized blocks can't provide.

Key Methods of the Lock Interface:

1. lock(): Acquires the lock if it is available. If not, it waits until the lock is released.
2. unlock(): Releases the lock.

31. What is a semaphore?

A lock with several permits. A classical lock can give access to the block of code it protects to only one thread at a time. A semaphore can give access to several threads. You can create a semaphore by giving it a number of permits then you can use it to protect a block of code, the thread needs the permit to execute the protected code. And if there is none available, then it blocks until there is one.Dont forget to release your permit in a finally block. Semaphores are useful when you need to limit the number of threads that can excess the external resource.

Semaphore is regarded as a thread synchronization construct that is usually required to control and manage the access to the shared resource using counters. It simply sets the limit of the thread. Can be used to send signals between threads to avoid missed signals or to guard critical sections.

32. Explain Thread Priority

Thread priority simply means that threads with the highest priority will get a chance for execution prior to low-priority threads. One can specify the priority but it’s not necessary that the highest priority thread will get executed before the lower-priority thread. The thread scheduler assigns the processor to the thread on the basis of thread priority. The range of priority changes between 1–10 from lowest priority to highest priority.

33. What is synchronized method and synchronized block? Which one should be preferred?

In Java, both synchronized methods and synchronized blocks are used to control access to critical sections of code in a multithreaded environment, ensuring that only one thread can execute a block of code at a time for a specific object or class. However, they differ in terms of granularity, flexibility, and performance.

1. Synchronized Method:

A synchronized method locks the entire method, allowing only one thread at a time to execute it on a given object instance (for instance methods) or on the class (for static methods). It can be applied by adding the synchronized keyword to the method declaration.

public synchronized void performTask() {
    // Critical section: Only one thread can execute this method at a time
    System.out.println(Thread.currentThread().getName() + " is performing task.");
}

2. Synchronized Block:

A synchronized block provides more fine-grained control over synchronization. Instead of locking the entire method, you can lock only a part of it. This allows more flexibility, as you can synchronize only the critical section of the code that needs protection, leaving other parts of the method to be executed by multiple threads concurrently.

public void performTask() {
    System.out.println(Thread.currentThread().getName() + " is performing task.");

    synchronized (this) { // Only this block is synchronized
        // Critical section: Only one thread can execute this block at a time
        System.out.println(Thread.currentThread().getName() + " is in synchronized block.");
    }

    System.out.println(Thread.currentThread().getName() + " is continuing task.");
}

34. What is busy spinning?

Busy spinning (or busy waiting) is a technique where a thread continuously checks a condition in a loop without releasing the CPU. It wastes CPU resources as the thread consumes cycles while waiting, instead of sleeping or being blocked.

When to use:

• Low-latency critical sections.
• When the expected wait time is extremely short.

Downsides:

• Wastes CPU cycles and energy.
• Not scalable, inefficient for longer waits.

35. Can we Overload run() method?

Yes, it is possible to overload run() by passing parameters to it and also keeping a check over to comment down @override from the run() method.

4. Multiple threads within the same process share the same memory space.

Shared Memory Space

• Process and Threads: A process is an instance of a running program and has its own memory space (address space). Threads, on the other hand, are smaller units of execution that belong to a process.
• Threads within a Process: All threads within the same process share the same memory space, which includes:
• Heap memory: Where dynamically allocated objects live. For example, if one thread allocates memory on the heap, another thread can access it.
• Global variables: Any global variables declared in the program are accessible by all threads.
• Static variables: Similarly, static variables (variables defined with static keywords) are shared among threads.

Example:-

public class SharedMemoryExample {
    private static int count = 0;

    public static void main(String[] args) {
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                count++;  // Shared memory access
            }
        });

        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                count++;  // Shared memory access
            }
        });

        t1.start();
        t2.start();

        // Wait for both threads to finish
        try {
            t1.join();
            t2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("Final count is: " + count);
    }
}

Synchronization Needed: Sharing memory between threads requires careful synchronization, especially when multiple threads modify the same data. Without synchronization, it can lead to race conditions, where the outcome depends on the timing of thread execution.

Thread-local Storage (Separate Memory)

Even though threads share memory space, they also have their own private memory.

ThreadLocal is a class in Java used to create variables that are local to a thread. Each thread accessing such a variable has its own, independent copy. It helps avoid synchronization and can be useful in scenarios where each thread needs its own state or data that is not shared with others.

Stack: Each thread has its own stack memory for local variables and method calls. So, two threads can call the same method and have their own local variables without interference.

For example, two threads may both call a function, but their local variables are stored separately on their respective stacks.

5. Why MultiThreading?

To properly utilize multi-core CPUs.

6. What is Thread?

A thread is an independent sequential path of execution with a program.

5. Daemon thread

A daemon thread in Java (and in many other programming environments) is a special type of thread that runs in the background and does not prevent the JVM (Java Virtual Machine) from exiting when all the user (non-daemon) threads finish execution.

Key Characteristics of Daemon Threads:

1. Background Threads: Daemon threads are typically used to perform background tasks that support the running of the program, such as garbage collection, monitoring, or waiting for events to happen.
2. No JVM Blocking: The JVM does not wait for daemon threads to finish before exiting. When all user threads complete, the JVM will terminate, and all daemon threads will be abruptly stopped, even if they are in the middle of execution.
3. Examples in Java:

• Garbage Collector: The garbage collection thread is a daemon thread. It runs in the background to free memory that is no longer used by the application.
• Other System Tasks: Any thread that performs maintenance tasks, like cleaning up resources or monitoring, is typically implemented as a daemon thread.

How to Create a Daemon Thread in Java:-

public class DaemonThreadExample {
    public static void main(String[] args) {
        Thread daemonThread = new Thread(() -> {
            while (true) {
                System.out.println("Daemon thread running...");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

        // Set the thread as a daemon
        daemonThread.setDaemon(true);
        
        daemonThread.start();
        
        // Main thread sleeps for 3 seconds, after which the JVM will exit
        // Daemon thread will not prevent the JVM from exiting
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        
        System.out.println("Main thread finished, JVM will exit now.");
    }
}

Daemon thread running...
Daemon thread running...
Daemon thread running...
Main thread finished, JVM will exit now.

Differences Between User Threads and Daemon Threads:

JVM Behavior:

• User threads keep the JVM running until they finish.
• Daemon threads do not prevent the JVM from exiting.

Lifecycle:

• Daemon threads can be terminated by the JVM abruptly when no user threads are running.
• User threads complete their execution normally unless explicitly terminated.

Typical Use Cases:

• Daemon threads are typically used for background tasks that do not affect the core logic of the application (e.g., logging, system monitoring, garbage collection).
• User threads are meant for the primary logic of the application.

When to Use Daemon Threads:

• Daemon threads are useful when you need continuous background processing but don’t want those tasks to block the program from exiting. However, you need to be cautious when using them, as they can be terminated abruptly, potentially leaving tasks incomplete.

6. Thread Creation.

7. Synchronization ()

Synchronization is a mechanism that ensures that only one thread can access a shared resource at a time. This is particularly useful when multiple threads try to modify or access shared data concurrently, preventing inconsistent results or corrupted data.

Java provides various ways to synchronize threads:

1. Synchronized Methods — Synchronize a method so that only one thread can execute it at a time.
2. Synchronized Blocks — Synchronize a block of code within a method.
3. Static Synchronization — Used for static methods.

class Counter {
    private int count = 0;

    // Synchronized method to ensure thread safety
    public synchronized void increment() {
        count++;
    }

    public int getCount() {
        return count;
    }
}

class MyThread extends Thread {
    Counter counter;

    MyThread(Counter counter) {
        this.counter = counter;
    }

    public void run() {
        for (int i = 0; i < 1000; i++) {
            counter.increment();
        }
    }
}

public class Main {
    public static void main(String[] args) throws InterruptedException {
        Counter counter = new Counter();

        // Creating two threads that will work on the same counter object
        MyThread t1 = new MyThread(counter);
        MyThread t2 = new MyThread(counter);

        // Start both threads
        t1.start();
        t2.start();

        // Wait for both threads to finish
        t1.join();
        t2.join();

        // Output the final count value
        System.out.println("Final count: " + counter.getCount());
    }
}

In the above case instance of a class, it acts as a lock which is the same for all the functions.

We can make any object a lock;

8. Thread Safety

Thread safety in Java refers to the concept of ensuring that shared data or resources are accessed by multiple threads without causing concurrency issues, such as race conditions, inconsistent data, or unpredictable results. A class or method is said to be thread-safe if it behaves correctly when accessed by multiple threads simultaneously.

ThreadLocal<Integer> threadLocalValue = new ThreadLocal<>();
threadLocalValue.set(100);  // Each thread has its own copy

9. Wait() and NotifyAll() and Notify()

wait() and notifyAll() (along with notify()) are methods used to coordinate the execution of threads. These methods are part of the Object class and are typically used when multiple threads need to communicate with each other, especially in producer-consumer type problems.

Concepts of wait() and notifyAll():

wait():

• When a thread calls wait() on an object, it enters the waiting state and releases the intrinsic lock (monitor) it holds on that object.
• The thread stays in this state until another thread calls notify() or notifyAll() on the same object.
• The wait() method must be called within a synchronized block or method, otherwise, it will throw an IllegalMonitorStateException.

notifyAll():

• When a thread calls notifyAll() on an object, it wakes up all the threads that are waiting on that object’s monitor.
• The threads that are notified will not resume until they can reacquire the lock on the object.
• Only one thread will proceed to execute the synchronized block, while the others will continue waiting.

notify():

• Similar to notifyAll(), but only one thread waiting on the object’s monitor will be notified.

Example: Producer-Consumer with wait() and notifyAll()

import java.util.LinkedList;
import java.util.Queue;

class Buffer {
    private Queue<Integer> queue = new LinkedList<>();
    private int capacity = 5; // Maximum capacity of the buffer

    // Producer adds an item to the buffer
    public synchronized void produce(int value) throws InterruptedException {
        while (queue.size() == capacity) {
            System.out.println("Buffer is full. Producer is waiting...");
            wait(); // Wait until space is available
        }
        queue.add(value);
        System.out.println("Produced: " + value);
        notifyAll(); // Notify all consumers that new data is available
    }

    // Consumer removes an item from the buffer
    public synchronized int consume() throws InterruptedException {
        while (queue.isEmpty()) {
            System.out.println("Buffer is empty. Consumer is waiting...");
            wait(); // Wait until data is available
        }
        int value = queue.poll();
        System.out.println("Consumed: " + value);
        notifyAll(); // Notify the producer that space is available
        return value;
    }
}

class Producer extends Thread {
    private Buffer buffer;

    Producer(Buffer buffer) {
        this.buffer = buffer;
    }

    public void run() {
        try {
            int value = 0;
            while (true) {
                buffer.produce(value++);
                Thread.sleep(1000); // Simulating time taken to produce
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

class Consumer extends Thread {
    private Buffer buffer;

    Consumer(Buffer buffer) {
        this.buffer = buffer;
    }

    public void run() {
        try {
            while (true) {
                buffer.consume();
                Thread.sleep(1500); // Simulating time taken to consume
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

public class Main {
    public static void main(String[] args) {
        Buffer buffer = new Buffer();

        // Create one producer and one consumer thread
        Producer producer = new Producer(buffer);
        Consumer consumer = new Consumer(buffer);

        producer.start();
        consumer.start();
    }
}

10. Thread States

+-------------+
|    NEW      |  -- start() -->  +-------------+
+-------------+                  |  RUNNABLE   |
                                 +-------------+
                                    ^      |
                                 waiting for resources
                                    |      v
                               +-------------+
                  waiting for  |  BLOCKED    |
                    lock       +-------------+
                                    |
                                    v
                                +-------------+
          notify() or join()    |   WAITING   |
              or timeout        +-------------+
                                    |  Timeout or notify()
                                    v
                                +-------------+
                                | TIMED_WAITING|
                                +-------------+
                                    |
                                    v
                               +-------------+
                               | TERMINATED  |
                               +-------------+

Explanation of Transitions:

1. NEW to RUNNABLE: When the thread is started using the start() method.
2. RUNNABLE to BLOCKED: When a thread tries to enter a synchronized block or method but another thread is already holding the lock.
3. RUNNABLE to WAITING: When a thread calls Object.wait() or Thread.join() on another thread without a timeout.
4. RUNNABLE to TIMED_WAITING: When a thread calls methods like sleep(), join(long timeout), or wait(long timeout).
5. WAITING/TIMED_WAITING to RUNNABLE: When the waiting time has expired, or another thread calls notify(), notifyAll(), or the join() finishes.
6. RUNNABLE to TERMINATED: When the thread completes its execution, either naturally or due to an uncaught exception.

11. Yield();

• yield() is a method in Java’s Thread class that suggests to the thread scheduler that the current thread is willing to yield its current CPU usage to give other threads a chance to run.
• When a thread calls yield(), it transitions from the Running state back to the Runnable state, allowing other threads of equal or higher priority to execute.
• It’s important to note that yield() does not guarantee that the current thread will stop executing immediately. It is merely a hint to the scheduler, and the actual behaviour depends on the thread scheduler (which is platform-dependent).

class MyThread extends Thread {
    public void run() {
        for (int i = 1; i <= 5; i++) {
            System.out.println(Thread.currentThread().getName() + " is running: " + i);
            Thread.yield(); // Suggests yielding the CPU to other threads
        }
    }
}

public class Main {
    public static void main(String[] args) {
        MyThread t1 = new MyThread();
        MyThread t2 = new MyThread();

        t1.start(); // t1 starts and enters the RUNNABLE state
        t2.start(); // t2 starts and enters the RUNNABLE state
    }
}

12. TimeOut (wait has two either the condition is met or timeout but In Join only looks for timeout)

Timeout refers to setting a maximum waiting time for certain operations or threads.

Purpose:

Timeouts help avoid indefinite blocking, ensuring that threads or operations don’t wait forever, improving performance and preventing deadlocks.

• Thread Join Timeout (join(long millis)):
• A thread waits for another to finish but only for the specified time.
• Example: t.join(1000); // Waits for 1 second.
• Object Wait Timeout (wait(long timeout)):
• A thread waits for a condition to be met but stops waiting after the timeout.
• Example: wait(2000); // Waits for 2 seconds.

13. Interrupted

Interruption refers to a mechanism that allows one thread to signal another thread that it should stop what it’s doing, often used to handle cooperative thread termination or to break out of blocking operations like sleep(), wait(), or join().

When a thread is interrupted, it doesn’t stop immediately; instead, it sets an internal flag (interrupted status), and it’s up to the thread to check this flag and respond appropriately.

Thread t = new Thread(() -> {
    try {
        Thread.sleep(5000); // Sleeping for 5 seconds
    } catch (InterruptedException e) {
        System.out.println("Thread was interrupted during sleep.");
    }
});

t.start();
t.interrupt(); // Interrupts the thread while it's sleeping

14. Join and isAlive

join will make the main method to wait until t1 and t2 are done

before Join:-

After Join:-

15. Thread Priority

16. Time Scheduler

In Preemptive, priority is given to high-priority threads while scheduling the execution of threads.

17. Dead Lock:-

public class deadlock {
    public static void main(String[] args) {

        String lock1="Gandharv";
        String lock2="Dalal";

        Thread t1=new Thread(()->{
            synchronized(lock1){
                try {
                    Thread.sleep(1);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                synchronized(lock2){
                    System.out.println("Hey !!");
                }
            }
        });

        Thread t2=new Thread(()->{
            synchronized(lock2){
                try {
                    Thread.sleep(1);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                synchronized(lock1){
                    System.out.println("Hey2 !!");
                }
            }
        });

        t1.start(); t2.start();
    }
}

List<Integer>list=Arrays.asList(1,4,5,6,7,8);

Optional<Integer> sum=list.stream().reduce((a,b)->a+b);

System.out.println("Sum of numbers : "+ sum.get());

2. Print the Average of All Numbers

List<Integer>list=Arrays.asList(1,4,5,6,7,8);

double avg=list.stream().mapToInt(e->e).average().getAsDouble();

System.out.println("Sum of numbers : "+ avg);

3. Print Square, filter and Average of Numbers

List<Integer>list=Arrays.asList(1,4,5,6,7,8);

double avg=list.stream().map(e->e*e).filter(e->e>100).mapToInt(e->e).average().getAsDouble();

System.out.println("Sum of numbers : "+ avg);

4. Print Even & Odd Numbers Using Stream

List<Integer>list=Arrays.asList(1,4,5,6,7,8);

List<Integer>ans=list.stream().filter(e->e%2==0).collect(Collectors.toList());

System.out.println(ans);

5. Print Numbers Starts With Prefix 2 using Streams

List<Integer>list=Arrays.asList(1,4,5,6,7,8);

List<Integer>ans=list.stream().map(e->String.valueOf(e)).filter(e->e.startsWith("2")).map(Integer::valueOf).collect(Collectors.toList());

6. Print Duplicate Numbers using Stream

List<Integer>list=Arrays.asList(1,4,5,6,7,8);

Set<Integer>dup= list.stream().filter(e->Collections.frequency(list,e)>1).collect(Collectors.toSet());

// methode 2

Set<Integer>dupNum=new HashSet<Integer>();
Set<Integer>dup=list.stream().filter(e->!dupNum(e)).collect(Collectors.toSet());

7. Find Max and Min Numbers using Stream

List<Integer>list=Arrays.asList(1,4,5,6,7,8);

int max=list.stream().max(Comparator.comparing(Integer::valueOf)).get();
int min=list.stream().min(Comparator.comparing(Integer::valueOf)).get();

8. Sort Numbers

List<Integer>list=Arrays.asList(1,4,5,6,7,8);

// ascending order

List<Integer>sortedList=list.stream().sorted().collect(Collectors.toList());

// Descending Order

List<Integer>sortedList=list.stream().sorted(Collections.reverseOrder()).collect(Collectors.toList()));

9. Get/ignore the first 5 numbers using Limit & Skip in Streams

List<Integer>list=Arrays.asList(1,4,5,6,7,8);

List<Integer>l=List.stream().limit(5).collect(Collectors.toList());

int sum=List.stream().limit(5).reduce((p,q)->p+q).get();

List<Integer>sk=list.stream().skip(5).collect(Collectors.toList());

int ans=list.stream().skip(5).reduce((a,b)->a+b).get();

10. Get the Second Highest/Lowest Number using Streams

List<Integer>list=Arrays.asList(1,4,5,6,7,8);

// sec highest
int secH=list.stream().sorted(Collections.reverseOrder()).distict().limit(2).skip(1).findFirst().get();

// sec highest

int secH=list.stream().sorted(Collections.reverseOrder()).distinct().skip(1).findFirst().get();


// sec Lowest

int secL=list.stream().sorted().distinct().skip(1).findFirst().get();

Stream<Integer>stream=list.stream();

String[] str={"abc","yobwf","iewbc","bidwk"};
Stream<Integer>stream=Stream.of(str);

stream.forEach(e->System.out.println(e));

What is maven? (Pom.xml)

Build automation tools and manage dependencies.

you can find all the libraries and dependencies in the Maven repository.

Maven has defined the build lifecycle.

mvn verify

//In a build environment, use the following call to cleanly build and deploy artifacts into the shared repository.
mvn clean deploy

ye saari commands maven wrapper see chlti hai.

Mvn compile se src code compile ho jata hai target folder me.

Mvn install se local repository me .m2 ki folder hoti hai vha iski jar chli jaaygi.

MVN clean se target folder ki saari cheese ud jaayngi.

Structure of Spring Boot Application:-

gitignore is the list of files which we have to ignore while committing to the github.

Plugin will help you convert your code into jar.

what is repackaging in spring boot ?

In Spring Boot, repackaging refers to the process of transforming the built JAR or WAR file into an executable JAR file. This executable JAR contains all the necessary dependencies and can be run directly using the java -jar command.

Lecture 6:-

Object c=new Object();

through this we are creating object on our own. But In spring we can give the control of creating of object to spring . Hence Inversion of control.

Now, the person will go to the IOC container(spring) and the container will bring us the object.

IOC container is a box that has all the classes (objects ) made in the project.

Application context is a way to implement an IOC container.

How does IOC container get all the classes ?

It scans through the project (all classes ) and the classes which have @component annotations

get stored in the IOC (Not all classes get stored).

Bean is just an object in terms of spring. In other words, the object IOC have is called Bean.

After Bean is created we can use it through IOC without creating it again.

What is @SpringBootApplication ?

Only on Main class (only 1 in whole project).

@componentScan just scans through whole projects for Components. (This can not scan beyond its base package).

@EnableAutoConfiguration is an annotation in Spring Boot that helps in the automatic configuration of the Spring application context. It tells Spring Boot to automatically configure the necessary beans and settings based on the dependencies present in the classpath.

@RestController = @Component + Something else (specialised version of component )

@Autowired is used for dependency Injection.

In this Car is dependent on Dog which we get through IOC. So Autowired is used when we want to use an object of some class in some other class without self-initiating it with a new keyword. And this is called Dependency Injection.

@Configuration:- if we write this on class then it tells the compiler that in this class we provide some configurations. (Meaning we can create Bean in that Class).

We define @Bean on functions, not on Classes.

REST API:- Representation State Transfer, Application programming interface.

REst APi ke through kissi server ke access krte hai.

Our phone communicates with the server of netflix through Rest API. Through Request and response.

Server exposes end points so that we can access them with the help HTTP verbs.

@RestController is a special kind of @component which handles HTTP requests.

The special thing is here we write endpoints with methods.

What ever we return from the end points get converted into JSON.

@RequestMapping puri class pr mapping krte hai uske bad GETMapping ke baad particular method ki mapping krte hai.

id is Request Param and {myId} is path variable.

Post is for creating a new Entry and Put is for updating the entry.

ORM — Object-relational Mapping.

JPA

Integrating MongoDB with SpringBoot:-

The controller will call the service. Service is where all our logical parts are present. The controller is where all our endpoints are present.

The service will call Repository ,which is just an interface.

This repository will extend the MongoDB Repository. And will be the point of interaction with MongoDB.

MongoDB Repository is also an Interface given by spring MongoDb. It does standard crud operations.

Above we have passed the Entity type and the ID type.

@Document tells the spring that this particular class is Mapped to MongoDb. And this class's Instance will equal the document(Row of database).

@Id states this is a unique key of the collection. (Not compulsory to give)

The Instance of the Repository gets generated and injected into the Service.

By default Document searched for Journal Entry.

In the above, we are mapping to a specific entity.

Now we have injected the Service interface for the controller class.

Make it @compent otherwise it will give null in the service class.

String ID changed to ObjectID.

Response Entity:-

The client is postman, and Tomat is the server where our application is running.

ResponseEntity is Springs inbuild Interface (Generic in nature).

LOMBOK:-

No need to write getters and setters after this.

Mastering MongoDB”-

Lambok Annotations.

@DBRef keeps the reference of the journal entries.

Acting as a foreign key.

For making do indexing.

Video 14.

— — — — — do it again after this point — — — — — — — —

@Transaction Annotation makes the method a Transaction Atomic in nature either all the operations will occur or none will happen, it will roll back to the previous state otherwise.

We have to add @EnableTransactionManagement as well on Main Class.

@Component VS @ services

we can both interchangeably but Service is used in service classes for readability it states to the new developer that here is main logic part of our application is present.

@ Value

put the values is YAML and import that in our Classes.

Will give us error

there should not be any static variable.

@PostConstruct

in added onto a method. Which will do is when ever the bean is created of that class that method gets invoked simultaneously.

— — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — —

Interview Questions:-

Application Context is just where all the beans are there.

In Spring, the ApplicationContext is a central interface that provides configuration information to the application. It is part of the Spring IoC (Inversion of Control) container, which manages the lifecycle and configuration of application components (beans).

@Component Scan is scanning other packages which @SpringBootApplication cant read.

@configuration allows us to creat Beans in the class.

XML Bean Factory is not in use anymore. Instead, we use Application Context.

In simple terms, Application Context is a child of BeanFactory and gives additional features to BeanFactory.

ApplicationContext=BeanFactory + Additional Context.

Laptop will give null because it is just a reference, not an actual object.

Setter Injection :-

Tweaking the values in SpringXML where the beans are present.

Constructor Injection:-

Create a parametrized Constructor And instead of property use constructor.

In the Case of Object references use reference (of that bean) instead of value.

We are basically wiring the reference bean to the bean where it need to be injected.

In addition, we need to initialize getters and setters as well in Dev Class.

It can be done automatically without doing it manually just by enabling auto wiring.

Here we, writing our own creation logic.

Here spring was deciding the logic of creation on its own.

— — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — —

KAFKA:-

This means it can work on different servers, and these machines will be connected.

A Kafka cluster is a group of Kafka brokers (servers where Kafka is running).

Kafka producer writes new data into the Kafka cluster.

Zookeeper tracks the health of the Kafka cluster.

Kafka connect basically is used for bringing or sending data from/to external entities and that too without writing any code.

kafka stream is the functionalities that we use for data transformation.

Data topic(container of storing particular kind of data) ke under ata hai vha partition hota hai jo hum topic ko define krte time btata hai ki kitne partition chahiye. Har ek Part. independent hota hai ek dusre see. And In partition there is a OffSet value which increaments as new record comes. And This whole data is stored in distributed log files.

Agr data bina key ke ata hai to round robin me hota hai .

Agr data ke saath key bhi bhejte hai to partitoning bhi picture me ajata hai , vo hashing krke dekhte hai kis partition me jata hai.

Retention policy — time-based and size-based.

The replication factor is no. of partitioning.

Every partition has one broker leader.

Data replicate every broker me hota hai.

ISR means In Sync Replica meaning replica sync me hai.

Lecture 1:-

Lecture 2:-

Every entity has a different “View”.

A database schema refers to the logical and visual configuration of the entire relational database.

Lecture 3:-

1 student 1 entity hoga. Baaki collection of student entity set hoga.

Lecture 4:-

Generalisation is just the opposite of specialisation.(bottom to up)

Lecture 5:-

Lecture 6:-

Lecture 7:-

Mysql, Oracle.

Reads all the types of keys from the Gate syllabus

a synthetic key generated by DBMS. Automatically get incremented. We can use it as PK.

CREATE TABLE Enrollment (
    EnrollmentID INT AUTO_INCREMENT PRIMARY KEY, -- Surrogate key
    StudentID INT NOT NULL,
    CourseID INT NOT NULL,
    EnrollmentDate DATE NOT NULL,
    FOREIGN KEY (StudentID) REFERENCES Student(StudentID)
        ON DELETE CASCADE,
    FOREIGN KEY (CourseID) REFERENCES Course(CourseID)
        ON DELETE CASCADE
);

CHATGPT IT (ABOVE)

ON delete cascade

ON delete set null

YES.

LECTURE 8:-

Yes, a foreign key can reference a column that is not the primary key in the referenced table. The foreign key does not have to reference a primary key; it can reference any unique key in the referenced table. (BUT IT SHOULD BE UNIQUE)

CREATE TABLE Employee (
    EmployeeID INT PRIMARY KEY,  -- Primary key for Employee
    Name VARCHAR(100) NOT NULL,
    Email VARCHAR(100) UNIQUE,   -- Unique email
    DepartmentCode VARCHAR(10),
    FOREIGN KEY (DepartmentCode) REFERENCES Department(DepartmentCode)  -- Foreign key referencing a unique column
);

CREATE TABLE Department (
    DepartmentCode VARCHAR(10) UNIQUE,  -- Unique but not the primary key
    DepartmentName VARCHAR(100),
    PRIMARY KEY (DepartmentCode)  -- Primary key is still DepartmentCode
);

Lecture 11 (Normalization ):-

We cannot add an IT course because no student is present for the same course.

For deletion, if we delete one particular student of the IT course(one student present in that course) then the whole Course will also get deleted from the Table.

For Updation:- if we have updated some course then we have to go through the whole table and update the whole table wherever that course is there.

Lecture 12:-

ACID PROPERTIES

Lecture 13 :-

Atomicity implementation

Lecture 14:-

Indexing

LinkedList is used as a Base pointer so that it can point to every base location of every occurrence of each Search Key.

Lecture 15:-

Example JSON

in the form of key value.

Flexible? Some attributes receive null values as well.

Higher performance cost .

Lecture 16:-

Lecture 17:-

What is clustering?

Features of Clustering:-

Lecture 18:-

Partitioning and sharding in database.

row-wise:-

column-wise:-

diff in partitioning and sharding is routing layer additional implementation we must do.

eg :-

Lecture 19:-

out of these 3 only two are achievable at one time. (In case of distributed system only). In case of single server all there can be applied.

Lecture 21:-

Master-slave architecture

A single point of failure was there.

Slaves can only perform read operations.

Good after sir, First of all thank you for this opportunity. My name is gandharv Dalal. I am currently working as a system engineer which is SDE1 basically in tcs for the last 2 years.

I am currently part of tcs Bank project . TCS BaNCS is a core banking solution that Tata Consultancy Services (TCS) developed. It is designed to cater to the needs of banks and financial institutions by providing a robust and scalable architecture that supports a wide range of banking operations.

My client is Socgen which is a France-based corporate bank. I am in the credit transfer team. Which handles the bank-to-customer transactions from Europe to Asia through different channels like swift routing, RTGS that we use in India and Target (They are nothing but protocols).

In our architecture, the System Integrator (SI) teams retrieve data from the JBoss server and process it, delivering the output in XML format. We use Java JDBC to store this data in a MySQL database, where we can perform code enhancements to address any issues or bugs that may arise on the server. Java is then used to retrieve the data from the database, converting it into objects that can be manipulated. The changes are reflected on the GUI using CSS and JavaScript. Once we confirm that everything is working correctly, we use Java to send the data back to the SI team in the form of a PAC08 message, enabling them to carry out transactions. Our application follows a microservices architecture, and I am specifically working on the Payment server.

SOAP Web Services

SOAP stands for Simple Object Access Protocol is a network platform used in a web service to exchange or communicate data between two different machines on a network. It uses the XML format of data to transfer messages over the HTTP protocol. In Web services, SOAP allows the user request to interact with other programming languages. In this way, it provides a way to communicate between applications running on different platforms (Operating system), with programming languages and technologies used in web service.

Greeting

name

designation

years of experience

graduation

current project overview and I am part of their back end payments team.