చిన్న పట్టికల కోసం

Daniel Marino

7, జనవరి 2025, మంగళవారం 2:18:47 PMకి

Redshift COPY ఆదేశాలు అకస్మాత్తుగా విఫలమైనప్పుడు

దీన్ని ఊహించండి: మీరు చాలా రోజులుగా మీ Amazon Redshift క్లస్టర్‌లో COPY ఆదేశాలను సజావుగా అమలు చేస్తున్నారు. ప్రశ్నలు వేగవంతమైనవి, సమర్థవంతమైనవి మరియు ప్రతిదీ క్లాక్‌వర్క్ లాగా పని చేస్తున్నట్లు కనిపిస్తోంది. అకస్మాత్తుగా, ఎక్కడి నుంచో, మీ కమాండ్‌లు హాంగ్ అవుతాయి, మిమ్మల్ని నిరాశపరిచాయి మరియు కలవరపరుస్తాయి. 😕

ఈ దృశ్యం అసాధారణం కాదు, ప్రత్యేకించి Redshift వంటి డేటా గిడ్డంగులతో పని చేస్తున్నప్పుడు. మీరు క్లస్టర్ కన్సోల్‌ని తనిఖీ చేసి, ప్రశ్న నడుస్తున్నట్లు చూపుతుంది. ఇంకా, వంటి సాధనాలు stv_recents మరియు PG_locks ఎటువంటి ఉపయోగకరమైన అంతర్దృష్టులను అందించదు. మీ క్వెరీ నిస్సందేహంగా, రన్ అవుతున్నప్పటికీ సరిగ్గా సమర్పించనట్లుగా ఉంది.

ఉపయోగించి ప్రక్రియను ముగించిన తర్వాత కూడా PG_TERMINATE_BACKEND మరియు క్లస్టర్‌ను రీబూట్ చేయడం వలన సమస్య కొనసాగుతుంది. ఇతర ప్రశ్నలు సరిగ్గా పని చేస్తూనే ఉన్నాయి, కానీ లోడ్ ప్రశ్నలు స్పష్టమైన కారణం లేకుండానే నిలిచిపోయినట్లు కనిపిస్తోంది. ఇది తెలిసినట్లుగా అనిపిస్తే, ఈ పోరాటంలో మీరు ఒంటరిగా లేరు.

ఈ కథనంలో, మేము అలాంటి ప్రవర్తనకు గల కారణాలను వెలికితీస్తాము మరియు చర్య తీసుకోగల పరిష్కారాలను అన్వేషిస్తాము. మీరు Redshift ప్రశ్న ఎడిటర్‌ని ఉపయోగిస్తున్నా లేదా Boto3 ద్వారా ప్రోగ్రామాటిక్‌గా యాక్సెస్ చేసినా, ఆ COPY ఆదేశాలను మళ్లీ అమలు చేయడంలో మేము మీకు సహాయం చేస్తాము. 🚀

