वाह, वे बाधाएं काफी सीमित हैं लेकिन मुझे लगता है कि इसके आसपास कोई रास्ता हो सकता है। मुझे लगता है कि इसके लिए आपको अपनी छोटी सी स्क्रिप्ट लिखनी पड़ सकती है।
मैं स्वयं जेडीबीसी के साथ जावा का उपयोग करूंगा (लेकिन कोई भी भाषा जो डेटाबेस से जुड़ सकती है और पढ़ सकती है, और आउटपुट स्ट्रिंग्स करेगा), एक छोटा प्रोग्राम लिखना जिसने डेटाबेस में प्रत्येक पंक्ति का रिकॉर्ड सेट पुनर्प्राप्त किया। फिर, उन पंक्तियों में से प्रत्येक के लिए:
-
पूरे डेटा के साथ एक इंसर्ट स्टेटमेंट बनाएं। यदि यह 2,000 बाइट्स से कम है, तो बस इसे फ़ाइल में आउटपुट करें और अगली पंक्ति पर जाएँ।
-
अन्यथा प्रत्येक फ़ील्ड के लिए एक इन्सर्ट स्टेटमेंट बनाएं, लेकिन
c13. को छोड़ दें''. के रूप में फ़ील्ड (खाली)। -
फिर, जब तक आपका
c13input. है स्ट्रिंग 2000 वर्णों से अधिक है, फ़ॉर्म का एक अपडेट स्टेटमेंट आउटपुट करें"update tbl set c13 = c13 || '" + c13input.substring (0,2000) + "' where ..."(अगले 2000 वर्णों को जोड़कर) और फिरc13input = c13input.substring(2000)करें उन वर्णों को अपनी स्ट्रिंग से अलग करने के लिए। -
एक बार
c13inputलंबाई में 2000 वर्णों से कम या उसके बराबर है, अंत में इससे निपटने के लिए बस एक अंतिम अपडेट आउटपुट करें।
यह आपको अपने व्यक्तिगत SQL कथनों को 2000-वर्ण चिह्न के आस-पास रखने और अन्य डेटाबेस तालिका को पुन:पॉप्युलेट करने के लिए सही SQL को कुशलतापूर्वक निष्पादित करने की अनुमति देता है।
मैं इस प्रकार की बात कर रहा हूं (केवल एक प्राथमिक कुंजी वाली तालिका के लिए c1 और एक बड़ा honkin' varchar c13 ):
rowset r = db.exec ("select * from oldtable");
while r.next != NO_MORE_ROWS:
string s = "insert into newtable (c1,c13) values ('" +
r.get("c1") + "','" + r.get("c13") + "')"
if s.len() < 2000:
print s
else:
s = "insert into newtable (c1,c13) values ('" + r.get("c1") + "','')"
print s
f = r.get("c13")
while f.len() > 2000:
s = "update newtable set c13 = c13 || '" + f.substring(0,2000) + ')"
f = f.substring(2000)
print s
endwhile
s = "update newtable set c13 = c13 || '" + f + ')"
print s
endif
endwhile
जाहिर है, आपको विशेष वर्णों के सम्मिलन की अनुमति देने के लिए स्ट्रिंग्स को मॉर्फ करने की आवश्यकता हो सकती है - मुझे यकीन नहीं है कि ओरेकल किस प्रारूप में इनसे अपेक्षा करता है, लेकिन उम्मीद है कि यह स्ट्रिंग्स को पार करने का एक साधारण मामला होगा (r.get("c13") यदि पूर्ण सम्मिलन की लंबाई 2000 से कम है, f.substring(0,2000) और f यदि आप अपडेट भी बना रहे हैं) ऐसा करने के लिए एक सहायक फ़ंक्शन के लिए।
अगर उस मॉर्फिंग से मुद्रित लाइन के आकार में वृद्धि होने की संभावना है, तो आप सुरक्षित रहने के लिए थ्रेशोल्ड को वापस 1000 तक छोड़ना चाह सकते हैं, यह सुनिश्चित करने के लिए कि मॉर्फ्ड स्ट्रिंग पीएल/एसक्यूएल सीमा से अधिक लाइन में परिणत नहीं होती है।
क्षमा करें यदि यह जटिल लगता है, लेकिन आपने जो प्रतिबंध बताए हैं, वे हमें थोड़ा प्रभावित करते हैं। एक बेहतर तरीका हो सकता है, लेकिन मैं उस तरीके के बारे में नहीं सोच सकता जो सभी से मिलता हो आपके मानदंड।
अपडेट करें: ऐसा लगता है कि आप और भी और हैं मूल रूप से सोचा की तुलना में हैमस्ट्रंग:यदि आपको जनरेट करने . के लिए स्वयं को SQL तक सीमित करना है स्क्रिप्ट के साथ-साथ इसे चलाने का एक तरीका है, हालांकि यह कष्टप्रद है।
एसक्यूएल उत्पन्न करने के लिए आप एसक्यूएल का उपयोग कर सकते हैं। मेरी उपर्युक्त तालिका का उपयोग c1 . के साथ करना और c13 , आप यह कर सकते हैं:
select
'insert into newtable (c1,c13) values ("' ||
c1 ||
'","");'
from oldtable;
# Xlates to: insert into newtable (c1,c13) values ("[c1]","");
इससे आपको आपकी सारी आधारभूत insert मिल जाएगी c13 . को छोड़कर सब कुछ डुप्लिकेट करने के लिए कथन कॉलम।
इसके बाद आपको c13 . को सेट करने के लिए और स्टेटमेंट जेनरेट करने की जरूरत है . अपडेट करने के लिए c13 लंबाई 1000 या उससे कम (सरल सेट) के सभी मानों के लिए:
select
'update newtable set c13 = "' ||
c13 ||
'" where c1 = "' ||
c1 ||
'";'
from oldtable where length(c13) <= 1000;
# Xlates to: update newtable set c13 = "[c13]" where c1 = "[c1]";
# but only for rows where length([c13]) <= 1000
फिर, update c13 1001 और 2000 वर्णों के बीच सभी मानों के लिए (सेट फिर संलग्न करें):
select
'update newtable set c13 = "' ||
substring(c13,1,1000) ||
'" where c1 = "' ||
c1 ||
'";'
from oldtable where length(c13) > 1000 and length(c13) <= 2000;
select
'update newtable set c13 = c13 || "' ||
substring(c13,1001,1000) ||
'" where c1 = "' ||
c1 ||
'";'
from oldtable where length(c13) > 1000 and length(c13) <= 2000;
# Xlates to: update newtable set c13 = "[c13a]" where c1 = "[c1]";
# update newtable set c13 = c13 || "[c13b]" where c1 = "[c1]";
# but only for rows where length([c13]) > 1000 and <= 2000
# and [c13a]/[c13b] are the first/second thousand chars of c13.
और इसी तरह 2001-से-3000 और 3001-से-4000 लंबाई वाले लोगों के लिए।
संभवत:कुछ ट्विकिंग करने की आवश्यकता होगी। मुझे आपको इसे हल करने का एक तरीका देने में खुशी हो रही है, लेकिन इस तरह के एक राक्षसी पर काम करने की मेरी इच्छा कम से कम है :-)
क्या यह काम हो जाएगा? हां। क्या यह सुंदर है? मैं कहूंगा कि यह एक शानदार "नहीं!" था। लेकिन, आपकी बाधाओं को देखते हुए, यह सबसे अच्छा हो सकता है जिसकी आप उम्मीद कर सकते हैं।
अवधारणा के प्रमाण के रूप में, यहाँ DB2 में एक SQL स्क्रिप्ट है (हालांकि कोई विशेष विशेषता नहीं है, इसे किसी भी DBMS में ठीक काम करना चाहिए जिसमें length हो और substr समकक्ष):
# Create table and populate.
DROP TABLE XYZ;
COMMIT;
CREATE TABLE XYZ (F1 VARCHAR(1),F2 VARCHAR(20));
COMMIT;
INSERT INTO XYZ VALUES ('1','PAX');
INSERT INTO XYZ VALUES ('2','GEORGE');
INSERT INTO XYZ VALUES ('3','VLADIMIR');
INSERT INTO XYZ VALUES ('4','ALEXANDRETTA');
SELECT * FROM XYZ ORDER BY F1;
# Create initial insert statem,ents.
SELECT 'INSERT INTO XYZ (F1,F2) VALUES (' || F1 ','''');'
FROM XYZ;
# Updates for 1-5 character F2 fields.
SELECT 'UPDATE XYZ SET F2 = ''' || F2 ||
''' WHERE F1 = ''' || F1 || ''';'
FROM XYZ WHERE LENGTH(F2) <= 5;
# Updates for 6-10 character F2 fields.
SELECT 'UPDATE XYZ SET F2 = ''' || SUBSTR(F2,1,5) ||
''' WHERE F1 = ''' || F1 || ''';'
FROM XYZ WHERE LENGTH(F2) > 5 AND LENGTH(F2) <= 10;
SELECT 'UPDATE XYZ SET F2 = F2 || ''' || SUBSTR(F2,6) ||
''' WHERE F1 = ''' || F1 || ''';'
FROM XYZ WHERE LENGTH(F2) > 5 AND LENGTH(F2) <= 10;
# Updates for 11-15 character F2 fields.
SELECT 'UPDATE XYZ SET F2 = ''' || SUBSTR(F2,1,5) ||
''' WHERE F1 = ''' || F1 || ''';'
FROM XYZ WHERE LENGTH(F2) > 10 AND LENGTH(F2) <= 15;
SELECT 'UPDATE XYZ SET F2 = F2 || ''' || SUBSTR(F2,6,5) ||
''' WHERE F1 = ''' || F1 || ''';'
FROM XYZ WHERE LENGTH(F2) > 10 AND LENGTH(F2) <= 15;
SELECT 'UPDATE XYZ SET F2 = F2 || ''' || SUBSTR(F2,11) ||
''' WHERE F1 = ''' || F1 || ''';'
FROM XYZ WHERE LENGTH(F2) > 10 AND LENGTH(F2) <= 15;
और यह निम्नलिखित पंक्तियाँ उत्पन्न करता है:
> DROP TABLE XYZ;
> COMMIT;
> CREATE TABLE XYZ (F1 VARCHAR(1),F2 VARCHAR(20));
> COMMIT;
> INSERT INTO XYZ VALUES ('1','PAX');
> INSERT INTO XYZ VALUES ('2','GEORGE');
> INSERT INTO XYZ VALUES ('3','VLADIMIR');
> INSERT INTO XYZ VALUES ('4','ALEXANDRETTA');
> SELECT * FROM XYZ;
F1 F2
-- ------------
1 PAX
2 GEORGE
3 VLADIMIR
4 ALEXANDRETTA
> SELECT 'INSERT INTO XYZ (F1,F2) VALUES (' || F1 || ','''');'
> FROM XYZ;
INSERT INTO XYZ (F1,F2) VALUES (1,'');
INSERT INTO XYZ (F1,F2) VALUES (2,'');
INSERT INTO XYZ (F1,F2) VALUES (3,'');
INSERT INTO XYZ (F1,F2) VALUES (4,'');
> SELECT 'UPDATE XYZ SET F2 = ''' || F2 ||
> ''' WHERE F1 = ''' || F1 || ''';'
> FROM XYZ WHERE LENGTH(F2) <= 5;
UPDATE XYZ SET F2 = 'PAX' WHERE F1 = '1';
> SELECT 'UPDATE XYZ SET F2 = ''' || SUBSTR(F2,1,5) ||
> ''' WHERE F1 = ''' || F1 || ''';'
> FROM XYZ WHERE LENGTH(F2) > 5 AND LENGTH(F2) <= 10;
UPDATE XYZ SET F2 = 'GEORG' WHERE F1 = '2';
UPDATE XYZ SET F2 = 'VLADI' WHERE F1 = '3';
> SELECT 'UPDATE XYZ SET F2 = F2 || ''' || SUBSTR(F2,6) ||
> ''' WHERE F1 = ''' || F1 || ''';'
> FROM XYZ WHERE LENGTH(F2) > 5 AND LENGTH(F2) <= 10;
UPDATE XYZ SET F2 = F2 || 'E' WHERE F1 = '2';
UPDATE XYZ SET F2 = F2 || 'MIR' WHERE F1 = '3';
> SELECT 'UPDATE XYZ SET F2 = ''' || SUBSTR(F2,1,5) ||
> ''' WHERE F1 = ''' || F1 || ''';'
> FROM XYZ WHERE LENGTH(F2) > 10 AND LENGTH(F2) <= 15;
UPDATE XYZ SET F2 = 'ALEXA' WHERE F1 = '4';
> SELECT 'UPDATE XYZ SET F2 = F2 || ''' || SUBSTR(F2,6,5) ||
> ''' WHERE F1 = ''' || F1 || ''';'
> FROM XYZ WHERE LENGTH(F2) > 10 AND LENGTH(F2) <= 15;
UPDATE XYZ SET F2 = F2 || 'NDRET' WHERE F1 = '4';
> SELECT 'UPDATE XYZ SET F2 = F2 || ''' || SUBSTR(F2,11) ||
> ''' WHERE F1 = ''' || F1 || ''';'
> FROM XYZ WHERE LENGTH(F2) > 10 AND LENGTH(F2) <= 15;
UPDATE XYZ SET F2 = F2 || 'TA' WHERE F1 = '4';
आउटपुट लाइनों को तोड़कर, हम प्राप्त करते हैं:
INSERT INTO XYZ (F1,F2) VALUES (1,'');
INSERT INTO XYZ (F1,F2) VALUES (2,'');
INSERT INTO XYZ (F1,F2) VALUES (3,'');
INSERT INTO XYZ (F1,F2) VALUES (4,'');
UPDATE XYZ SET F2 = 'PAX' WHERE F1 = '1';
UPDATE XYZ SET F2 = 'GEORG' WHERE F1 = '2';
UPDATE XYZ SET F2 = 'VLADI' WHERE F1 = '3';
UPDATE XYZ SET F2 = F2 || 'E' WHERE F1 = '2';
UPDATE XYZ SET F2 = F2 || 'MIR' WHERE F1 = '3';
UPDATE XYZ SET F2 = 'ALEXA' WHERE F1 = '4';
UPDATE XYZ SET F2 = F2 || 'NDRET' WHERE F1 = '4';
UPDATE XYZ SET F2 = F2 || 'TA' WHERE F1 = '4';
जो आपको मूल पंक्तियाँ दें, यद्यपि एक गोल चक्कर में।
और यह लगभग उतना ही प्रयास है जितना कि मैं अपने दिमाग को तलने के बिना किसी एक प्रश्न में डाल सकता हूं, इसलिए जब तक मुझे कोई गंभीर त्रुटि नहीं बताई जाती, तब तक मैं आपको अलविदा कह दूंगा।
आपके प्रोजेक्ट के लिए शुभकामनाएँ, और शुभकामनाएँ।
