నమూనా HBase POC

ఈ బ్లాగులో మేము HBase కోసం నమూనా ప్రూఫ్ ఆఫ్ కాన్సెప్ట్ గురించి చర్చిస్తాము.

దిగువ చిత్రంలో ఉన్నట్లుగా ఇక్కడ మనకు డేటా సెట్ ఉంది.

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

మొదటి ఫీల్డ్ తేదీని సూచిస్తుంది, రెండవ ఫీల్డ్ మొబైల్ నంబర్‌ను సూచిస్తుంది, మూడవ ఫీల్డ్ ఇన్‌కమింగ్ కాల్‌ల మొత్తం వ్యవధిని సూచిస్తుంది, నాల్గవ ఫీల్డ్ మొత్తం అవుట్‌గోయింగ్ కాల్‌ల వ్యవధిని సూచిస్తుంది మరియు ఐదవ ఫీల్డ్ మొత్తం పంపిన సందేశాల సంఖ్యను సూచిస్తుంది.

ఇప్పుడు మా పని ఏమిటంటే, ఇన్‌కమింగ్ మరియు అవుట్గోయింగ్ కాల్స్ మరియు సందేశాల వ్యవధి యొక్క సమాచారాన్ని ఒక నిర్దిష్ట తేదీలోని ఫోన్ నంబర్ నుండి తిరిగి పొందడం.

ఈ వినియోగ సందర్భంలో, నేను 15 రికార్డులను ఫిల్టర్ చేయడానికి ప్రయత్నిస్తున్నాను^వమార్చి 2014. దీన్ని సాధించడానికి ఇక్కడ ఒక HBase ప్రోగ్రామ్ ఉంది.

దాని పూర్తి కోడ్ క్రింద ఉంది.