ఆదేశం	ఉపయోగం యొక్క ఉదాహరణ
boto3.client()	ప్రాంతం మరియు సేవా రకాన్ని పేర్కొనడం ద్వారా Redshift వంటి AWS సేవలతో పరస్పర చర్య చేయడానికి Boto3 క్లయింట్‌ను ప్రారంభిస్తుంది.
redshift_client.cancel_query_execution()	దాని ClusterIdentifier మరియు QueryId ద్వారా గుర్తించబడిన Redshift క్లస్టర్‌పై అమలవుతున్న నిర్దిష్ట ప్రశ్నను రద్దు చేస్తుంది.
describe_query_executions()	రెడ్‌షిఫ్ట్ క్లస్టర్‌లో వాటి స్థితి మరియు అమలు సమయం వంటి అమలు చేయబడిన ప్రశ్నల గురించి మెటాడేటాను తిరిగి పొందుతుంది.
pg_terminate_backend()	Redshiftలో చిక్కుకున్న ప్రశ్న లేదా సెషన్‌ను క్లియర్ చేయడానికి దాని ప్రాసెస్ ID (pid) ద్వారా PostgreSQL బ్యాకెండ్ ప్రాసెస్‌ను ముగిస్తుంది.
SELECT * FROM stv_recents	ఇటీవల అమలు చేయబడిన ప్రశ్నలు మరియు వాటి స్థితులను గుర్తించడానికి Redshift యొక్క సిస్టమ్ పట్టికను ప్రశ్నిస్తుంది.
SELECT * FROM pg_locks	డేటాబేస్లో క్రియాశీల లాక్‌ల గురించి సమాచారాన్ని తిరిగి పొందుతుంది, పట్టిక లేదా లావాదేవీ-స్థాయి నిరోధించే సమస్యలను గుర్తించడంలో సహాయపడుతుంది.
Node.js AWS SDK: redshift.describeQueryExecutions()	సమస్య ట్రాకింగ్‌ని ఆటోమేట్ చేయడానికి Node.jsని ఉపయోగించి ప్రోగ్రామాటిక్‌గా Redshift క్లస్టర్‌లో క్రియాశీల ప్రశ్నలను పొందుతుంది.
redshift_client.promise()	Redshift కార్యకలాపాల కోసం Node.js స్క్రిప్ట్‌లలో అసమకాలిక ఆపరేషన్‌లు (API కాల్‌ల వంటివి) సమర్థవంతంగా నిర్వహించబడుతున్నాయని నిర్ధారిస్తుంది.
response.get()	Redshift ప్రతిస్పందన ఆబ్జెక్ట్ నుండి నిర్దిష్ట కీ లేదా విలువను తిరిగి పొందుతుంది, క్వెరీ డేటాను ప్రోగ్రామాటిక్‌గా ఫిల్టర్ చేయడానికి ఉపయోగపడుతుంది.
pg_locks.lockable_type	లాక్ రకాన్ని పేర్కొంటుంది (సంబంధం, లావాదేవీ మొదలైనవి), సిస్టమ్‌లో లాక్‌కి కారణమేమిటో నిర్ధారించడంలో సహాయపడుతుంది.

రెడ్‌షిఫ్ట్ కాపీ ప్రశ్న సమస్యలను అర్థం చేసుకోవడం మరియు డీబగ్గింగ్ చేయడం

గతంలో అందించిన స్క్రిప్ట్‌లు అమెజాన్ రెడ్‌షిఫ్ట్‌లో చిక్కుకున్న కాపీ ప్రశ్నలను ట్రబుల్షూటింగ్ చేయడానికి క్లిష్టమైన సాధనాలుగా పనిచేస్తాయి. ఈ స్క్రిప్ట్‌లు సమస్యాత్మక ప్రశ్నలను గుర్తించడం, వాటిని ముగించడం మరియు సజావుగా ఆపరేషన్‌ను నిర్ధారించడానికి సిస్టమ్ కార్యాచరణను పర్యవేక్షించడం ద్వారా సమస్యను పరిష్కరిస్తాయి. ఉదాహరణకు, పైథాన్ స్క్రిప్ట్ ఉపయోగిస్తుంది బోటో3 లైబ్రరీ రెడ్‌షిఫ్ట్‌తో ప్రోగ్రామాటిక్‌గా ఇంటరాక్ట్ అవుతుంది. ఇది క్రియాశీల ప్రశ్నలను జాబితా చేయడానికి మరియు వాటిని ఉపయోగించి వాటిని ముగించడానికి ఫంక్షన్‌లను అందిస్తుంది Cancel_query_execution() API కాల్, నిరంతర ప్రశ్న హ్యాంగ్‌లను నిర్వహించడానికి రూపొందించబడిన పద్ధతి. AWS మేనేజ్‌మెంట్ కన్సోల్ ద్వారా మాన్యువల్ జోక్యం అసాధ్యమైన పరిస్థితులకు ఈ విధానం అనువైనది. 🚀

అదేవిధంగా, SQL-ఆధారిత స్క్రిప్ట్ లక్ష్యం రెడ్‌షిఫ్ట్ సిస్టమ్ టేబుల్‌లను ప్రభావితం చేయడం ద్వారా చిక్కుకున్న ప్రశ్నలను లక్ష్యంగా చేసుకుంటుంది stv_recents మరియు pg_locks. ఈ పట్టికలు క్వెరీ స్టేట్స్ మరియు లాక్ స్టేటస్‌ల గురించి అంతర్దృష్టులను అందిస్తాయి, అడ్మినిస్ట్రేటర్‌లు సమస్యలను సమర్ధవంతంగా గుర్తించడానికి మరియు పరిష్కరించేందుకు వీలు కల్పిస్తాయి. వంటి ఆదేశాలను ఉపయోగించడం ద్వారా pg_terminate_backend(), ఇది నిర్దిష్ట బ్యాకెండ్ ప్రక్రియలను ముగించడానికి, వనరులను ఖాళీ చేయడానికి మరియు తదుపరి ఆలస్యాన్ని నిరోధించడానికి అనుమతిస్తుంది. వ్యక్తిగత సమస్యలను గుర్తించడం సవాలుగా ఉన్న పెద్ద ప్రశ్న వాల్యూమ్‌లతో క్లస్టర్‌ల కోసం ఈ స్క్రిప్ట్‌లు ప్రత్యేకించి ప్రభావవంతంగా ఉంటాయి.

Node.js సొల్యూషన్ JavaScript-ఆధారిత సాధనాలను ఇష్టపడే వారికి ప్రత్యామ్నాయాన్ని ప్రదర్శిస్తుంది. Redshift కోసం AWS SDKని ఉపయోగించడం ద్వారా, ఈ స్క్రిప్ట్ అత్యంత అసమకాలిక వాతావరణంలో ప్రశ్న పర్యవేక్షణ మరియు ముగింపును ఆటోమేట్ చేస్తుంది. ఉదాహరణకు, స్వయంచాలక ETL పైప్‌లైన్‌లను అమలు చేస్తున్నప్పుడు, చిక్కుకున్న ప్రశ్నలు షెడ్యూల్‌లను మరియు వృధా వనరులకు అంతరాయం కలిగించవచ్చు. ఈ Node.js అమలు ఇప్పటికే ఉన్న వర్క్‌ఫ్లోలతో, ప్రత్యేకించి డైనమిక్, క్లౌడ్-ఆధారిత పరిసరాలలో సజావుగా ఏకీకృతం చేయడం ద్వారా అటువంటి అంతరాయాలు తగ్గించబడతాయని నిర్ధారిస్తుంది. 🌐

మూడు విధానాలు మాడ్యులారిటీ మరియు పునర్వినియోగాన్ని నొక్కిచెబుతున్నాయి. మీరు Python, SQL లేదా Node.jsని ఇష్టపడినా, ఈ సొల్యూషన్‌లు పనితీరు కోసం ఆప్టిమైజ్ చేయబడతాయి మరియు విస్తృత నిర్వహణ వ్యవస్థల్లో ఏకీకృతం అయ్యేలా రూపొందించబడ్డాయి. అవి విశ్వసనీయతను నిర్ధారించడానికి ఎర్రర్ హ్యాండ్లింగ్ మరియు ఇన్‌పుట్ ధ్రువీకరణ వంటి ఉత్తమ పద్ధతులను కూడా కలిగి ఉంటాయి. డీబగ్గింగ్ క్వెరీ హ్యాంగ్‌ల నుండి లాక్ ప్రవర్తనను విశ్లేషించడం వరకు, ఈ స్క్రిప్ట్‌లు డెవలపర్‌లను సమర్థవంతమైన రెడ్‌షిఫ్ట్ కార్యకలాపాలను నిర్వహించడానికి శక్తినిస్తాయి, మీ డేటా పైప్‌లైన్‌లు పటిష్టంగా మరియు ప్రతిస్పందించేలా ఉంటాయి.

పైథాన్‌తో రెడ్‌షిఫ్ట్ కాపీ ప్రశ్న సమస్యలను పరిష్కరిస్తోంది (బోటో3ని ఉపయోగించి)

పైథాన్ మరియు బోటో3ని ఉపయోగించి డీబగ్గింగ్ మరియు సమస్యను పరిష్కరించడానికి బ్యాకెండ్ స్క్రిప్ట్

import boto3
import time
from botocore.exceptions import ClientError
# Initialize Redshift client
redshift_client = boto3.client('redshift', region_name='your-region')
# Function to terminate a stuck query
def terminate_query(cluster_identifier, query_id):
    try:
        response = redshift_client.cancel_query_execution(ClusterIdentifier=cluster_identifier, QueryId=query_id)
        print(f"Query {query_id} terminated successfully.")
    except ClientError as e:
        print(f"Error terminating query: {e}")