ప్రజా తరగతి నమూనా{

ప్రైవేట్ స్టాటిక్ ఆకృతీకరణ conf

స్టాటిక్ HTable పట్టిక

ప్రజా నమూనా (స్ట్రింగ్ టేబుల్ నేమ్, స్ట్రింగ్ కోల్ఫామ్స్) విసురుతాడు IOException {

conf = HBaseConfiguration. సృష్టించండి ()

createTable (tableName, colFams)

పట్టిక = క్రొత్తది HTable ( conf , tableName)

}

శూన్యమైనది క్రియేట్ టేబుల్ (స్ట్రింగ్ టేబుల్ నేమ్, స్ట్రింగ్ కోల్ ఫామ్స్) విసురుతాడు IOException {

HBaseAdmin hbase = క్రొత్తది HBaseAdmin ( conf )

HTableDescriptor desc = క్రొత్తది HTableDescriptor (టేబుల్ నేమ్)

HColumnDescriptor మెటా = క్రొత్తది HColumnDescriptor (colFams.getBytes ())

desc.addFamily (మెటా)

hbase.createTable (డెస్క్)

}

ప్రజా స్టాటిక్ శూన్యమైనది addColumnEntry (స్ట్రింగ్ టేబుల్ నేమ్, స్ట్రింగ్ రో,

స్ట్రింగ్ colFamilyName, స్ట్రింగ్ colName, స్ట్రింగ్ విలువలు)

విసురుతాడు IOException {

బైట్ [] rowKey = బైట్లు. toBytes (అడ్డు వరుస)

పుట్డేటా ఉంచండి = క్రొత్తది ఉంచండి (rowKey)

putdata.add (బైట్లు. toBytes (colFamilyName), బైట్లు. toBytes (colName),

బైట్లు. toBytes (విలువలు))

పట్టిక .పుట్ (పుట్డేటా)

}

ప్రజా స్టాటిక్ శూన్యమైనది getAllRecord (స్ట్రింగ్ టేబుల్ నేమ్, స్ట్రింగ్ స్టార్ట్పార్టికల్ కే,

స్ట్రింగ్ ఎండ్‌పార్షియల్‌కే) విసురుతాడు IOException {

ప్రయత్నించండి {

స్కాన్ s

ఉంటే (startPartialKey == శూన్య || endPartialKey == శూన్య )

s = క్రొత్తది స్కాన్ ()

లేకపోతే

s = క్రొత్తది స్కాన్ (బైట్లు. toBytes (startPartialKey),

బైట్లు. toBytes (endPartialKey))

పైథాన్ అంటే __init__

ఫలితం స్కానర్ ss = పట్టిక .getScanner (లు)

హాష్ మ్యాప్outputRec = క్రొత్తది హాష్ మ్యాప్()

సి ++ లో నేమ్‌స్పేస్‌లు

స్ట్రింగ్ imsi = “”

కోసం (ఫలితం r: ss) {

హాష్ మ్యాప్ కీవాల్ = క్రొత్తది హాష్ మ్యాప్ ()

కోసం (కీవాల్యూ kv: r.raw ()) {

imsi = క్రొత్తది స్ట్రింగ్ (kv.getRow ()). సబ్‌స్ట్రింగ్ (10)

keyVal.put ( క్రొత్తది స్ట్రింగ్ (kv.getQualifier ()),

క్రొత్తది స్ట్రింగ్ (kv.getValue ()))

outputRec.put (imsi, keyVal)

ఉంటే (keyVal.size () == 3)

సిస్టమ్. అవుట్ .println (తీసుకోండి + ”” + “వచ్చే నిమిషాలు:”

+ keyVal.get (“c1 ″) +” రాబోయే నిమిషాలు: ”

+ keyVal.get (“c2 ″) +” సందేశాలు: ”

+ keyVal.get (“c3”))

}

}

} చివరకు {

}

}

ప్రజా స్టాటిక్ శూన్యమైనది ప్రధాన (స్ట్రింగ్ [] అర్గ్స్) విసురుతాడు IOException {

స్ట్రింగ్ tableName = “daterecords”

స్ట్రింగ్ colFamilyNames = “i”

నమూనా పరీక్ష = క్రొత్తది నమూనా (టేబుల్‌నేమ్, కోల్‌ఫ్యామిలీ నేమ్స్)

స్ట్రింగ్ ఫైల్ పేరు = “/ హోమ్ / క్లౌడెరా / డెస్క్‌టాప్ / డేటా”

// ఇది ఒక సమయంలో ఒక పంక్తిని సూచిస్తుంది

స్ట్రింగ్ లైన్ = శూన్య

ప్రయత్నించండి {

// ఫైల్ రీడర్ డిఫాల్ట్ ఎన్కోడింగ్లో టెక్స్ట్ ఫైళ్ళను చదువుతుంది.

ఫైల్ రీడర్ ఫైల్ రీడర్ = క్రొత్తది ఫైల్ రీడర్ (ఫైల్ పేరు)

// ఎల్లప్పుడూ ఫైల్ రీడర్‌ను బఫర్డ్ రీడర్‌లో చుట్టండి.

బఫర్డ్ రీడర్ బఫర్డ్ రీడర్ = క్రొత్తది బఫర్డ్ రీడర్ (ఫైల్ రీడర్)

అయితే ((పంక్తి = బఫర్డ్ రీడర్.రెడ్‌లైన్ ())! = శూన్య ) {

స్ట్రింగ్ [] విలువలు = line.split (”“)

addColumnEntry (పట్టిక పేరు, విలువలు [0] + “-” + విలువలు [1],

colFamilyNames, “c1”, విలువలు [2])

addColumnEntry (పట్టిక పేరు, విలువలు [0] + “-” + విలువలు [1],

colFamilyNames, “c2”, విలువలు [3])

addColumnEntry (పట్టిక పేరు, విలువలు [0] + “-” + విలువలు [1],

colFamilyNames, “c3”, విలువలు [4])

}

bufferedReader.close ()

} క్యాచ్ (FileNotFoundException ఉదా) {

సిస్టమ్. అవుట్ .println (“ఫైల్‌ను తెరవడం సాధ్యం కాలేదు‘ ”+ ఫైల్ పేరు +“ ‘”)

} క్యాచ్ (IOException ఉదా) {

సిస్టమ్. అవుట్ .println (“ఫైల్‌ను చదవడంలో లోపం‘ ”+ ఫైల్ పేరు +“ ‘”)

// లేదా మేము దీన్ని చేయగలం:

// ex.printStackTrace ()

}

getAllRecord (tableName, “20140315”, “20140316”)

}

}

ఇక్కడ మేము కాన్ఫిగరేషన్, HTable క్లాస్ యొక్క ఒక వస్తువును సృష్టించాము మరియు పేరుతో Hbase పట్టికను సృష్టించాము: daterecords మరియు కాలమ్ కుటుంబం: i .

ఈ వినియోగ సందర్భంలో, ఈ Hbase పట్టికకు వరుస కీగా '-' ద్వారా వేరు చేయబడిన తేదీ మరియు మొబైల్ నంబర్ కలయికను మరియు ఇన్కమింగ్, అవుట్గోయింగ్ కాల్ వ్యవధులు ', నిలువు వరుసలుగా పంపిన సందేశాల సంఖ్య' c1 ',' 'i' కాలమ్ కుటుంబానికి c2 ',' c3 '.

క్లౌడెరా యొక్క స్థానిక ఫైల్ సిస్టమ్‌లో ఇన్‌పుట్ డేటా నిల్వ చేయబడింది. కాబట్టి మనం ఫైల్ నుండి డేటాను చదివే జావా లాజిక్ రాయాలి.

క్రింద జావా లాజిక్ ఉంది.