# List active queries
def list_active_queries(cluster_identifier):
    try:
        response = redshift_client.describe_query_executions(ClusterIdentifier=cluster_identifier)
        for query in response.get('QueryExecutions', []):
            print(f"Query ID: {query['QueryId']} - Status: {query['Status']}")
    except ClientError as e:
        print(f"Error fetching queries: {e}")
# Example usage
cluster_id = 'your-cluster-id'
list_active_queries(cluster_id)
terminate_query(cluster_id, 'your-query-id')

సమస్యను పరిష్కరించడానికి SQL-ఆధారిత విధానాన్ని రూపొందించడం

Redshift ప్రశ్న ఎడిటర్ లేదా SQL క్లయింట్ ద్వారా నేరుగా SQL ప్రశ్నలను ఉపయోగించడం

-- Check for stuck queries
SELECT * FROM stv_recents WHERE aborted = 0;
-- Terminate a specific backend process
SELECT pg_terminate_backend(pid)
FROM stv_sessions
WHERE process = 'query_id';
-- Validate table locks
SELECT lockable_type, transaction_id, relation, mode
FROM pg_locks;
-- Reboot the cluster if necessary
-- This must be done via the AWS console or API
-- Ensure no active sessions before rebooting

AWS SDKని ఉపయోగించి Node.js అప్రోచ్‌ని అమలు చేస్తోంది

Node.jsని ఉపయోగించి Redshift ప్రశ్నలను నిర్వహించడానికి బ్యాకెండ్ స్క్రిప్ట్

const AWS = require('aws-sdk');
const redshift = new AWS.Redshift({ region: 'your-region' });
// Function to describe active queries
async function listActiveQueries(clusterId) {
    try {
        const data = await redshift.describeQueryExecutions({ ClusterIdentifier: clusterId }).promise();
        data.QueryExecutions.forEach(query => {
            console.log(`Query ID: ${query.QueryId} - Status: ${query.Status}`);
        });
    } catch (err) {
        console.error("Error fetching queries:", err);
    }
}
// Terminate a stuck query
async function terminateQuery(clusterId, queryId) {
    try {
        await redshift.cancelQueryExecution({ ClusterIdentifier: clusterId, QueryId: queryId }).promise();
        console.log(`Query ${queryId} terminated successfully.`);
    } catch (err) {
        console.error("Error terminating query:", err);
    }
}
// Example usage
const clusterId = 'your-cluster-id';
listActiveQueries(clusterId);
terminateQuery(clusterId, 'your-query-id');

రెడ్‌షిఫ్ట్‌లో ట్రబుల్షూటింగ్ ప్రశ్న హ్యాంగ్స్: బేసిక్స్‌కు మించి

అమెజాన్ రెడ్‌షిఫ్ట్‌తో పని చేస్తున్నప్పుడు, ట్రబుల్షూటింగ్ క్వెరీ హ్యాంగ్‌లలో తరచుగా పట్టించుకోని అంశం ఏమిటంటే దీని ప్రభావం WLM (వర్క్‌లోడ్ మేనేజ్‌మెంట్) ఆకృతీకరణలు. WLM సెట్టింగ్‌లు Redshift ప్రశ్నలకు వనరులను ఎలా కేటాయిస్తుందో నియంత్రిస్తుంది మరియు తప్పుగా కాన్ఫిగర్ చేయబడిన క్యూలు లోడ్ ప్రశ్నలను నిరవధికంగా నిలిపివేయవచ్చు. ఉదాహరణకు, COPY కమాండ్ తగినంత మెమరీ లేని క్యూకి మళ్లించబడితే, అది నిజమైన పురోగతి లేకుండానే రన్ అయ్యేలా కనిపించవచ్చు. ఎక్కువ మెమరీని కేటాయించడం లేదా కాన్‌కరెన్సీ స్కేలింగ్‌ని ప్రారంభించడం ద్వారా WLM సెట్టింగ్‌లను సర్దుబాటు చేయడం అటువంటి సమస్యలను పరిష్కరించగలదు. డేటా లోడ్ వాల్యూమ్‌లలో హెచ్చుతగ్గులు ఉన్న దృశ్యాలలో ఇది ప్రత్యేకంగా వర్తిస్తుంది. 📊

పరిగణించవలసిన మరో ముఖ్యమైన అంశం నెట్‌వర్క్ జాప్యం. COPY ఆదేశాలు తరచుగా S3 లేదా DynamoDB వంటి బాహ్య డేటా మూలాధారాలపై ఆధారపడి ఉంటాయి. డేటా బదిలీలో అడ్డంకి ఉన్నట్లయితే, ఆదేశం నిలిచిపోయినట్లు అనిపించవచ్చు. ఉదాహరణకు, తప్పును ఉపయోగించడం IAM పాత్రలు లేదా తగినంత అనుమతులు లేకపోవడం వల్ల బాహ్య డేటా యాక్సెస్‌కు ఆటంకం ఏర్పడుతుంది, ఇది ఆలస్యం అవుతుంది. సరైన నెట్‌వర్క్ కాన్ఫిగరేషన్‌లను నిర్ధారించడం మరియు AWS CLI వంటి సాధనాలతో S3 బకెట్‌లకు కనెక్టివిటీని పరీక్షించడం ఈ అంతరాయాలను నిరోధించవచ్చు. పంపిణీ చేయబడిన వ్యవస్థలలో ఈ సవాళ్లు సాధారణం, ప్రత్యేకించి ప్రపంచవ్యాప్తంగా కార్యకలాపాలను స్కేలింగ్ చేస్తున్నప్పుడు. 🌎

చివరగా, డేటా ఫార్మాట్ సమస్యలు తరచుగా కానీ తక్కువ స్పష్టమైన అపరాధి. Redshift COPY ఆదేశాలు CSV, JSON లేదా Parquet వంటి వివిధ ఫైల్ ఫార్మాట్‌లకు మద్దతు ఇస్తాయి. ఫైల్ నిర్మాణం లేదా డీలిమిటర్ సెట్టింగ్‌లలో చిన్న అసమతుల్యత COPY ప్రశ్న నిశ్శబ్దంగా విఫలమవుతుంది. అమలు చేయడానికి ముందు ఇన్‌పుట్ ఫైల్‌లను ధృవీకరించడం మరియు రెడ్‌షిఫ్ట్‌లను ఉపయోగించడం ఫిల్‌రికార్డ్ మరియు ఇగ్నోర్హెడర్ ఎంపికలు అటువంటి ప్రమాదాలను తగ్గించగలవు. ఈ వ్యూహాలు తక్షణ సమస్యను పరిష్కరించడమే కాకుండా మొత్తం డేటా ఇంజెషన్ సామర్థ్యాన్ని మెరుగుపరుస్తాయి.

Redshift కాపీ క్వెరీ హ్యాంగ్స్ గురించి ముఖ్యమైన FAQలు

Redshiftలో COPY క్వెరీ హ్యాంగ్ అవ్వడానికి సాధారణ కారణాలు ఏమిటి?
WLM తప్పు కాన్ఫిగరేషన్‌లు, నెట్‌వర్క్ సమస్యలు లేదా ఫైల్ ఫార్మాట్ అసమానతల వల్ల తరచుగా కాపీ ప్రశ్న హ్యాంగ్ అవుతుంది. WLM సెట్టింగ్‌లను సర్దుబాటు చేయండి మరియు దీనితో డేటా సోర్స్ కనెక్టివిటీని ధృవీకరించండి aws s3 ls.
హ్యాంగింగ్ క్వెరీని నేను ఎలా ముగించగలను?
ఉపయోగించండి SELECT pg_terminate_backend(pid) ప్రక్రియను ముగించడానికి లేదా ప్రోగ్రామాటిక్ ముగింపు కోసం AWS SDK.
IAM పాత్రలు COPY ఆదేశాలను ప్రభావితం చేయగలవా?
అవును, తప్పు IAM పాత్రలు లేదా విధానాలు S3 వంటి బాహ్య డేటా సోర్స్‌లకు యాక్సెస్‌ను బ్లాక్ చేయగలవు, దీని వలన ప్రశ్నలు హ్యాంగ్ అవుతాయి. ఉపయోగించండి aws sts get-caller-identity పాత్రలను ధృవీకరించడానికి.
ఫైల్ ఫార్మాట్ సమస్యలను డీబగ్ చేయడానికి ఉత్తమ మార్గం ఏమిటి?
ముందుగా చిన్న డేటాసెట్‌లను లోడ్ చేయడం ద్వారా ఫైల్ ఫార్మాట్‌లను ధృవీకరించండి మరియు COPY ఎంపికలను ప్రభావితం చేయండి FILLRECORD తప్పిపోయిన విలువలను సునాయాసంగా నిర్వహించడానికి.
నేను Redshift నుండి S3కి కనెక్టివిటీని ఎలా పరీక్షించగలను?
వంటి ప్రాథమిక ప్రశ్నను అమలు చేయండి aws s3 ls s3://your-bucket-name/ యాక్సెస్‌ని నిర్ధారించడానికి Redshift వలె అదే VPC నుండి.