ఈ పద్ధతిలో మేము కాలమ్ కుటుంబం యొక్క ప్రతి కాలమ్ కోసం డేటాను పట్టికలో నిల్వ చేస్తున్నాము.

స్కాన్ ఆదేశాన్ని ఉపయోగించి మేము Hbase పట్టిక ‘daterecords’ లో నిల్వ చేసిన డేటాను తనిఖీ చేయవచ్చు.

దిగువ చిత్రంలో ఉన్నట్లుగా మీరు డేటాను స్వీకరిస్తారు.

ఇప్పుడు మేము డేటాను HBase పట్టికలో విజయవంతంగా చేర్చాము.

ఒక నిర్దిష్ట తేదీ పట్టికలో నిల్వ చేసిన రికార్డులను తిరిగి పొందుదాం.

ఈ వినియోగ సందర్భంలో, మేము తేదీ: 15 యొక్క రికార్డులను తిరిగి పొందడానికి ప్రయత్నిస్తున్నాము^వమార్చి 2014

రికార్డులను తిరిగి పొందడానికి మేము ఒక పద్ధతిని సృష్టించాము

getAllRecord (స్ట్రింగ్ టేబుల్ నేమ్, స్ట్రింగ్ స్టార్ట్పార్షియల్ కే, స్ట్రింగ్ ఎండ్పార్టికల్ కే)

మొదటి పరామితి పట్టిక పేరును సూచిస్తుంది, రెండవది మేము డేటాను తిరిగి పొందవలసిన ప్రారంభ తేదీని సూచిస్తుంది మరియు మూడవది ప్రారంభ తేదీ యొక్క తదుపరి తేదీ.

జావా కోడ్‌ను ఎలా కంపైల్ చేయాలి

ఉదా:

getAllRecord (tableName, “20140315”, “20140316”)

ఇప్పుడు మనం అర్థం చేసుకుందాం తర్కం ఈ పద్ధతి యొక్క.

స్టార్ట్‌పార్షియల్‌కే మరియు ఎండ్‌పార్షియల్‌కే సహాయంతో హెచ్‌బేస్ ఎపిఐని ఉపయోగించడం ద్వారా మేము హెచ్‌బేస్ టేబుల్‌ను స్కాన్ చేయడానికి ప్రయత్నిస్తున్నాము.

StartPartialKey మరియు endPartialkey శూన్యంగా లేనందున, ఇది వేరే బ్లాక్‌కు వెళ్లి, StartPartialKey విలువను కలిగి ఉన్న రికార్డులను స్కాన్ చేస్తుంది.

ఫలిత స్కానర్ యొక్క ఒక వస్తువును మేము సృష్టించాము, ఇది Hbase పట్టిక యొక్క స్కాన్ చేసిన రికార్డులను మరియు ఫలితాన్నిచ్చే అవుట్పుట్ను నిల్వ చేయడానికి ఒక హాష్ మ్యాప్ను నిల్వ చేస్తుంది.

ఫలిత స్కానర్‌లో డేటా స్టోర్ పొందడానికి మరియు ఫలితం కోసం ఒక లూప్‌ను అమలు చేయడానికి మేము ఫలితం యొక్క వస్తువును సృష్టిస్తున్నాము.

imsi అనేది మొబైల్ నంబర్‌ను నిల్వ చేయడానికి నిర్వచించబడిన స్ట్రింగ్ మరియు కీవాల్ అనేది ఒక హాష్ మ్యాప్, ఇది ఒక నిర్దిష్ట ఫోన్ యొక్క కాలమ్ నుండి తిరిగి పొందిన అవుట్‌పుట్‌ను నిల్వ చేస్తుంది.

మేము ఇచ్చాము 20140315-1234567890 గా రౌకీ Hbase పట్టికకు. ఈ 20140315 తేదీని సూచిస్తుంది మరియు 1234567890 మొబైల్ నంబర్‌ను సూచిస్తుంది.

మనకు మొబైల్ నంబర్ మాత్రమే అవసరం కనుక దాన్ని తిరిగి పొందడానికి సబ్‌స్ట్రింగ్ పద్ధతిని ఉపయోగిస్తున్నాము.

మేము r.raw () నుండి డేటాను తిరిగి పొందుతున్నాము మరియు పుట్ ఉపయోగించి హాష్ మ్యాప్‌లో నిల్వ చేస్తున్నాము.

చివరగా మేము వాటిని కన్సోల్‌లో ప్రింట్ చేయడానికి ప్రయత్నిస్తున్నాము.

అవుట్పుట్ క్రింది చిత్రంలో ఉంటుంది.

తేదీ: 15 యొక్క రికార్డులను మేము విజయవంతంగా తిరిగి పొందాము^వమార్చి 2014.