ప్రశ్న ట్రబుల్‌షూటింగ్‌ను ముగించడం

అమెజాన్ రెడ్‌షిఫ్ట్‌లో నిలిచిపోయిన కాపీ ప్రశ్నలను నిర్వహించడానికి stv_recents వంటి సిస్టమ్ టేబుల్‌లను విశ్లేషించడం నుండి WLM సెట్టింగ్‌ల వంటి కాన్ఫిగరేషన్ సమస్యలను పరిష్కరించడం వరకు బహుముఖ విధానం అవసరం. స్పష్టమైన డయాగ్నస్టిక్స్ మరియు ఆప్టిమైజ్ చేసిన వర్క్‌ఫ్లోలతో డీబగ్గింగ్ నిర్వహించబడుతుంది. 🎯

ఫైల్ ఫార్మాట్‌లను ధృవీకరించడం మరియు IAM పాత్రలను నిర్వహించడం వంటి బలమైన పద్ధతులను అమలు చేయడం భవిష్యత్తులో అంతరాయాలను నివారిస్తుంది. ఈ పరిష్కారాలు తక్షణ సమస్యలను పరిష్కరించడమే కాకుండా మొత్తం సిస్టమ్ సామర్థ్యాన్ని మెరుగుపరుస్తాయి, డేటా వేర్‌హౌసింగ్ అవసరాల కోసం రెడ్‌షిఫ్ట్‌ను మరింత నమ్మదగిన సాధనంగా మారుస్తుంది. 🌟

Redshift ప్రశ్న ట్రబుల్షూటింగ్ కోసం వనరులు మరియు సూచనలు

Amazon Redshift COPY కమాండ్ కార్యాచరణ మరియు ట్రబుల్షూటింగ్ గురించిన వివరాలు అధికారిక AWS డాక్యుమెంటేషన్ నుండి సూచించబడ్డాయి. సందర్శించండి అమెజాన్ రెడ్‌షిఫ్ట్ కాపీ డాక్యుమెంటేషన్ .
stv_recents మరియు pg_locks వంటి సిస్టమ్ పట్టికలను నిర్వహించడంపై అంతర్దృష్టులు AWS నాలెడ్జ్ బేస్ కథనాల నుండి తీసుకోబడ్డాయి. వద్ద మరింత అన్వేషించండి AWS రెడ్‌షిఫ్ట్ ప్రశ్న పనితీరు గైడ్ .
Redshiftతో పరస్పర చర్య చేయడానికి పైథాన్ యొక్క Boto3 లైబ్రరీని ఉపయోగించిన ఉదాహరణలు కమ్యూనిటీ ట్యుటోరియల్స్ మరియు అందుబాటులో ఉన్న గైడ్‌ల ద్వారా ప్రేరణ పొందాయి. Boto3 డాక్యుమెంటేషన్ .
భాగస్వామ్యం చేయబడిన ప్రాక్టికల్ కేస్ స్టడీస్ నుండి WLM కాన్ఫిగరేషన్ మరియు రిసోర్స్ ఆప్టిమైజేషన్ కోసం ఉత్తమ పద్ధతులు అధ్యయనం చేయబడ్డాయి DataCumulus బ్లాగ్ .
Redshift కనెక్టివిటీ మరియు అనుమతుల నిర్వహణ కోసం సాధారణ ట్రబుల్షూటింగ్ చిట్కాలు AWS మద్దతు ఫోరమ్‌ల నుండి తీసుకోబడ్డాయి. వద్ద చర్చలను చూడండి AWS రెడ్‌షిఫ్ట్ ఫోరమ్ .

చిన్న పట్టికల కోసం రెడ్‌షిఫ్ట్ కాపీ ప్రశ్న హ్యాంగ్ సమస్యలను పరిష్కరిస్తోంది