1 /**************************************************************
2  *
3  * Licensed to the Apache Software Foundation (ASF) under one
4  * or more contributor license agreements.  See the NOTICE file
5  * distributed with this work for additional information
6  * regarding copyright ownership.  The ASF licenses this file
7  * to you under the Apache License, Version 2.0 (the
8  * "License"); you may not use this file except in compliance
9  * with the License.  You may obtain a copy of the License at
10  *
11  *   http://www.apache.org/licenses/LICENSE-2.0
12  *
13  * Unless required by applicable law or agreed to in writing,
14  * software distributed under the License is distributed on an
15  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16  * KIND, either express or implied.  See the License for the
17  * specific language governing permissions and limitations
18  * under the License.
19  *
20  *************************************************************/
21 
22 
23 
24 // MARKER(update_precomp.py): autogen include statement, do not remove
25 #include "precompiled_connectivity.hxx"
26 #include "dbase/DTable.hxx"
27 #include <com/sun/star/sdbc/ColumnValue.hpp>
28 #include <com/sun/star/sdbc/DataType.hpp>
29 #include <com/sun/star/ucb/XContentAccess.hpp>
30 #include <com/sun/star/sdbc/XRow.hpp>
31 #include <svl/converter.hxx>
32 #include "dbase/DConnection.hxx"
33 #include "dbase/DColumns.hxx"
34 #include <osl/thread.h>
35 #include <tools/config.hxx>
36 #include "dbase/DIndex.hxx"
37 #include "dbase/DIndexes.hxx"
38 //#include "file/FDriver.hxx"
39 #include <comphelper/sequence.hxx>
40 #include <svl/zforlist.hxx>
41 #include <unotools/syslocale.hxx>
42 #include <rtl/math.hxx>
43 #include <stdio.h>		//sprintf
44 #include <ucbhelper/content.hxx>
45 #include <comphelper/extract.hxx>
46 #include <connectivity/dbexception.hxx>
47 #include <connectivity/dbconversion.hxx>
48 #include <com/sun/star/lang/DisposedException.hpp>
49 #include <comphelper/property.hxx>
50 //#include <unotools/calendarwrapper.hxx>
51 #include <unotools/tempfile.hxx>
52 #include <unotools/ucbhelper.hxx>
53 #include <comphelper/types.hxx>
54 #include <cppuhelper/exc_hlp.hxx>
55 #include "connectivity/PColumn.hxx"
56 #include "connectivity/dbtools.hxx"
57 #include "connectivity/FValue.hxx"
58 #include "connectivity/dbconversion.hxx"
59 #include "resource/dbase_res.hrc"
60 #include <rtl/logfile.hxx>
61 
62 #include <algorithm>
63 
64 using namespace ::comphelper;
65 using namespace connectivity;
66 using namespace connectivity::sdbcx;
67 using namespace connectivity::dbase;
68 using namespace connectivity::file;
69 using namespace ::ucbhelper;
70 using namespace ::utl;
71 using namespace ::cppu;
72 using namespace ::dbtools;
73 using namespace ::com::sun::star::uno;
74 using namespace ::com::sun::star::ucb;
75 using namespace ::com::sun::star::beans;
76 using namespace ::com::sun::star::sdbcx;
77 using namespace ::com::sun::star::sdbc;
78 using namespace ::com::sun::star::container;
79 using namespace ::com::sun::star::lang;
80 using namespace ::com::sun::star::i18n;
81 
82 // stored as the Field Descriptor terminator
83 #define FIELD_DESCRIPTOR_TERMINATOR 0x0D
84 #define DBF_EOL                     0x1A
85 
86 namespace
87 {
lcl_getFileSize(SvStream & _rStream)88 sal_Int32 lcl_getFileSize(SvStream& _rStream)
89 {
90     sal_Int32 nFileSize = 0;
91     _rStream.Seek(STREAM_SEEK_TO_END);
92     _rStream.SeekRel(-1);
93     char cEOL;
94     _rStream >> cEOL;
95     nFileSize = _rStream.Tell();
96     if ( cEOL == DBF_EOL )
97         nFileSize -= 1;
98     return nFileSize;
99 }
100 /**
101 	calculates the Julian date
102 */
lcl_CalcJulDate(sal_Int32 & _nJulianDate,sal_Int32 & _nJulianTime,const com::sun::star::util::DateTime _aDateTime)103 void lcl_CalcJulDate(sal_Int32& _nJulianDate,sal_Int32& _nJulianTime,const com::sun::star::util::DateTime _aDateTime)
104 {
105     com::sun::star::util::DateTime aDateTime = _aDateTime;
106 	// weird: months fix
107     if (aDateTime.Month > 12)
108 	{
109 	    aDateTime.Month--;
110 	    sal_uInt16 delta = _aDateTime.Month / 12;
111 	    aDateTime.Year += delta;
112 	    aDateTime.Month -= delta * 12;
113 	    aDateTime.Month++;
114 	}
115 
116 	_nJulianTime = ((aDateTime.Hours*3600000)+(aDateTime.Minutes*60000)+(aDateTime.Seconds*1000)+(aDateTime.HundredthSeconds*10));
117 	/* conversion factors */
118 	sal_uInt16 iy0;
119 	sal_uInt16 im0;
120 	if ( aDateTime.Month <= 2 )
121 	{
122 		iy0 = aDateTime.Year - 1;
123 		im0 = aDateTime.Month + 12;
124 	}
125 	else
126 	{
127 		iy0 = aDateTime.Year;
128 		im0 = aDateTime.Month;
129 	}
130 	sal_Int32 ia = iy0 / 100;
131 	sal_Int32 ib = 2 - ia + (ia >> 2);
132 	/* calculate julian date	*/
133 	if ( aDateTime.Year <= 0 )
134     {
135 		_nJulianDate = (sal_Int32) ((365.25 * iy0) - 0.75)
136 			+ (sal_Int32) (30.6001 * (im0 + 1) )
137 			+ aDateTime.Day + 1720994;
138 	} // if ( _aDateTime.Year <= 0 )
139     else
140     {
141 		_nJulianDate = static_cast<sal_Int32>( ((365.25 * iy0)
142 			+ (sal_Int32) (30.6001 * (im0 + 1))
143 			+ aDateTime.Day + 1720994));
144 	}
145     double JD = _nJulianDate + 0.5;
146     _nJulianDate = (sal_Int32)( JD + 0.5);
147     const double gyr = aDateTime.Year + (0.01 * aDateTime.Month) + (0.0001 * aDateTime.Day);
148 	if ( gyr >= 1582.1015 )	/* on or after 15 October 1582	*/
149 		_nJulianDate += ib;
150 }
151 
152 /**
153 	calculates date time from the Julian Date
154 */
lcl_CalDate(sal_Int32 _nJulianDate,sal_Int32 _nJulianTime,com::sun::star::util::DateTime & _rDateTime)155 void lcl_CalDate(sal_Int32 _nJulianDate,sal_Int32 _nJulianTime,com::sun::star::util::DateTime& _rDateTime)
156 {
157     if ( _nJulianDate )
158     {
159         sal_Int32 ialp;
160 	    sal_Int32 ka = _nJulianDate;
161 	    if ( _nJulianDate >= 2299161 )
162 	    {
163 		    ialp = (sal_Int32)( ((double) _nJulianDate - 1867216.25 ) / ( 36524.25 ));
164 		    ka = _nJulianDate + 1 + ialp - ( ialp >> 2 );
165 	    }
166 	    sal_Int32 kb = ka + 1524;
167 	    sal_Int32 kc =  (sal_Int32) ( ((double) kb - 122.1 ) / 365.25 );
168 	    sal_Int32 kd = (sal_Int32) ((double) kc * 365.25);
169 	    sal_Int32 ke = (sal_Int32) ((double) ( kb - kd ) / 30.6001 );
170 	    _rDateTime.Day = static_cast<sal_uInt16>(kb - kd - ((sal_Int32) ( (double) ke * 30.6001 )));
171 	    if ( ke > 13 )
172 		    _rDateTime.Month = static_cast<sal_uInt16>(ke - 13);
173 	    else
174 		    _rDateTime.Month = static_cast<sal_uInt16>(ke - 1);
175 	    if ( (_rDateTime.Month == 2) && (_rDateTime.Day > 28) )
176 		    _rDateTime.Day = 29;
177 	    if ( (_rDateTime.Month == 2) && (_rDateTime.Day == 29) && (ke == 3) )
178 		    _rDateTime.Year = static_cast<sal_uInt16>(kc - 4716);
179 	    else if ( _rDateTime.Month > 2 )
180 		    _rDateTime.Year = static_cast<sal_uInt16>(kc - 4716);
181 	    else
182 		    _rDateTime.Year = static_cast<sal_uInt16>(kc - 4715);
183     } // if ( _nJulianDate )
184 
185     if ( _nJulianTime )
186     {
187         double d_s = _nJulianTime / 1000;
188         double d_m = d_s / 60;
189         double d_h  = d_m / 60;
190         _rDateTime.Hours = (sal_uInt16) (d_h);
191 	    _rDateTime.Minutes = (sal_uInt16) d_m;			// integer _aDateTime.Minutes
192 	    //// weird: time fix
193      //   int test = (_rDateTime.Hours % 3) * 100 + _rDateTime.Minutes;
194 	    //int test_tbl[] = {0, 1, 2, 11, 12, 13, 22, 23, 24, 25, 34, 35, 36,
195 	    //	45, 46, 47, 56, 57, 58, 107, 108, 109, 110, 119, 120, 121,
196 	    //	130, 131, 132, 141, 142, 143, 152, 153, 154, 155, 204, 205,
197 	    //	206, 215, 216, 217, 226, 227, 228, 237, 238, 239, 240, 249,
198 	    //	250, 251};
199      //   for (int i = 0; i < sizeof(test_tbl)/sizeof(test_tbl[0]); i++)
200 	    //{
201 	    //    if (test == test_tbl[i])
202 	    //    {
203 	    //	// frac += 0.000012;
204 	    //	    //d_hour = frac * 24.0;
205 	    //	    _rDateTime.Hours = (sal_uInt16)d_hour;
206 	    //	    d_minute = (d_hour - (double)_rDateTime.Hours) * 60.0;
207 	    //	    _rDateTime.Minutes = (sal_uInt16)d_minute;
208 	    //	    break;
209 	    //    }
210      //   }
211 
212 	    _rDateTime.Seconds = static_cast<sal_uInt16>(( d_m - (double) _rDateTime.Minutes ) * 60.0);
213     }
214 }
215 
216 }
217 
218 // -------------------------------------------------------------------------
readHeader()219 void ODbaseTable::readHeader()
220 {
221     RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbase", "Ocke.Janssen@sun.com", "ODbaseTable::readHeader" );
222 	OSL_ENSURE(m_pFileStream,"No Stream available!");
223 	if(!m_pFileStream)
224 		return;
225 	m_pFileStream->RefreshBuffer(); // sicherstellen, dass die Kopfinformationen tatsaechlich neu gelesen werden
226 	m_pFileStream->Seek(STREAM_SEEK_TO_BEGIN);
227 
228 	sal_uInt8 nType=0;
229 	(*m_pFileStream) >> nType;
230 	if(ERRCODE_NONE != m_pFileStream->GetErrorCode())
231 		throwInvalidDbaseFormat();
232 
233 	m_pFileStream->Read((char*)(&m_aHeader.db_aedat), 3*sizeof(sal_uInt8));
234 	if(ERRCODE_NONE != m_pFileStream->GetErrorCode())
235 		throwInvalidDbaseFormat();
236 	(*m_pFileStream) >> m_aHeader.db_anz;
237 	if(ERRCODE_NONE != m_pFileStream->GetErrorCode())
238 		throwInvalidDbaseFormat();
239 	(*m_pFileStream) >> m_aHeader.db_kopf;
240 	if(ERRCODE_NONE != m_pFileStream->GetErrorCode())
241 		throwInvalidDbaseFormat();
242 	(*m_pFileStream) >> m_aHeader.db_slng;
243 	if(ERRCODE_NONE != m_pFileStream->GetErrorCode())
244 		throwInvalidDbaseFormat();
245 	m_pFileStream->Read((char*)(&m_aHeader.db_frei), 20*sizeof(sal_uInt8));
246 	if(ERRCODE_NONE != m_pFileStream->GetErrorCode())
247 		throwInvalidDbaseFormat();
248 
249     if ( ( ( m_aHeader.db_kopf - 1 ) / 32 - 1 ) <= 0 ) // anzahl felder
250 	{
251 		// no dbase file
252 		throwInvalidDbaseFormat();
253 	}
254 	else
255 	{
256 		// Konsistenzpruefung des Header:
257 		m_aHeader.db_typ = (DBFType)nType;
258 		switch (m_aHeader.db_typ)
259 		{
260 			case dBaseIII:
261 			case dBaseIV:
262 			case dBaseV:
263             case VisualFoxPro:
264             case VisualFoxProAuto:
265 			case dBaseFS:
266 			case dBaseFSMemo:
267 			case dBaseIVMemoSQL:
268 			case dBaseIIIMemo:
269 			case FoxProMemo:
270 				m_pFileStream->SetNumberFormatInt(NUMBERFORMAT_INT_LITTLEENDIAN);
271                 if ( m_aHeader.db_frei[17] != 0x00
272                     && !m_aHeader.db_frei[18] && !m_aHeader.db_frei[19] && getConnection()->isTextEncodingDefaulted() )
273                 {
274                     switch(m_aHeader.db_frei[17])
275                     {
276                         case 0x01: m_eEncoding = RTL_TEXTENCODING_IBM_437; break; 	    // DOS USA	code page 437
277                         case 0x02: m_eEncoding = RTL_TEXTENCODING_IBM_850; break; 	    // DOS Multilingual	code page 850
278                         case 0x03: m_eEncoding = RTL_TEXTENCODING_MS_1252; break; 	    // Windows ANSI	code page 1252
279                         case 0x04: m_eEncoding = RTL_TEXTENCODING_APPLE_ROMAN; break; 	// Standard Macintosh
280                         case 0x64: m_eEncoding = RTL_TEXTENCODING_IBM_852; break; 	    // EE MS-DOS	code page 852
281                         case 0x65: m_eEncoding = RTL_TEXTENCODING_IBM_865; break; 	    // Nordic MS-DOS	code page 865
282                         case 0x66: m_eEncoding = RTL_TEXTENCODING_IBM_866; break; 	    // Russian MS-DOS	code page 866
283                         case 0x67: m_eEncoding = RTL_TEXTENCODING_IBM_861; break; 	    // Icelandic MS-DOS
284                         //case 0x68: m_eEncoding = ; break; 	// Kamenicky (Czech) MS-DOS
285                         //case 0x69: m_eEncoding = ; break; 	// Mazovia (Polish) MS-DOS
286                         case 0x6A: m_eEncoding = RTL_TEXTENCODING_IBM_737; break; 	    // Greek MS-DOS (437G)
287                         case 0x6B: m_eEncoding = RTL_TEXTENCODING_IBM_857; break; 	    // Turkish MS-DOS
288                         case 0x96: m_eEncoding = RTL_TEXTENCODING_APPLE_CYRILLIC; break; 	// Russian Macintosh
289                         case 0x97: m_eEncoding = RTL_TEXTENCODING_APPLE_CENTEURO; break; 	// Eastern European Macintosh
290                         case 0x98: m_eEncoding = RTL_TEXTENCODING_APPLE_GREEK; break; 	// Greek Macintosh
291                         case 0xC8: m_eEncoding = RTL_TEXTENCODING_MS_1250; break; 	    // Windows EE	code page 1250
292                         case 0xC9: m_eEncoding = RTL_TEXTENCODING_MS_1251; break; 	    // Russian Windows
293                         case 0xCA: m_eEncoding = RTL_TEXTENCODING_MS_1254; break; 	    // Turkish Windows
294                         case 0xCB: m_eEncoding = RTL_TEXTENCODING_MS_1253; break; 	    // Greek Windows
295                         default:
296                             break;
297                     }
298                 }
299 				break;
300             case dBaseIVMemo:
301                 m_pFileStream->SetNumberFormatInt(NUMBERFORMAT_INT_LITTLEENDIAN);
302                 break;
303 			default:
304 			{
305 				throwInvalidDbaseFormat();
306 			}
307 		}
308 	}
309 }
310 // -------------------------------------------------------------------------
fillColumns()311 void ODbaseTable::fillColumns()
312 {
313     RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbase", "Ocke.Janssen@sun.com", "ODbaseTable::fillColumns" );
314 	m_pFileStream->Seek(STREAM_SEEK_TO_BEGIN);
315 	m_pFileStream->Seek(32L);
316 
317 	if(!m_aColumns.isValid())
318 		m_aColumns = new OSQLColumns();
319 	else
320 		m_aColumns->get().clear();
321 
322 	m_aTypes.clear();
323 	m_aPrecisions.clear();
324 	m_aScales.clear();
325 
326 	// Anzahl Felder:
327 	const sal_Int32 nFieldCount = (m_aHeader.db_kopf - 1) / 32 - 1;
328 	OSL_ENSURE(nFieldCount,"No columns in table!");
329 
330 	m_aColumns->get().reserve(nFieldCount);
331 	m_aTypes.reserve(nFieldCount);
332 	m_aPrecisions.reserve(nFieldCount);
333 	m_aScales.reserve(nFieldCount);
334 
335 	String aStrFieldName;
336 	aStrFieldName.AssignAscii("Column");
337 	::rtl::OUString aTypeName;
338     static const ::rtl::OUString sVARCHAR(RTL_CONSTASCII_USTRINGPARAM("VARCHAR"));
339 	const sal_Bool bCase = getConnection()->getMetaData()->supportsMixedCaseQuotedIdentifiers();
340     const bool bFoxPro = m_aHeader.db_typ == VisualFoxPro || m_aHeader.db_typ == VisualFoxProAuto || m_aHeader.db_typ == FoxProMemo;
341 
342     sal_Int32 i = 0;
343 	for (; i < nFieldCount; i++)
344 	{
345 		DBFColumn aDBFColumn;
346 		m_pFileStream->Read((char*)&aDBFColumn, sizeof(aDBFColumn));
347         if ( FIELD_DESCRIPTOR_TERMINATOR == aDBFColumn.db_fnm[0] ) // 0x0D stored as the Field Descriptor terminator.
348             break;
349 
350         sal_Bool bIsRowVersion = bFoxPro && ( aDBFColumn.db_frei2[0] & 0x01 ) == 0x01;
351         //if ( bFoxPro && ( aDBFColumn.db_frei2[0] & 0x01 ) == 0x01 ) // system column not visible to user
352         //    continue;
353 		const String aColumnName((const char *)aDBFColumn.db_fnm,m_eEncoding);
354 
355         m_aRealFieldLengths.push_back(aDBFColumn.db_flng);
356 		sal_Int32 nPrecision = aDBFColumn.db_flng;
357 		sal_Int32 eType;
358         sal_Bool bIsCurrency = sal_False;
359 
360         char cType[2];
361         cType[0] = aDBFColumn.db_typ;
362         cType[1] = 0;
363         aTypeName = ::rtl::OUString::createFromAscii(cType);
364 OSL_TRACE("column type: %c",aDBFColumn.db_typ);
365 
366 		switch (aDBFColumn.db_typ)
367 		{
368 			case 'C':
369 				eType = DataType::VARCHAR;
370                 aTypeName = ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("VARCHAR"));
371 				break;
372 			case 'F':
373                 aTypeName = ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("DECIMAL"));
374 			case 'N':
375                 if ( aDBFColumn.db_typ == 'N' )
376                     aTypeName = ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("NUMERIC"));
377 				eType = DataType::DECIMAL;
378 
379 				// Bei numerischen Feldern werden zwei Zeichen mehr geschrieben, als die Precision der Spaltenbeschreibung eigentlich
380 				// angibt, um Platz fuer das eventuelle Vorzeichen und das Komma zu haben. Das muss ich jetzt aber wieder rausrechnen.
381 				nPrecision = SvDbaseConverter::ConvertPrecisionToOdbc(nPrecision,aDBFColumn.db_dez);
382 					// leider gilt das eben Gesagte nicht fuer aeltere Versionen ....
383 				break;
384 			case 'L':
385 				eType = DataType::BIT;
386                 aTypeName = ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("BOOLEAN"));
387 				break;
388             case 'Y':
389                 bIsCurrency = sal_True;
390 				eType = DataType::DOUBLE;
391                 aTypeName = ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("DOUBLE"));
392 				break;
393 			case 'D':
394 				eType = DataType::DATE;
395                 aTypeName = ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("DATE"));
396 				break;
397             case 'T':
398 				eType = DataType::TIMESTAMP;
399                 aTypeName = ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("TIMESTAMP"));
400 				break;
401             case 'I':
402 				eType = DataType::INTEGER;
403                 aTypeName = ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("INTEGER"));
404 				break;
405 			case 'M':
406                 if ( bFoxPro && ( aDBFColumn.db_frei2[0] & 0x04 ) == 0x04 )
407                 {
408 				    eType = DataType::LONGVARBINARY;
409                     aTypeName = ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("LONGVARBINARY"));
410                 }
411                 else
412                 {
413                     aTypeName = ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("LONGVARCHAR"));
414                     eType = DataType::LONGVARCHAR;
415                 }
416 				nPrecision = 2147483647;
417 				break;
418             case 'P':
419                 aTypeName = ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("LONGVARBINARY"));
420 				eType = DataType::LONGVARBINARY;
421 				nPrecision = 2147483647;
422 				break;
423             case '0':
424             case 'B':
425                 if ( m_aHeader.db_typ == VisualFoxPro || m_aHeader.db_typ == VisualFoxProAuto )
426                 {
427                     aTypeName = ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("DOUBLE"));
428                     eType = DataType::DOUBLE;
429                 }
430                 else
431                 {
432                     aTypeName = ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("LONGVARBINARY"));
433                     eType = DataType::LONGVARBINARY;
434 				    nPrecision = 2147483647;
435                 }
436 				break;
437 			default:
438 				eType = DataType::OTHER;
439 		}
440 
441 		m_aTypes.push_back(eType);
442 		m_aPrecisions.push_back(nPrecision);
443 		m_aScales.push_back(aDBFColumn.db_dez);
444 
445 		Reference< XPropertySet> xCol = new sdbcx::OColumn(aColumnName,
446 													aTypeName,
447 													::rtl::OUString(),
448                                                     ::rtl::OUString(),
449 													ColumnValue::NULLABLE,
450 													nPrecision,
451 													aDBFColumn.db_dez,
452 													eType,
453 													sal_False,
454 													bIsRowVersion,
455 													bIsCurrency,
456 													bCase);
457 		m_aColumns->get().push_back(xCol);
458 	} // for (; i < nFieldCount; i++)
459     OSL_ENSURE(i,"No columns in table!");
460 }
461 // -------------------------------------------------------------------------
ODbaseTable(sdbcx::OCollection * _pTables,ODbaseConnection * _pConnection)462 ODbaseTable::ODbaseTable(sdbcx::OCollection* _pTables,ODbaseConnection* _pConnection)
463 		:ODbaseTable_BASE(_pTables,_pConnection)
464 		,m_pMemoStream(NULL)
465 		,m_bWriteableMemo(sal_False)
466 {
467     RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbase", "Ocke.Janssen@sun.com", "ODbaseTable::ODbaseTable" );
468 	// initialize the header
469 	m_aHeader.db_typ	= dBaseIII;
470 	m_aHeader.db_anz	= 0;
471 	m_aHeader.db_kopf	= 0;
472 	m_aHeader.db_slng	= 0;
473     m_eEncoding = getConnection()->getTextEncoding();
474 }
475 // -------------------------------------------------------------------------
ODbaseTable(sdbcx::OCollection * _pTables,ODbaseConnection * _pConnection,const::rtl::OUString & _Name,const::rtl::OUString & _Type,const::rtl::OUString & _Description,const::rtl::OUString & _SchemaName,const::rtl::OUString & _CatalogName)476 ODbaseTable::ODbaseTable(sdbcx::OCollection* _pTables,ODbaseConnection* _pConnection,
477 					const ::rtl::OUString& _Name,
478 					const ::rtl::OUString& _Type,
479 					const ::rtl::OUString& _Description ,
480 					const ::rtl::OUString& _SchemaName,
481 					const ::rtl::OUString& _CatalogName
482 				) : ODbaseTable_BASE(_pTables,_pConnection,_Name,
483 								  _Type,
484 								  _Description,
485 								  _SchemaName,
486 								  _CatalogName)
487 				,m_pMemoStream(NULL)
488 				,m_bWriteableMemo(sal_False)
489 {
490     RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbase", "Ocke.Janssen@sun.com", "ODbaseTable::ODbaseTable" );
491     m_eEncoding = getConnection()->getTextEncoding();
492 }
493 
494 // -----------------------------------------------------------------------------
construct()495 void ODbaseTable::construct()
496 {
497     RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbase", "Ocke.Janssen@sun.com", "ODbaseTable::construct" );
498 	// initialize the header
499 	m_aHeader.db_typ	= dBaseIII;
500 	m_aHeader.db_anz	= 0;
501 	m_aHeader.db_kopf	= 0;
502 	m_aHeader.db_slng	= 0;
503     m_aMemoHeader.db_size = 0;
504 
505 	String sFileName(getEntry(m_pConnection,m_Name));
506 
507 	INetURLObject aURL;
508 	aURL.SetURL(sFileName);
509 
510 	OSL_ENSURE( m_pConnection->matchesExtension( aURL.getExtension() ),
511 		"ODbaseTable::ODbaseTable: invalid extension!");
512 		// getEntry is expected to ensure the corect file name
513 
514 	m_pFileStream = createStream_simpleError( sFileName, STREAM_READWRITE | STREAM_NOCREATE | STREAM_SHARE_DENYWRITE);
515 	m_bWriteable = ( m_pFileStream != NULL );
516 
517     if ( !m_pFileStream )
518     {
519         m_bWriteable = sal_False;
520 		m_pFileStream = createStream_simpleError( sFileName, STREAM_READ | STREAM_NOCREATE | STREAM_SHARE_DENYNONE);
521     }
522 
523 	if(m_pFileStream)
524 	{
525 		readHeader();
526 		if (HasMemoFields())
527 		{
528 			// Memo-Dateinamen bilden (.DBT):
529 			// nyi: Unschoen fuer Unix und Mac!
530 
531 			if ( m_aHeader.db_typ == FoxProMemo || VisualFoxPro == m_aHeader.db_typ || VisualFoxProAuto == m_aHeader.db_typ ) // foxpro uses another extension
532 				aURL.SetExtension(String::CreateFromAscii("fpt"));
533 			else
534 				aURL.SetExtension(String::CreateFromAscii("dbt"));
535 
536 			// Wenn die Memodatei nicht gefunden wird, werden die Daten trotzdem angezeigt
537 			// allerdings koennen keine Updates durchgefuehrt werden
538 			// jedoch die Operation wird ausgefuehrt
539 			m_pMemoStream = createStream_simpleError( aURL.GetMainURL(INetURLObject::NO_DECODE), STREAM_READWRITE | STREAM_NOCREATE | STREAM_SHARE_DENYWRITE);
540             if ( !m_pMemoStream )
541             {
542                 m_bWriteableMemo = sal_False;
543 				m_pMemoStream = createStream_simpleError( aURL.GetMainURL(INetURLObject::NO_DECODE), STREAM_READ | STREAM_NOCREATE | STREAM_SHARE_DENYNONE);
544             }
545 			if (m_pMemoStream)
546 				ReadMemoHeader();
547 		}
548 		//	if(!m_pColumns && (!m_aColumns.isValid() || !m_aColumns->size()))
549 		fillColumns();
550 
551 		sal_uInt32 nFileSize = lcl_getFileSize(*m_pFileStream);
552 		m_pFileStream->Seek(STREAM_SEEK_TO_BEGIN);
553         if ( m_aHeader.db_anz == 0 && ((nFileSize-m_aHeader.db_kopf)/m_aHeader.db_slng) > 0) // seems to be empty or someone wrote bullshit into the dbase file
554             m_aHeader.db_anz = ((nFileSize-m_aHeader.db_kopf)/m_aHeader.db_slng);
555 
556 		// Buffersize abhaengig von der Filegroesse
557 		m_pFileStream->SetBufferSize(nFileSize > 1000000 ? 32768 :
558 								  nFileSize > 100000 ? 16384 :
559 								  nFileSize > 10000 ? 4096 : 1024);
560 
561 		if (m_pMemoStream)
562 		{
563 			// Puffer genau auf Laenge eines Satzes stellen
564 			m_pMemoStream->Seek(STREAM_SEEK_TO_END);
565 			nFileSize = m_pMemoStream->Tell();
566 			m_pMemoStream->Seek(STREAM_SEEK_TO_BEGIN);
567 
568 			// Buffersize abhaengig von der Filegroesse
569 			m_pMemoStream->SetBufferSize(nFileSize > 1000000 ? 32768 :
570 										  nFileSize > 100000 ? 16384 :
571 										  nFileSize > 10000 ? 4096 :
572 										  m_aMemoHeader.db_size);
573 		}
574 
575 		AllocBuffer();
576 	}
577 }
578 //------------------------------------------------------------------
ReadMemoHeader()579 sal_Bool ODbaseTable::ReadMemoHeader()
580 {
581     RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbase", "Ocke.Janssen@sun.com", "ODbaseTable::ReadMemoHeader" );
582 	m_pMemoStream->SetNumberFormatInt(NUMBERFORMAT_INT_LITTLEENDIAN);
583 	m_pMemoStream->RefreshBuffer();			// sicherstellen das die Kopfinformationen tatsaechlich neu gelesen werden
584 	m_pMemoStream->Seek(0L);
585 
586 	(*m_pMemoStream) >> m_aMemoHeader.db_next;
587 	switch (m_aHeader.db_typ)
588 	{
589         case dBaseIIIMemo:  // dBase III: feste Blockgroesse
590 		case dBaseIVMemo:
591 			// manchmal wird aber auch dBase3 dBase4 Memo zugeordnet
592 			m_pMemoStream->Seek(20L);
593 			(*m_pMemoStream) >> m_aMemoHeader.db_size;
594 			if (m_aMemoHeader.db_size > 1 && m_aMemoHeader.db_size != 512)	// 1 steht auch fuer dBase 3
595 				m_aMemoHeader.db_typ  = MemodBaseIV;
596 			else if (m_aMemoHeader.db_size > 1 && m_aMemoHeader.db_size == 512)
597 			{
598                 // nun gibt es noch manche Dateien, die verwenden eine Groessenangabe,
599 				// sind aber dennoch dBase Dateien
600 				char sHeader[4];
601 				m_pMemoStream->Seek(m_aMemoHeader.db_size);
602 				m_pMemoStream->Read(sHeader,4);
603 
604 				if ((m_pMemoStream->GetErrorCode() != ERRCODE_NONE) || ((sal_uInt8)sHeader[0]) != 0xFF || ((sal_uInt8)sHeader[1]) != 0xFF || ((sal_uInt8)sHeader[2]) != 0x08)
605 					m_aMemoHeader.db_typ  = MemodBaseIII;
606 				else
607 					m_aMemoHeader.db_typ  = MemodBaseIV;
608 			}
609 			else
610 			{
611 				m_aMemoHeader.db_typ  = MemodBaseIII;
612 				m_aMemoHeader.db_size = 512;
613 			}
614 			break;
615         case VisualFoxPro:
616         case VisualFoxProAuto:
617 		case FoxProMemo:
618 			m_aMemoHeader.db_typ	= MemoFoxPro;
619 			m_pMemoStream->Seek(6L);
620 			m_pMemoStream->SetNumberFormatInt(NUMBERFORMAT_INT_BIGENDIAN);
621 			(*m_pMemoStream) >> m_aMemoHeader.db_size;
622             break;
623         default:
624             OSL_ENSURE( false, "ODbaseTable::ReadMemoHeader: unsupported memo type!" );
625             break;
626 	}
627 	return sal_True;
628 }
629 // -------------------------------------------------------------------------
getEntry(OConnection * _pConnection,const::rtl::OUString & _sName)630 String ODbaseTable::getEntry(OConnection* _pConnection,const ::rtl::OUString& _sName )
631 {
632     RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbase", "Ocke.Janssen@sun.com", "ODbaseTable::getEntry" );
633 	::rtl::OUString sURL;
634 	try
635 	{
636 		Reference< XResultSet > xDir = _pConnection->getDir()->getStaticResultSet();
637 		Reference< XRow> xRow(xDir,UNO_QUERY);
638 		::rtl::OUString sName;
639 		::rtl::OUString sExt;
640 		INetURLObject aURL;
641 		static const ::rtl::OUString s_sSeparator(RTL_CONSTASCII_USTRINGPARAM("/"));
642 		xDir->beforeFirst();
643 		while(xDir->next())
644 		{
645 			sName = xRow->getString(1);
646 			aURL.SetSmartProtocol(INET_PROT_FILE);
647 			String sUrl = _pConnection->getURL() +  s_sSeparator + sName;
648 			aURL.SetSmartURL( sUrl );
649 
650 			// cut the extension
651 			sExt = aURL.getExtension();
652 
653 			// name and extension have to coincide
654 			if ( _pConnection->matchesExtension( sExt ) )
655 			{
656 				sName = sName.replaceAt(sName.getLength()-(sExt.getLength()+1),sExt.getLength()+1,::rtl::OUString());
657 				if ( sName == _sName )
658 				{
659 					Reference< XContentAccess > xContentAccess( xDir, UNO_QUERY );
660 					sURL = xContentAccess->queryContentIdentifierString();
661 					break;
662 				}
663 			}
664 		}
665 		xDir->beforeFirst(); // move back to before first record
666 	}
667 	catch(Exception&)
668 	{
669 		OSL_ASSERT(0);
670 	}
671 	return sURL;
672 }
673 // -------------------------------------------------------------------------
refreshColumns()674 void ODbaseTable::refreshColumns()
675 {
676     RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbase", "Ocke.Janssen@sun.com", "ODbaseTable::refreshColumns" );
677 	::osl::MutexGuard aGuard( m_aMutex );
678 
679 	TStringVector aVector;
680 	aVector.reserve(m_aColumns->get().size());
681 
682 	for(OSQLColumns::Vector::const_iterator aIter = m_aColumns->get().begin();aIter != m_aColumns->get().end();++aIter)
683 		aVector.push_back(Reference< XNamed>(*aIter,UNO_QUERY)->getName());
684 
685 	if(m_pColumns)
686 		m_pColumns->reFill(aVector);
687 	else
688 		m_pColumns	= new ODbaseColumns(this,m_aMutex,aVector);
689 }
690 // -------------------------------------------------------------------------
refreshIndexes()691 void ODbaseTable::refreshIndexes()
692 {
693     RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbase", "Ocke.Janssen@sun.com", "ODbaseTable::refreshIndexes" );
694 	TStringVector aVector;
695 	if(m_pFileStream && (!m_pIndexes || m_pIndexes->getCount() == 0))
696 	{
697 		INetURLObject aURL;
698 		aURL.SetURL(getEntry(m_pConnection,m_Name));
699 
700 		aURL.setExtension(String::CreateFromAscii("inf"));
701 		Config aInfFile(aURL.getFSysPath(INetURLObject::FSYS_DETECT));
702 		aInfFile.SetGroup(dBASE_III_GROUP);
703 		sal_uInt16 nKeyCnt = aInfFile.GetKeyCount();
704 		ByteString aKeyName;
705 		ByteString aIndexName;
706 
707 		for (sal_uInt16 nKey = 0; nKey < nKeyCnt; nKey++)
708 		{
709 			// Verweist der Key auf ein Indexfile?...
710 			aKeyName = aInfFile.GetKeyName( nKey );
711 			//...wenn ja, Indexliste der Tabelle hinzufuegen
712 			if (aKeyName.Copy(0,3) == ByteString("NDX") )
713 			{
714 				aIndexName = aInfFile.ReadKey(aKeyName);
715 				aURL.setName(String(aIndexName,m_eEncoding));
716 				try
717 				{
718 					Content aCnt(aURL.GetMainURL(INetURLObject::NO_DECODE),Reference<XCommandEnvironment>());
719 					if (aCnt.isDocument())
720 					{
721 						aVector.push_back(aURL.getBase());
722 					}
723 				}
724 				catch(Exception&) // a execption is thrown when no file exists
725 				{
726 				}
727 			}
728 		}
729 	}
730 	if(m_pIndexes)
731 		m_pIndexes->reFill(aVector);
732 	else
733 		m_pIndexes	= new ODbaseIndexes(this,m_aMutex,aVector);
734 }
735 
736 // -------------------------------------------------------------------------
disposing(void)737 void SAL_CALL ODbaseTable::disposing(void)
738 {
739     RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbase", "Ocke.Janssen@sun.com", "ODbaseTable::disposing" );
740 	OFileTable::disposing();
741 	::osl::MutexGuard aGuard(m_aMutex);
742 	m_aColumns = NULL;
743 }
744 // -------------------------------------------------------------------------
getTypes()745 Sequence< Type > SAL_CALL ODbaseTable::getTypes(  ) throw(RuntimeException)
746 {
747     RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbase", "Ocke.Janssen@sun.com", "ODbaseTable::getTypes" );
748 	Sequence< Type > aTypes = OTable_TYPEDEF::getTypes();
749 	::std::vector<Type> aOwnTypes;
750 	aOwnTypes.reserve(aTypes.getLength());
751 
752 	const Type* pBegin = aTypes.getConstArray();
753 	const Type* pEnd = pBegin + aTypes.getLength();
754 	for(;pBegin != pEnd;++pBegin)
755 	{
756 		if(!(*pBegin == ::getCppuType((const Reference<XKeysSupplier>*)0)	||
757 			//	*pBegin == ::getCppuType((const Reference<XAlterTable>*)0)	||
758 			*pBegin == ::getCppuType((const Reference<XDataDescriptorFactory>*)0)))
759 		{
760 			aOwnTypes.push_back(*pBegin);
761 		}
762 	}
763 	aOwnTypes.push_back(::getCppuType( (const Reference< ::com::sun::star::lang::XUnoTunnel > *)0 ));
764 	Type *pTypes = aOwnTypes.empty() ? 0 : &aOwnTypes[0];
765 	return Sequence< Type >(pTypes, aOwnTypes.size());
766 }
767 
768 // -------------------------------------------------------------------------
queryInterface(const Type & rType)769 Any SAL_CALL ODbaseTable::queryInterface( const Type & rType ) throw(RuntimeException)
770 {
771     RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbase", "Ocke.Janssen@sun.com", "ODbaseTable::queryInterface" );
772 	if( rType == ::getCppuType((const Reference<XKeysSupplier>*)0)	||
773 		rType == ::getCppuType((const Reference<XDataDescriptorFactory>*)0))
774 		return Any();
775 
776 	Any aRet = OTable_TYPEDEF::queryInterface(rType);
777 	return aRet.hasValue() ? aRet : ::cppu::queryInterface(rType,static_cast< ::com::sun::star::lang::XUnoTunnel*> (this));
778 }
779 
780 //--------------------------------------------------------------------------
getUnoTunnelImplementationId()781 Sequence< sal_Int8 > ODbaseTable::getUnoTunnelImplementationId()
782 {
783     RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbase", "Ocke.Janssen@sun.com", "ODbaseTable::getUnoTunnelImplementationId" );
784 	static ::cppu::OImplementationId * pId = 0;
785 	if (! pId)
786 	{
787 		::osl::MutexGuard aGuard( ::osl::Mutex::getGlobalMutex() );
788 		if (! pId)
789 		{
790 			static ::cppu::OImplementationId aId;
791 			pId = &aId;
792 		}
793 	}
794 	return pId->getImplementationId();
795 }
796 
797 // com::sun::star::lang::XUnoTunnel
798 //------------------------------------------------------------------
getSomething(const Sequence<sal_Int8> & rId)799 sal_Int64 ODbaseTable::getSomething( const Sequence< sal_Int8 > & rId ) throw (RuntimeException)
800 {
801     RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbase", "Ocke.Janssen@sun.com", "ODbaseTable::getSomething" );
802 	return (rId.getLength() == 16 && 0 == rtl_compareMemory(getUnoTunnelImplementationId().getConstArray(),  rId.getConstArray(), 16 ) )
803 				? reinterpret_cast< sal_Int64 >( this )
804 				: ODbaseTable_BASE::getSomething(rId);
805 }
806 //------------------------------------------------------------------
fetchRow(OValueRefRow & _rRow,const OSQLColumns & _rCols,sal_Bool _bUseTableDefs,sal_Bool bRetrieveData)807 sal_Bool ODbaseTable::fetchRow(OValueRefRow& _rRow,const OSQLColumns & _rCols, sal_Bool _bUseTableDefs,sal_Bool bRetrieveData)
808 {
809     RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbase", "Ocke.Janssen@sun.com", "ODbaseTable::fetchRow" );
810 	// Einlesen der Daten
811 	sal_Bool bIsCurRecordDeleted = ((char)m_pBuffer[0] == '*') ? sal_True : sal_False;
812 
813 	// only read the bookmark
814 
815 	// Satz als geloescht markieren
816 	//	rRow.setState(bIsCurRecordDeleted ? ROW_DELETED : ROW_CLEAN );
817 	_rRow->setDeleted(bIsCurRecordDeleted);
818 	*(_rRow->get())[0] = m_nFilePos;
819 
820 	if (!bRetrieveData)
821 		return sal_True;
822 
823 	sal_Size nByteOffset = 1;
824 	// Felder:
825 	OSQLColumns::Vector::const_iterator aIter = _rCols.get().begin();
826     OSQLColumns::Vector::const_iterator aEnd  = _rCols.get().end();
827     const sal_Size nCount = _rRow->get().size();
828 	for (sal_Size i = 1; aIter != aEnd && nByteOffset <= m_nBufferSize && i < nCount;++aIter, i++)
829 	{
830 		// Laengen je nach Datentyp:
831 		sal_Int32 nLen = 0;
832 		sal_Int32 nType = 0;
833 		if(_bUseTableDefs)
834 		{
835 			nLen	= m_aPrecisions[i-1];
836 			nType	= m_aTypes[i-1];
837 		}
838 		else
839 		{
840 			(*aIter)->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_PRECISION))	>>= nLen;
841 			(*aIter)->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_TYPE))		>>= nType;
842 		}
843 		switch(nType)
844 		{
845             case DataType::INTEGER:
846             case DataType::DOUBLE:
847             case DataType::TIMESTAMP:
848 			case DataType::DATE:
849             case DataType::BIT:
850 			case DataType::LONGVARCHAR:
851             case DataType::LONGVARBINARY:
852                 nLen = m_aRealFieldLengths[i-1];
853                 break;
854 			case DataType::DECIMAL:
855 				if(_bUseTableDefs)
856 					nLen = SvDbaseConverter::ConvertPrecisionToDbase(nLen,m_aScales[i-1]);
857 				else
858 					nLen = SvDbaseConverter::ConvertPrecisionToDbase(nLen,getINT32((*aIter)->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_SCALE))));
859 				break;	// das Vorzeichen und das Komma
860 
861             case DataType::BINARY:
862 			case DataType::OTHER:
863 				nByteOffset += nLen;
864 				continue;
865 		}
866 
867 		// Ist die Variable ueberhaupt gebunden?
868 		if ( !(_rRow->get())[i]->isBound() )
869 		{
870 			// Nein - naechstes Feld.
871 			nByteOffset += nLen;
872 			OSL_ENSURE( nByteOffset <= m_nBufferSize ,"ByteOffset > m_nBufferSize!");
873 			continue;
874 		} // if ( !(_rRow->get())[i]->isBound() )
875         if ( ( nByteOffset + nLen) > m_nBufferSize )
876             break; // length doesn't match buffer size.
877 
878 		char *pData = (char *) (m_pBuffer + nByteOffset);
879 
880 		//	(*_rRow)[i].setType(nType);
881 
882 		if (nType == DataType::CHAR || nType == DataType::VARCHAR)
883 		{
884 			char cLast = pData[nLen];
885 			pData[nLen] = 0;
886 			String aStr(pData,(xub_StrLen)nLen,m_eEncoding);
887 			aStr.EraseTrailingChars();
888 
889 			if ( aStr.Len() )
890                 *(_rRow->get())[i] = ::rtl::OUString(aStr);
891 			else// keine StringLaenge, dann NULL
892                 (_rRow->get())[i]->setNull();
893 
894 			pData[nLen] = cLast;
895 		} // if (nType == DataType::CHAR || nType == DataType::VARCHAR)
896         else if ( DataType::TIMESTAMP == nType )
897         {
898             sal_Int32 nDate = 0,nTime = 0;
899             OSL_ENSURE(nLen == 8, "Invalid length for date field");
900             if (nLen >= 8) {
901                 memcpy(&nDate, pData, 4);
902                 memcpy(&nTime, pData+ 4, 4);
903             }
904             if ( !nDate && !nTime )
905             {
906                 (_rRow->get())[i]->setNull();
907             }
908             else
909             {
910                 ::com::sun::star::util::DateTime aDateTime;
911                 lcl_CalDate(nDate,nTime,aDateTime);
912                 *(_rRow->get())[i] = aDateTime;
913             }
914         }
915         else if ( DataType::INTEGER == nType )
916         {
917             OSL_ENSURE(nLen == 4, "Invalid length for integer field");
918             if (nLen >= 4) {
919                 sal_Int32 nValue = 0;
920                 memcpy(&nValue, pData, 4);
921                 *(_rRow->get())[i] = nValue;
922             } else {
923                 (_rRow->get())[i]->setNull();
924             }
925         }
926         else if ( DataType::DOUBLE == nType )
927         {
928             double d = 0.0;
929             OSL_ENSURE(nLen == 8, "Invalid length for double field");
930             if (nLen >= 8) {
931                 if (getBOOL((*aIter)->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_ISCURRENCY)))) // Currency needs special treatment
932                     {
933                         sal_Int64 nValue = 0;
934                         memcpy(&nValue, pData, nLen);
935 
936                         if ( m_aScales[i-1] )
937                             d = (double)(nValue / pow(10.0,(int)m_aScales[i-1]));
938                         else
939                             d = (double)(nValue);
940                     }
941                 else
942                     {
943                         memcpy(&d, pData, nLen);
944                     }
945 
946                 *(_rRow->get())[i] = d;
947             } else {
948                 (_rRow->get())[i]->setNull();
949             }
950         }
951 		else
952 		{
953 			// Change any nulls into spaces
954 			for (sal_Int32 k = 0; k < nLen; k++)
955 			{
956 				if (pData[k] == '\0')
957 					pData[k] = ' ';
958 			}
959 
960 			String aStr(pData, (xub_StrLen)nLen,m_eEncoding);		// Strip spaces from beginning and end
961 			aStr.EraseLeadingChars();
962 			aStr.EraseTrailingChars();
963 
964 			if (!aStr.Len())
965 			{
966 				nByteOffset += nLen;
967 				(_rRow->get())[i]->setNull();	// no value -> we are done
968 				continue;
969 			}
970 
971 			switch (nType)
972 			{
973 				case DataType::DATE:
974 				{
975                     OSL_ENSURE(nLen == 8, "Invalid length for date field");
976 					if ((nLen < 8) || (aStr.Len() != nLen)) {
977 						(_rRow->get())[i]->setNull();
978 						break;
979 					}
980 					const sal_uInt16  nYear   = (sal_uInt16)aStr.Copy( 0, 4 ).ToInt32();
981 					const sal_uInt16  nMonth  = (sal_uInt16)aStr.Copy( 4, 2 ).ToInt32();
982 					const sal_uInt16  nDay    = (sal_uInt16)aStr.Copy( 6, 2 ).ToInt32();
983 
984 					const ::com::sun::star::util::Date aDate(nDay,nMonth,nYear);
985 					*(_rRow->get())[i] = aDate;
986 				}
987 				break;
988 				case DataType::DECIMAL:
989 					*(_rRow->get())[i] = ORowSetValue(aStr);
990 					//	pVal->setDouble(SdbTools::ToDouble(aStr));
991 				break;
992 				case DataType::BIT:
993 				{
994                     OSL_ENSURE(nLen == 1, "Invalid length for bit field");
995                     if (nLen < 1) {
996 						(_rRow->get())[i]->setNull();
997 						break;
998                     }
999 					sal_Bool b;
1000 					switch (* ((const char *)pData))
1001 					{
1002 						case 'T':
1003 						case 'Y':
1004 						case 'J':	b = sal_True; break;
1005 						default: 	b = sal_False; break;
1006 					}
1007 					*(_rRow->get())[i] = b;
1008 					//	pVal->setDouble(b);
1009 				}
1010 				break;
1011                 case DataType::LONGVARBINARY:
1012                 case DataType::BINARY:
1013 				case DataType::LONGVARCHAR:
1014 				{
1015 					const long nBlockNo = aStr.ToInt32();	// Blocknummer lesen
1016 					if (nBlockNo > 0 && m_pMemoStream) // Daten aus Memo-Datei lesen, nur wenn
1017 					{
1018 						if ( !ReadMemo(nBlockNo, (_rRow->get())[i]->get()) )
1019 							break;
1020 					}
1021 					else
1022 						(_rRow->get())[i]->setNull();
1023 				}	break;
1024 				default:
1025 					OSL_ASSERT("Wrong type");
1026 			}
1027 			(_rRow->get())[i]->setTypeKind(nType);
1028 		}
1029 
1030 		nByteOffset += nLen;
1031 		OSL_ENSURE( nByteOffset <= m_nBufferSize ,"ByteOffset > m_nBufferSize!");
1032 	}
1033 	return sal_True;
1034 }
1035 //------------------------------------------------------------------
1036 // -------------------------------------------------------------------------
FileClose()1037 void ODbaseTable::FileClose()
1038 {
1039     RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbase", "Ocke.Janssen@sun.com", "ODbaseTable::FileClose" );
1040 	::osl::MutexGuard aGuard(m_aMutex);
1041 	// falls noch nicht alles geschrieben wurde
1042 	if (m_pMemoStream && m_pMemoStream->IsWritable())
1043 		m_pMemoStream->Flush();
1044 
1045 	delete m_pMemoStream;
1046 	m_pMemoStream = NULL;
1047 
1048 	ODbaseTable_BASE::FileClose();
1049 }
1050 // -------------------------------------------------------------------------
CreateImpl()1051 sal_Bool ODbaseTable::CreateImpl()
1052 {
1053     RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbase", "Ocke.Janssen@sun.com", "ODbaseTable::CreateImpl" );
1054 	OSL_ENSURE(!m_pFileStream, "SequenceError");
1055 
1056 	if ( m_pConnection->isCheckEnabled() && ::dbtools::convertName2SQLName(m_Name,::rtl::OUString()) != m_Name )
1057 	{
1058         const ::rtl::OUString sError( getConnection()->getResources().getResourceStringWithSubstitution(
1059                 STR_SQL_NAME_ERROR,
1060                 "$name$", m_Name
1061              ) );
1062         ::dbtools::throwGenericSQLException( sError, *this );
1063 	}
1064 
1065 	INetURLObject aURL;
1066 	aURL.SetSmartProtocol(INET_PROT_FILE);
1067 	String aName = getEntry(m_pConnection,m_Name);
1068 	if(!aName.Len())
1069 	{
1070 		::rtl::OUString aIdent = m_pConnection->getContent()->getIdentifier()->getContentIdentifier();
1071 		if ( aIdent.lastIndexOf('/') != (aIdent.getLength()-1) )
1072 			aIdent += ::rtl::OUString::createFromAscii("/");
1073 		aIdent += m_Name;
1074 		aName = aIdent.getStr();
1075 	}
1076 	aURL.SetURL(aName);
1077 
1078 	if ( !m_pConnection->matchesExtension( aURL.getExtension() ) )
1079 		aURL.setExtension(m_pConnection->getExtension());
1080 
1081 	try
1082 	{
1083 		Content aContent(aURL.GetMainURL(INetURLObject::NO_DECODE),Reference<XCommandEnvironment>());
1084 		if (aContent.isDocument())
1085 		{
1086 			// Hack fuer Bug #30609 , nur wenn das File existiert und die Laenge > 0 gibt es einen Fehler
1087 			SvStream* pFileStream = createStream_simpleError( aURL.GetMainURL(INetURLObject::NO_DECODE),STREAM_READ);
1088 
1089 			if (pFileStream && pFileStream->Seek(STREAM_SEEK_TO_END))
1090 			{
1091 				//	aStatus.SetError(ERRCODE_IO_ALREADYEXISTS,TABLE,aFile.GetFull());
1092 				return sal_False;
1093 			}
1094 			delete pFileStream;
1095 		}
1096 	}
1097 	catch(Exception&) // a execption is thrown when no file exists
1098 	{
1099 	}
1100 
1101 	sal_Bool bMemoFile = sal_False;
1102 
1103 	sal_Bool bOk = CreateFile(aURL, bMemoFile);
1104 
1105 	FileClose();
1106 
1107 	if (!bOk)
1108 	{
1109 		try
1110 		{
1111 			Content aContent(aURL.GetMainURL(INetURLObject::NO_DECODE),Reference<XCommandEnvironment>());
1112 			aContent.executeCommand( rtl::OUString::createFromAscii( "delete" ),bool2any( sal_True ) );
1113 		}
1114 		catch(Exception&) // a execption is thrown when no file exists
1115 		{
1116 		}
1117 		return sal_False;
1118 	}
1119 
1120 	if (bMemoFile)
1121 	{
1122 		String aExt = aURL.getExtension();
1123 		aURL.setExtension(String::CreateFromAscii("dbt"));                      // extension for memo file
1124 		Content aMemo1Content(aURL.GetMainURL(INetURLObject::NO_DECODE),Reference<XCommandEnvironment>());
1125 
1126 		sal_Bool bMemoAlreadyExists = sal_False;
1127 		try
1128 		{
1129 			bMemoAlreadyExists = aMemo1Content.isDocument();
1130 		}
1131 		catch(Exception&) // a execption is thrown when no file exists
1132 		{
1133 		}
1134 		if (bMemoAlreadyExists)
1135 		{
1136 			//	aStatus.SetError(ERRCODE_IO_ALREADYEXISTS,MEMO,aFile.GetFull());
1137 			aURL.setExtension(aExt);      // kill dbf file
1138 			try
1139 			{
1140 				Content aMemoContent(aURL.GetMainURL(INetURLObject::NO_DECODE),Reference<XCommandEnvironment>());
1141 				aMemoContent.executeCommand( rtl::OUString::createFromAscii( "delete" ),bool2any( sal_True ) );
1142 			}
1143 			catch(const Exception&)
1144 			{
1145 
1146                 const ::rtl::OUString sError( getConnection()->getResources().getResourceStringWithSubstitution(
1147                         STR_COULD_NOT_DELETE_FILE,
1148                         "$name$", aName
1149                      ) );
1150                 ::dbtools::throwGenericSQLException( sError, *this );
1151 			}
1152 		}
1153 		if (!CreateMemoFile(aURL))
1154 		{
1155 			aURL.setExtension(aExt);      // kill dbf file
1156 			Content aMemoContent(aURL.GetMainURL(INetURLObject::NO_DECODE),Reference<XCommandEnvironment>());
1157 			aMemoContent.executeCommand( rtl::OUString::createFromAscii( "delete" ),bool2any( sal_True ) );
1158 			return sal_False;
1159 		}
1160 		m_aHeader.db_typ = dBaseIIIMemo;
1161 	}
1162 	else
1163 		m_aHeader.db_typ = dBaseIII;
1164 
1165 	return sal_True;
1166 }
1167 // -----------------------------------------------------------------------------
throwInvalidColumnType(const sal_uInt16 _nErrorId,const::rtl::OUString & _sColumnName)1168 void ODbaseTable::throwInvalidColumnType(const sal_uInt16 _nErrorId,const ::rtl::OUString& _sColumnName)
1169 {
1170     RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbase", "Ocke.Janssen@sun.com", "ODbaseTable::throwInvalidColumnType" );
1171 	try
1172 	{
1173 		// we have to drop the file because it is corrupted now
1174 		DropImpl();
1175 	}
1176 	catch(const Exception&)
1177 	{
1178 	}
1179 
1180     const ::rtl::OUString sError( getConnection()->getResources().getResourceStringWithSubstitution(
1181             _nErrorId,
1182             "$columnname$", _sColumnName
1183          ) );
1184     ::dbtools::throwGenericSQLException( sError, *this );
1185 }
1186 //------------------------------------------------------------------
1187 // erzeugt grundsaetzlich dBase IV Datei Format
CreateFile(const INetURLObject & aFile,sal_Bool & bCreateMemo)1188 sal_Bool ODbaseTable::CreateFile(const INetURLObject& aFile, sal_Bool& bCreateMemo)
1189 {
1190     RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbase", "Ocke.Janssen@sun.com", "ODbaseTable::CreateFile" );
1191 	bCreateMemo = sal_False;
1192 	Date aDate;                                     // aktuelles Datum
1193 
1194 	m_pFileStream = createStream_simpleError( aFile.GetMainURL(INetURLObject::NO_DECODE),STREAM_READWRITE | STREAM_SHARE_DENYWRITE | STREAM_TRUNC );
1195 
1196 	if (!m_pFileStream)
1197 		return sal_False;
1198 
1199     sal_uInt8 nDbaseType = dBaseIII;
1200     Reference<XIndexAccess> xColumns(getColumns(),UNO_QUERY);
1201 	Reference<XPropertySet> xCol;
1202     const ::rtl::OUString sPropType = OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_TYPE);
1203 
1204     try
1205 	{
1206         const sal_Int32 nCount = xColumns->getCount();
1207 		for(sal_Int32 i=0;i<nCount;++i)
1208 		{
1209 			xColumns->getByIndex(i) >>= xCol;
1210 			OSL_ENSURE(xCol.is(),"This should be a column!");
1211 
1212 			switch (getINT32(xCol->getPropertyValue(sPropType)))
1213 			{
1214                 case DataType::DOUBLE:
1215                 case DataType::INTEGER:
1216                 case DataType::TIMESTAMP:
1217                 case DataType::LONGVARBINARY:
1218                     nDbaseType = VisualFoxPro;
1219                     i = nCount; // no more columns need to be checked
1220                     break;
1221             } // switch (getINT32(xCol->getPropertyValue(sPropType)))
1222         }
1223     }
1224     catch ( const Exception& e )
1225 	{
1226         (void)e;
1227 
1228 		try
1229 		{
1230 			// we have to drop the file because it is corrupted now
1231 			DropImpl();
1232 		}
1233 		catch(const Exception&) { }
1234 		throw;
1235 	}
1236 
1237 	char aBuffer[21];               // write buffer
1238 	memset(aBuffer,0,sizeof(aBuffer));
1239 
1240 	m_pFileStream->Seek(0L);
1241 	(*m_pFileStream) << (sal_uInt8) nDbaseType;                              // dBase format
1242 	(*m_pFileStream) << (sal_uInt8) (aDate.GetYear() % 100);                 // aktuelles Datum
1243 
1244 
1245 	(*m_pFileStream) << (sal_uInt8) aDate.GetMonth();
1246 	(*m_pFileStream) << (sal_uInt8) aDate.GetDay();
1247     (*m_pFileStream) << 0L;                                             // Anzahl der Datensaetze
1248 	(*m_pFileStream) << (sal_uInt16)((m_pColumns->getCount()+1) * 32 + 1);  // Kopfinformationen,
1249                                                                         // pColumns erhaelt immer eine Spalte mehr
1250     (*m_pFileStream) << (sal_uInt16) 0;                                     // Satzlaenge wird spaeter bestimmt
1251 	m_pFileStream->Write(aBuffer, 20);
1252 
1253     sal_uInt16 nRecLength = 1;                                              // Laenge 1 fuer deleted flag
1254 	sal_Int32  nMaxFieldLength = m_pConnection->getMetaData()->getMaxColumnNameLength();
1255 	::rtl::OUString aName;
1256     const ::rtl::OUString sPropName = OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_NAME);
1257     const ::rtl::OUString sPropPrec = OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_PRECISION);
1258     const ::rtl::OUString sPropScale = OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_SCALE);
1259 
1260 	try
1261 	{
1262 		const sal_Int32 nCount = xColumns->getCount();
1263 		for(sal_Int32 i=0;i<nCount;++i)
1264 		{
1265 			xColumns->getByIndex(i) >>= xCol;
1266 			OSL_ENSURE(xCol.is(),"This should be a column!");
1267 
1268             char cTyp( 'C' );
1269 
1270 			xCol->getPropertyValue(sPropName) >>= aName;
1271 
1272 			::rtl::OString aCol;
1273 			if ( DBTypeConversion::convertUnicodeString( aName, aCol, m_eEncoding ) > nMaxFieldLength)
1274 			{
1275                 throwInvalidColumnType( STR_INVALID_COLUMN_NAME_LENGTH, aName );
1276 			}
1277 
1278 			(*m_pFileStream) << aCol.getStr();
1279 			m_pFileStream->Write(aBuffer, 11 - aCol.getLength());
1280 
1281             sal_Int32 nPrecision = 0;
1282 			xCol->getPropertyValue(sPropPrec) >>= nPrecision;
1283 			sal_Int32 nScale = 0;
1284 			xCol->getPropertyValue(sPropScale) >>= nScale;
1285 
1286             bool bBinary = false;
1287 
1288 			switch (getINT32(xCol->getPropertyValue(sPropType)))
1289 			{
1290 				case DataType::CHAR:
1291 				case DataType::VARCHAR:
1292 					cTyp = 'C';
1293 					break;
1294                 case DataType::DOUBLE:
1295                     if (getBOOL(xCol->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_ISCURRENCY)))) // Currency wird gesondert behandelt
1296                         cTyp = 'Y';
1297                     else
1298                         cTyp = 'B';
1299 					break;
1300                 case DataType::INTEGER:
1301                     cTyp = 'I';
1302 				    break;
1303 				case DataType::TINYINT:
1304 				case DataType::SMALLINT:
1305 				case DataType::BIGINT:
1306 				case DataType::DECIMAL:
1307 				case DataType::NUMERIC:
1308 				case DataType::REAL:
1309 					cTyp = 'N';                             // nur dBase 3 format
1310 					break;
1311                 case DataType::TIMESTAMP:
1312                     cTyp = 'T';
1313 				    break;
1314 				case DataType::DATE:
1315 					cTyp = 'D';
1316 					break;
1317 				case DataType::BIT:
1318 					cTyp = 'L';
1319 					break;
1320 				case DataType::LONGVARBINARY:
1321                     bBinary = true;
1322                     // run through
1323 				case DataType::LONGVARCHAR:
1324 					cTyp = 'M';
1325 					break;
1326 				default:
1327 					{
1328 						throwInvalidColumnType(STR_INVALID_COLUMN_TYPE, aName);
1329 					}
1330 			}
1331 
1332 			(*m_pFileStream) << cTyp;
1333             if ( nDbaseType == VisualFoxPro )
1334                 (*m_pFileStream) << (nRecLength-1);
1335             else
1336 			    m_pFileStream->Write(aBuffer, 4);
1337 
1338 			switch(cTyp)
1339 			{
1340 				case 'C':
1341 					OSL_ENSURE(nPrecision < 255, "ODbaseTable::Create: Column zu lang!");
1342 					if (nPrecision > 254)
1343 					{
1344 						throwInvalidColumnType(STR_INVALID_COLUMN_PRECISION, aName);
1345 					}
1346 					(*m_pFileStream) << (sal_uInt8) Min((sal_uIntPtr)nPrecision, 255UL);      //Feldlaenge
1347                     nRecLength = nRecLength + (sal_uInt16)::std::min((sal_uInt16)nPrecision, (sal_uInt16)255UL);
1348 					(*m_pFileStream) << (sal_uInt8)0;                                                                //Nachkommastellen
1349 					break;
1350 				case 'F':
1351 				case 'N':
1352 					OSL_ENSURE(nPrecision >=  nScale,
1353 							"ODbaseTable::Create: Feldlaenge muss groesser Nachkommastellen sein!");
1354 					if (nPrecision <  nScale)
1355 					{
1356 						throwInvalidColumnType(STR_INVALID_PRECISION_SCALE, aName);
1357 					}
1358 					if (getBOOL(xCol->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_ISCURRENCY)))) // Currency wird gesondert behandelt
1359 					{
1360 						(*m_pFileStream) << (sal_uInt8)10;          // Standard Laenge
1361 						(*m_pFileStream) << (sal_uInt8)4;
1362 						nRecLength += 10;
1363 					}
1364 					else
1365 					{
1366 						sal_Int32 nPrec = SvDbaseConverter::ConvertPrecisionToDbase(nPrecision,nScale);
1367 
1368 						(*m_pFileStream) << (sal_uInt8)( nPrec);
1369 						(*m_pFileStream) << (sal_uInt8)nScale;
1370                         nRecLength += (sal_uInt16)nPrec;
1371 					}
1372 					break;
1373 				case 'L':
1374 					(*m_pFileStream) << (sal_uInt8)1;
1375 					(*m_pFileStream) << (sal_uInt8)0;
1376 					++nRecLength;
1377 					break;
1378                 case 'I':
1379 					(*m_pFileStream) << (sal_uInt8)4;
1380 					(*m_pFileStream) << (sal_uInt8)0;
1381 					nRecLength += 4;
1382 					break;
1383                 case 'Y':
1384                 case 'B':
1385                 case 'T':
1386 				case 'D':
1387 					(*m_pFileStream) << (sal_uInt8)8;
1388 					(*m_pFileStream) << (sal_uInt8)0;
1389 					nRecLength += 8;
1390 					break;
1391 				case 'M':
1392 					bCreateMemo = sal_True;
1393 					(*m_pFileStream) << (sal_uInt8)10;
1394 					(*m_pFileStream) << (sal_uInt8)0;
1395 					nRecLength += 10;
1396                     if ( bBinary )
1397                         aBuffer[0] = 0x06;
1398 					break;
1399 				default:
1400                     throwInvalidColumnType(STR_INVALID_COLUMN_TYPE, aName);
1401 			}
1402 			m_pFileStream->Write(aBuffer, 14);
1403             aBuffer[0] = 0x00;
1404 		}
1405 
1406 		(*m_pFileStream) << (sal_uInt8)FIELD_DESCRIPTOR_TERMINATOR;              // kopf ende
1407         (*m_pFileStream) << (char)DBF_EOL;
1408 		m_pFileStream->Seek(10L);
1409 		(*m_pFileStream) << nRecLength;                                     // Satzlaenge nachtraeglich eintragen
1410 
1411 		if (bCreateMemo)
1412 		{
1413 			m_pFileStream->Seek(0L);
1414             if (nDbaseType == VisualFoxPro)
1415                 (*m_pFileStream) << (sal_uInt8) FoxProMemo;
1416             else
1417                 (*m_pFileStream) << (sal_uInt8) dBaseIIIMemo;
1418 		} // if (bCreateMemo)
1419 	}
1420 	catch ( const Exception& e )
1421 	{
1422         (void)e;
1423 
1424 		try
1425 		{
1426 			// we have to drop the file because it is corrupted now
1427 			DropImpl();
1428 		}
1429 		catch(const Exception&) { }
1430 		throw;
1431 	}
1432 	return sal_True;
1433 }
1434 
1435 //------------------------------------------------------------------
1436 // erzeugt grundsaetzlich dBase III Datei Format
CreateMemoFile(const INetURLObject & aFile)1437 sal_Bool ODbaseTable::CreateMemoFile(const INetURLObject& aFile)
1438 {
1439     RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbase", "Ocke.Janssen@sun.com", "ODbaseTable::CreateMemoFile" );
1440     // Makro zum Filehandling fuers Erzeugen von Tabellen
1441 	m_pMemoStream = createStream_simpleError( aFile.GetMainURL(INetURLObject::NO_DECODE),STREAM_READWRITE | STREAM_SHARE_DENYWRITE);
1442 
1443 	if (!m_pMemoStream)
1444 		return sal_False;
1445 
1446 	char aBuffer[512];              // write buffer
1447 	memset(aBuffer,0,sizeof(aBuffer));
1448 
1449 	m_pMemoStream->SetFiller('\0');
1450 	m_pMemoStream->SetStreamSize(512);
1451 
1452 	m_pMemoStream->Seek(0L);
1453 	(*m_pMemoStream) << long(1);                  // Zeiger auf ersten freien Block
1454 
1455 	m_pMemoStream->Flush();
1456 	delete m_pMemoStream;
1457 	m_pMemoStream = NULL;
1458 	return sal_True;
1459 }
1460 //------------------------------------------------------------------
Drop_Static(const::rtl::OUString & _sUrl,sal_Bool _bHasMemoFields,OCollection * _pIndexes)1461 sal_Bool ODbaseTable::Drop_Static(const ::rtl::OUString& _sUrl,sal_Bool _bHasMemoFields,OCollection* _pIndexes )
1462 {
1463     RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbase", "Ocke.Janssen@sun.com", "ODbaseTable::Drop_Static" );
1464 	INetURLObject aURL;
1465 	aURL.SetURL(_sUrl);
1466 
1467 	sal_Bool bDropped = ::utl::UCBContentHelper::Kill(aURL.GetMainURL(INetURLObject::NO_DECODE));
1468 
1469 	if(bDropped)
1470 	{
1471 		if (_bHasMemoFields)
1472 		{  // delete the memo fields
1473 			aURL.setExtension(String::CreateFromAscii("dbt"));
1474 			bDropped = ::utl::UCBContentHelper::Kill(aURL.GetMainURL(INetURLObject::NO_DECODE));
1475 		}
1476 
1477 		if(bDropped)
1478 		{
1479 			if(_pIndexes)
1480 			{
1481 				try
1482 				{
1483 					sal_Int32 i = _pIndexes->getCount();
1484 					while (i)
1485 					{
1486 						_pIndexes->dropByIndex(--i);
1487 					}
1488 				}
1489 				catch(SQLException)
1490 				{
1491 				}
1492 			}
1493 			//	aFile.SetBase(m_Name);
1494 			aURL.setExtension(String::CreateFromAscii("inf"));
1495 
1496 			// as the inf file does not necessarily exist, we aren't allowed to use UCBContentHelper::Kill
1497 			// 89711 - 16.07.2001 - frank.schoenheit@sun.com
1498 			try
1499 			{
1500 				::ucbhelper::Content aDeleteContent( aURL.GetMainURL( INetURLObject::NO_DECODE ), Reference< XCommandEnvironment > () );
1501 				aDeleteContent.executeCommand( ::rtl::OUString::createFromAscii( "delete" ), makeAny( sal_Bool( sal_True ) ) );
1502 			}
1503 			catch(Exception&)
1504 			{
1505 				// silently ignore this ....
1506 			}
1507 		}
1508 	}
1509 	return bDropped;
1510 }
1511 // -----------------------------------------------------------------------------
DropImpl()1512 sal_Bool ODbaseTable::DropImpl()
1513 {
1514     RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbase", "Ocke.Janssen@sun.com", "ODbaseTable::DropImpl" );
1515 	FileClose();
1516 
1517 	if(!m_pIndexes)
1518 		refreshIndexes(); // look for indexes which must be deleted as well
1519 
1520 	sal_Bool bDropped = Drop_Static(getEntry(m_pConnection,m_Name),HasMemoFields(),m_pIndexes);
1521 	if(!bDropped)
1522 	{// we couldn't drop the table so we have to reopen it
1523 		construct();
1524 		if(m_pColumns)
1525 			m_pColumns->refresh();
1526 	}
1527 	return bDropped;
1528 }
1529 
1530 //------------------------------------------------------------------
InsertRow(OValueRefVector & rRow,sal_Bool bFlush,const Reference<XIndexAccess> & _xCols)1531 sal_Bool ODbaseTable::InsertRow(OValueRefVector& rRow, sal_Bool bFlush,const Reference<XIndexAccess>& _xCols)
1532 {
1533     RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbase", "Ocke.Janssen@sun.com", "ODbaseTable::InsertRow" );
1534     // Buffer mit Leerzeichen fuellen
1535 	AllocBuffer();
1536 	memset(m_pBuffer, 0, m_aHeader.db_slng);
1537     m_pBuffer[0] = ' ';
1538 
1539 	// Gesamte neue Row uebernehmen:
1540 	// ... und am Ende als neuen Record hinzufuegen:
1541 	sal_uInt32 nTempPos = m_nFilePos,
1542 		   nFileSize = 0,
1543 		   nMemoFileSize = 0;
1544 
1545 	m_nFilePos = (sal_uIntPtr)m_aHeader.db_anz + 1;
1546     sal_Bool bInsertRow = UpdateBuffer( rRow, NULL, _xCols );
1547 	if ( bInsertRow )
1548 	{
1549 		nFileSize = lcl_getFileSize(*m_pFileStream);
1550 
1551 		if (HasMemoFields() && m_pMemoStream)
1552 		{
1553 			m_pMemoStream->Seek(STREAM_SEEK_TO_END);
1554 			nMemoFileSize = m_pMemoStream->Tell();
1555 		}
1556 
1557 		if (!WriteBuffer())
1558 		{
1559             m_pFileStream->SetStreamSize(nFileSize);                // alte Groesse restaurieren
1560 
1561 			if (HasMemoFields() && m_pMemoStream)
1562                 m_pMemoStream->SetStreamSize(nMemoFileSize);    // alte Groesse restaurieren
1563 			m_nFilePos = nTempPos;								// Fileposition restaurieren
1564 		}
1565 		else
1566 		{
1567             (*m_pFileStream) << (char)DBF_EOL; // write EOL
1568 			// Anzahl Datensaetze im Header erhoehen:
1569 			m_pFileStream->Seek( 4L );
1570 			(*m_pFileStream) << (m_aHeader.db_anz + 1);
1571 
1572 			// beim AppendOnly kein Flush!
1573 			if (bFlush)
1574 				m_pFileStream->Flush();
1575 
1576             // bei Erfolg # erhoehen
1577 			m_aHeader.db_anz++;
1578 			*rRow.get()[0] = m_nFilePos;							    // BOOKmark setzen
1579 			m_nFilePos = nTempPos;
1580 		}
1581 	}
1582 	else
1583 		m_nFilePos = nTempPos;
1584 
1585 	return bInsertRow;
1586 }
1587 
1588 //------------------------------------------------------------------
UpdateRow(OValueRefVector & rRow,OValueRefRow & pOrgRow,const Reference<XIndexAccess> & _xCols)1589 sal_Bool ODbaseTable::UpdateRow(OValueRefVector& rRow, OValueRefRow& pOrgRow,const Reference<XIndexAccess>& _xCols)
1590 {
1591     RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbase", "Ocke.Janssen@sun.com", "ODbaseTable::UpdateRow" );
1592     // Buffer mit Leerzeichen fuellen
1593 	AllocBuffer();
1594 
1595 	// Auf gewuenschten Record positionieren:
1596 	long nPos = m_aHeader.db_kopf + (long)(m_nFilePos-1) * m_aHeader.db_slng;
1597 	m_pFileStream->Seek(nPos);
1598 	m_pFileStream->Read((char*)m_pBuffer, m_aHeader.db_slng);
1599 
1600 	sal_uInt32 nMemoFileSize( 0 );
1601 	if (HasMemoFields() && m_pMemoStream)
1602 	{
1603 		m_pMemoStream->Seek(STREAM_SEEK_TO_END);
1604 		nMemoFileSize = m_pMemoStream->Tell();
1605 	}
1606 	if (!UpdateBuffer(rRow, pOrgRow,_xCols) || !WriteBuffer())
1607 	{
1608 		if (HasMemoFields() && m_pMemoStream)
1609             m_pMemoStream->SetStreamSize(nMemoFileSize);    // alte Groesse restaurieren
1610 	}
1611 	else
1612 	{
1613 		m_pFileStream->Flush();
1614 	}
1615 	return sal_True;
1616 }
1617 
1618 //------------------------------------------------------------------
DeleteRow(const OSQLColumns & _rCols)1619 sal_Bool ODbaseTable::DeleteRow(const OSQLColumns& _rCols)
1620 {
1621     RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbase", "Ocke.Janssen@sun.com", "ODbaseTable::DeleteRow" );
1622 	// Einfach das Loesch-Flag setzen (egal, ob es schon gesetzt war
1623 	// oder nicht):
1624 	// Auf gewuenschten Record positionieren:
1625 	long nFilePos = m_aHeader.db_kopf + (long)(m_nFilePos-1) * m_aHeader.db_slng;
1626 	m_pFileStream->Seek(nFilePos);
1627 
1628 	OValueRefRow aRow = new OValueRefVector(_rCols.get().size());
1629 
1630 	if (!fetchRow(aRow,_rCols,sal_True,sal_True))
1631 		return sal_False;
1632 
1633 	Reference<XPropertySet> xCol;
1634 	::rtl::OUString aColName;
1635 	::comphelper::UStringMixEqual aCase(isCaseSensitive());
1636 	for (sal_uInt16 i = 0; i < m_pColumns->getCount(); i++)
1637 	{
1638 		Reference<XPropertySet> xIndex = isUniqueByColumnName(i);
1639 		if (xIndex.is())
1640 		{
1641 			::cppu::extractInterface(xCol,m_pColumns->getByIndex(i));
1642 			OSL_ENSURE(xCol.is(),"ODbaseTable::DeleteRow column is null!");
1643 			if(xCol.is())
1644 			{
1645 				xCol->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_NAME)) >>= aColName;
1646 
1647 				Reference<XUnoTunnel> xTunnel(xIndex,UNO_QUERY);
1648 				OSL_ENSURE(xTunnel.is(),"No TunnelImplementation!");
1649 				ODbaseIndex* pIndex = reinterpret_cast< ODbaseIndex* >( xTunnel->getSomething(ODbaseIndex::getUnoTunnelImplementationId()) );
1650 				OSL_ENSURE(pIndex,"ODbaseTable::DeleteRow: No Index returned!");
1651 
1652 				OSQLColumns::Vector::const_iterator aIter = _rCols.get().begin();
1653 				sal_Int32 nPos = 1;
1654 				for(;aIter != _rCols.get().end();++aIter,++nPos)
1655 				{
1656 					if(aCase(getString((*aIter)->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_REALNAME))),aColName))
1657 						break;
1658 				}
1659 				if (aIter == _rCols.get().end())
1660 					continue;
1661 
1662 				pIndex->Delete(m_nFilePos,*(aRow->get())[nPos]);
1663 			}
1664 		}
1665 	}
1666 
1667 	m_pFileStream->Seek(nFilePos);
1668 	(*m_pFileStream) << (sal_uInt8)'*'; // mark the row in the table as deleted
1669 	m_pFileStream->Flush();
1670 	return sal_True;
1671 }
1672 // -------------------------------------------------------------------------
isUniqueByColumnName(sal_Int32 _nColumnPos)1673 Reference<XPropertySet> ODbaseTable::isUniqueByColumnName(sal_Int32 _nColumnPos)
1674 {
1675     RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbase", "Ocke.Janssen@sun.com", "ODbaseTable::isUniqueByColumnName" );
1676 	if(!m_pIndexes)
1677 		refreshIndexes();
1678 	if(m_pIndexes->hasElements())
1679 	{
1680 		Reference<XPropertySet> xCol;
1681 		m_pColumns->getByIndex(_nColumnPos) >>= xCol;
1682 		OSL_ENSURE(xCol.is(),"ODbaseTable::isUniqueByColumnName column is null!");
1683 		::rtl::OUString sColName;
1684 		xCol->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_NAME)) >>= sColName;
1685 
1686 		Reference<XPropertySet> xIndex;
1687 		for(sal_Int32 i=0;i<m_pIndexes->getCount();++i)
1688 		{
1689 			::cppu::extractInterface(xIndex,m_pIndexes->getByIndex(i));
1690 			if(xIndex.is() && getBOOL(xIndex->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_ISUNIQUE))))
1691 			{
1692 				Reference<XNameAccess> xCols(Reference<XColumnsSupplier>(xIndex,UNO_QUERY)->getColumns());
1693 				if(xCols->hasByName(sColName))
1694 					return xIndex;
1695 
1696 			}
1697 		}
1698 	}
1699 	return Reference<XPropertySet>();
1700 }
1701 //------------------------------------------------------------------
toDouble(const ByteString & rString)1702 double toDouble(const ByteString& rString)
1703 {
1704     return ::rtl::math::stringToDouble( rString, '.', ',', NULL, NULL );
1705 }
1706 
1707 //------------------------------------------------------------------
UpdateBuffer(OValueRefVector & rRow,OValueRefRow pOrgRow,const Reference<XIndexAccess> & _xCols)1708 sal_Bool ODbaseTable::UpdateBuffer(OValueRefVector& rRow, OValueRefRow pOrgRow,const Reference<XIndexAccess>& _xCols)
1709 {
1710     RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbase", "Ocke.Janssen@sun.com", "ODbaseTable::UpdateBuffer" );
1711 	OSL_ENSURE(m_pBuffer,"Buffer is NULL!");
1712 	if ( !m_pBuffer )
1713 		return sal_False;
1714 	sal_Int32 nByteOffset  = 1;
1715 
1716 	// Felder aktualisieren:
1717 	Reference<XPropertySet> xCol;
1718 	Reference<XPropertySet> xIndex;
1719 	sal_uInt16 i;
1720 	::rtl::OUString aColName;
1721 	const sal_Int32 nColumnCount = m_pColumns->getCount();
1722 	::std::vector< Reference<XPropertySet> > aIndexedCols(nColumnCount);
1723 
1724 	::comphelper::UStringMixEqual aCase(isCaseSensitive());
1725 
1726 	Reference<XIndexAccess> xColumns = m_pColumns;
1727 	// first search a key that exist already in the table
1728 	for (i = 0; i < nColumnCount; ++i)
1729 	{
1730 		sal_Int32 nPos = i;
1731 		if(_xCols != xColumns)
1732 		{
1733 			m_pColumns->getByIndex(i) >>= xCol;
1734 			OSL_ENSURE(xCol.is(),"ODbaseTable::UpdateBuffer column is null!");
1735 			xCol->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_NAME)) >>= aColName;
1736 
1737 			for(nPos = 0;nPos<_xCols->getCount();++nPos)
1738 			{
1739 				Reference<XPropertySet> xFindCol;
1740 				::cppu::extractInterface(xFindCol,_xCols->getByIndex(nPos));
1741 				OSL_ENSURE(xFindCol.is(),"ODbaseTable::UpdateBuffer column is null!");
1742 				if(aCase(getString(xFindCol->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_NAME))),aColName))
1743 					break;
1744 			}
1745 			if (nPos >= _xCols->getCount())
1746 				continue;
1747 		}
1748 
1749 		++nPos;
1750 		xIndex = isUniqueByColumnName(i);
1751 		aIndexedCols[i] = xIndex;
1752 		if (xIndex.is())
1753 		{
1754 			// first check if the value is different to the old one and when if it conform to the index
1755 			if(pOrgRow.isValid() && (rRow.get()[nPos]->getValue().isNull() || rRow.get()[nPos] == (pOrgRow->get())[nPos]))
1756 				continue;
1757 			else
1758 			{
1759 				//	ODbVariantRef xVar = (pVal == NULL) ? new ODbVariant() : pVal;
1760 				Reference<XUnoTunnel> xTunnel(xIndex,UNO_QUERY);
1761 				OSL_ENSURE(xTunnel.is(),"No TunnelImplementation!");
1762 				ODbaseIndex* pIndex = reinterpret_cast< ODbaseIndex* >( xTunnel->getSomething(ODbaseIndex::getUnoTunnelImplementationId()) );
1763 				OSL_ENSURE(pIndex,"ODbaseTable::UpdateBuffer: No Index returned!");
1764 
1765 				if (pIndex->Find(0,*rRow.get()[nPos]))
1766 				{
1767 					// es existiert kein eindeutiger Wert
1768 					if ( !aColName.getLength() )
1769 					{
1770 						m_pColumns->getByIndex(i) >>= xCol;
1771 						OSL_ENSURE(xCol.is(),"ODbaseTable::UpdateBuffer column is null!");
1772 						xCol->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_NAME)) >>= aColName;
1773 						xCol.clear();
1774 					} // if ( !aColName.getLength() )
1775                     const ::rtl::OUString sError( getConnection()->getResources().getResourceStringWithSubstitution(
1776                             STR_DUPLICATE_VALUE_IN_COLUMN
1777                             ,"$columnname$", aColName
1778                          ) );
1779                     ::dbtools::throwGenericSQLException( sError, *this );
1780 				}
1781 			}
1782 		}
1783 	}
1784 
1785 	// when we are here there is no double key in the table
1786 
1787 	for (i = 0; i < nColumnCount && nByteOffset <= m_nBufferSize ; ++i)
1788 	{
1789 		// Laengen je nach Datentyp:
1790 		OSL_ENSURE(i < m_aPrecisions.size(),"Illegal index!");
1791 		sal_Int32 nLen = 0;
1792 		sal_Int32 nType = 0;
1793 		sal_Int32 nScale = 0;
1794 		if ( i < m_aPrecisions.size() )
1795 		{
1796 			nLen	= m_aPrecisions[i];
1797 			nType	= m_aTypes[i];
1798 			nScale	= m_aScales[i];
1799 		}
1800 		else
1801 		{
1802 			m_pColumns->getByIndex(i) >>= xCol;
1803 			if ( xCol.is() )
1804 			{
1805 				xCol->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_PRECISION))	>>= nLen;
1806 				xCol->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_TYPE))		>>= nType;
1807 				xCol->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_SCALE))		>>= nScale;
1808 			}
1809 		}
1810 
1811         bool bSetZero = false;
1812 		switch (nType)
1813 		{
1814             case DataType::INTEGER:
1815             case DataType::DOUBLE:
1816             case DataType::TIMESTAMP:
1817                 bSetZero = true;
1818             case DataType::LONGVARBINARY:
1819 			case DataType::DATE:
1820             case DataType::BIT:
1821 			case DataType::LONGVARCHAR:
1822                 nLen = m_aRealFieldLengths[i];
1823                 break;
1824 			case DataType::DECIMAL:
1825 				nLen = SvDbaseConverter::ConvertPrecisionToDbase(nLen,nScale);
1826 				break;	// das Vorzeichen und das Komma
1827 			default:
1828                 break;
1829 
1830 		} // switch (nType)
1831 
1832 		sal_Int32 nPos = i;
1833 		if(_xCols != xColumns)
1834 		{
1835 			m_pColumns->getByIndex(i) >>= xCol;
1836 			OSL_ENSURE(xCol.is(),"ODbaseTable::UpdateBuffer column is null!");
1837 			xCol->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_NAME)) >>= aColName;
1838 			for(nPos = 0;nPos<_xCols->getCount();++nPos)
1839 			{
1840 				Reference<XPropertySet> xFindCol;
1841 				::cppu::extractInterface(xFindCol,_xCols->getByIndex(nPos));
1842 				if(aCase(getString(xFindCol->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_NAME))),aColName))
1843 					break;
1844 			}
1845 			if (nPos >= _xCols->getCount())
1846 			{
1847 				nByteOffset += nLen;
1848 				continue;
1849 			}
1850 		}
1851 
1852 
1853 
1854 		++nPos; // the row values start at 1
1855 		// Ist die Variable ueberhaupt gebunden?
1856 		if ( !rRow.get()[nPos]->isBound() )
1857 		{
1858 			// Nein - naechstes Feld.
1859 			nByteOffset += nLen;
1860 			continue;
1861 		}
1862 		if (aIndexedCols[i].is())
1863 		{
1864 			Reference<XUnoTunnel> xTunnel(aIndexedCols[i],UNO_QUERY);
1865 			OSL_ENSURE(xTunnel.is(),"No TunnelImplementation!");
1866 			ODbaseIndex* pIndex = reinterpret_cast< ODbaseIndex* >( xTunnel->getSomething(ODbaseIndex::getUnoTunnelImplementationId()) );
1867 			OSL_ENSURE(pIndex,"ODbaseTable::UpdateBuffer: No Index returned!");
1868 			// Update !!
1869 			if (pOrgRow.isValid() && !rRow.get()[nPos]->getValue().isNull() )//&& pVal->isModified())
1870 				pIndex->Update(m_nFilePos,*(pOrgRow->get())[nPos],*rRow.get()[nPos]);
1871 			else
1872 				pIndex->Insert(m_nFilePos,*rRow.get()[nPos]);
1873 		}
1874 
1875 		char* pData = (char *)(m_pBuffer + nByteOffset);
1876 		if (rRow.get()[nPos]->getValue().isNull())
1877 		{
1878             if ( bSetZero )
1879                 memset(pData,0,nLen);	// Zuruecksetzen auf NULL
1880             else
1881 			    memset(pData,' ',nLen);	// Zuruecksetzen auf NULL
1882 			nByteOffset += nLen;
1883 			OSL_ENSURE( nByteOffset <= m_nBufferSize ,"ByteOffset > m_nBufferSize!");
1884 			continue;
1885 		}
1886 
1887         sal_Bool bHadError = sal_False;
1888 		try
1889 		{
1890 			switch (nType)
1891 			{
1892                 case DataType::TIMESTAMP:
1893                     {
1894                         OSL_ENSURE(nLen == 8, "Invalid length for timestamp field");
1895                         if (nLen != 8) {
1896                             bHadError = true;
1897                             break;
1898                         }
1899                         sal_Int32 nJulianDate = 0, nJulianTime = 0;
1900                         lcl_CalcJulDate(nJulianDate,nJulianTime,rRow.get()[nPos]->getValue());
1901                         // Genau 8 Byte kopieren:
1902 					    memcpy(pData,&nJulianDate,4);
1903                         memcpy(pData+4,&nJulianTime,4);
1904                     }
1905                     break;
1906 				case DataType::DATE:
1907 				{
1908                     OSL_ENSURE(nLen == 8, "Invalid length for date field");
1909                     if (nLen != 8) {
1910                         bHadError = true;
1911                         break;
1912                     }
1913 					::com::sun::star::util::Date aDate;
1914 					if(rRow.get()[nPos]->getValue().getTypeKind() == DataType::DOUBLE)
1915 						aDate = ::dbtools::DBTypeConversion::toDate(rRow.get()[nPos]->getValue().getDouble());
1916 					else
1917 						aDate = rRow.get()[nPos]->getValue();
1918 					char s[9];
1919 					snprintf(s,
1920 						sizeof(s),
1921 						"%04d%02d%02d",
1922 						(int)aDate.Year,
1923 						(int)aDate.Month,
1924 						(int)aDate.Day);
1925 
1926 					// Genau 8 Byte kopieren:
1927 					strncpy(pData,s,sizeof s - 1);
1928 				} break;
1929                 case DataType::INTEGER:
1930                     {
1931                         OSL_ENSURE(nLen == 4, "Invalid length for integer field");
1932                         if (nLen != 4) {
1933                             bHadError = true;
1934                             break;
1935                         }
1936                         sal_Int32 nValue = rRow.get()[nPos]->getValue();
1937                         memcpy(pData,&nValue,nLen);
1938                     }
1939                     break;
1940                 case DataType::DOUBLE:
1941                     {
1942                         OSL_ENSURE(nLen == 8, "Invalid length for double field");
1943                         if (nLen != 8) {
1944                             bHadError = true;
1945                             break;
1946                         }
1947                         const double d = rRow.get()[nPos]->getValue();
1948                         m_pColumns->getByIndex(i) >>= xCol;
1949 
1950                         if (getBOOL(xCol->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_ISCURRENCY)))) // Currency wird gesondert behandelt
1951                         {
1952                             sal_Int64 nValue = 0;
1953                             if ( m_aScales[i] )
1954                                 nValue = (sal_Int64)(d * pow(10.0,(int)m_aScales[i]));
1955                             else
1956                                 nValue = (sal_Int64)(d);
1957                             memcpy(pData,&nValue,nLen);
1958                         } // if (getBOOL(xCol->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_ISCURRENCY)))) // Currency wird gesondert behandelt
1959                         else
1960                             memcpy(pData,&d,nLen);
1961                     }
1962                     break;
1963 				case DataType::DECIMAL:
1964 				{
1965 					memset(pData,' ',nLen);	// Zuruecksetzen auf NULL
1966 
1967 					const double n = rRow.get()[nPos]->getValue();
1968 
1969 					// ein const_cast, da GetFormatPrecision am SvNumberFormat nicht const ist, obwohl es das eigentlich
1970 					// sein koennte und muesste
1971 
1972 					const ByteString aDefaultValue( ::rtl::math::doubleToString( n, rtl_math_StringFormat_F, nScale, '.', NULL, 0));
1973                     sal_Bool bValidLength  = aDefaultValue.Len() <= nLen;
1974                     if ( bValidLength )
1975                     {
1976 					    strncpy(pData,aDefaultValue.GetBuffer(),nLen);
1977 					    // write the resulting double back
1978 					    *rRow.get()[nPos] = toDouble(aDefaultValue);
1979                     }
1980                     else
1981 					{
1982 						m_pColumns->getByIndex(i) >>= xCol;
1983 						OSL_ENSURE(xCol.is(),"ODbaseTable::UpdateBuffer column is null!");
1984 						xCol->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_NAME)) >>= aColName;
1985                         ::std::list< ::std::pair<const sal_Char* , ::rtl::OUString > > aStringToSubstitutes;
1986                         aStringToSubstitutes.push_back(::std::pair<const sal_Char* , ::rtl::OUString >("$columnname$", aColName));
1987                         aStringToSubstitutes.push_back(::std::pair<const sal_Char* , ::rtl::OUString >("$precision$", String::CreateFromInt32(nLen)));
1988                         aStringToSubstitutes.push_back(::std::pair<const sal_Char* , ::rtl::OUString >("$scale$", String::CreateFromInt32(nScale)));
1989                         aStringToSubstitutes.push_back(::std::pair<const sal_Char* , ::rtl::OUString >("$value$", ::rtl::OStringToOUString(aDefaultValue,RTL_TEXTENCODING_UTF8)));
1990 
1991                         const ::rtl::OUString sError( getConnection()->getResources().getResourceStringWithSubstitution(
1992                                 STR_INVALID_COLUMN_DECIMAL_VALUE
1993                                 ,aStringToSubstitutes
1994                              ) );
1995                         ::dbtools::throwGenericSQLException( sError, *this );
1996 					}
1997 				} break;
1998 				case DataType::BIT:
1999                     OSL_ENSURE(nLen == 1, "Invalid length for bit field");
2000                     if (nLen != 1) {
2001                         bHadError = true;
2002                         break;
2003                     }
2004 					*pData = rRow.get()[nPos]->getValue().getBool() ? 'T' : 'F';
2005 					break;
2006                 case DataType::LONGVARBINARY:
2007 				case DataType::LONGVARCHAR:
2008 				{
2009 					char cNext = pData[nLen]; // merken und temporaer durch 0 ersetzen
2010 					pData[nLen] = '\0';		  // das geht, da der Puffer immer ein Zeichen groesser ist ...
2011 
2012 					sal_uIntPtr nBlockNo = strtol((const char *)pData,NULL,10);	// Blocknummer lesen
2013 
2014 					// Naechstes Anfangszeichen wieder restaurieren:
2015 					pData[nLen] = cNext;
2016 					if (!m_pMemoStream || !WriteMemo(rRow.get()[nPos]->get(), nBlockNo))
2017 						break;
2018 
2019 					ByteString aStr;
2020 					ByteString aBlock(ByteString::CreateFromInt32(nBlockNo));
2021 					aStr.Expand(static_cast<sal_uInt16>(nLen - aBlock.Len()), '0' );
2022 					aStr += aBlock;
2023 					// Zeichen kopieren:
2024 					memset(pData,' ',nLen);	// Zuruecksetzen auf NULL
2025 					memcpy(pData, aStr.GetBuffer(), nLen);
2026 				}	break;
2027 				default:
2028 				{
2029 					memset(pData,' ',nLen);	// Zuruecksetzen auf NULL
2030 
2031                     ::rtl::OUString sStringToWrite( rRow.get()[nPos]->getValue().getString() );
2032 
2033                     // convert the string, using the connection's encoding
2034                     ::rtl::OString sEncoded;
2035 
2036                     DBTypeConversion::convertUnicodeStringToLength( sStringToWrite, sEncoded, nLen, m_eEncoding );
2037                     memcpy( pData, sEncoded.getStr(), sEncoded.getLength() );
2038 
2039 				}
2040                 break;
2041 			}
2042 		}
2043 		catch( SQLException&  )
2044         {
2045             throw;
2046         }
2047 		catch ( Exception& ) { bHadError = sal_True; }
2048 
2049 		if ( bHadError )
2050 		{
2051 			m_pColumns->getByIndex(i) >>= xCol;
2052 			OSL_ENSURE( xCol.is(), "ODbaseTable::UpdateBuffer column is null!" );
2053             if ( xCol.is() )
2054 			    xCol->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_NAME)) >>= aColName;
2055 
2056 			const ::rtl::OUString sError( getConnection()->getResources().getResourceStringWithSubstitution(
2057                     STR_INVALID_COLUMN_VALUE,
2058                     "$columnname$", aColName
2059                  ) );
2060             ::dbtools::throwGenericSQLException( sError, *this );
2061 		}
2062 		// Und weiter ...
2063 		nByteOffset += nLen;
2064 		OSL_ENSURE( nByteOffset <= m_nBufferSize ,"ByteOffset > m_nBufferSize!");
2065 	}
2066 	return sal_True;
2067 }
2068 
2069 // -----------------------------------------------------------------------------
WriteMemo(ORowSetValue & aVariable,sal_uIntPtr & rBlockNr)2070 sal_Bool ODbaseTable::WriteMemo(ORowSetValue& aVariable, sal_uIntPtr& rBlockNr)
2071 {
2072     RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbase", "Ocke.Janssen@sun.com", "ODbaseTable::WriteMemo" );
2073 	// wird die BlockNr 0 vorgegeben, wird der block ans Ende gehaengt
2074     sal_uIntPtr nSize = 0;
2075     ::rtl::OString aStr;
2076     ::com::sun::star::uno::Sequence<sal_Int8> aValue;
2077 	sal_uInt8 nHeader[4];
2078     const bool bBinary = aVariable.getTypeKind() == DataType::LONGVARBINARY && m_aMemoHeader.db_typ == MemoFoxPro;
2079     if ( bBinary )
2080     {
2081         aValue = aVariable.getSequence();
2082         nSize = aValue.getLength();
2083     }
2084     else
2085     {
2086         nSize = DBTypeConversion::convertUnicodeString( aVariable.getString(), aStr, m_eEncoding );
2087     }
2088 
2089 	// Anhaengen oder ueberschreiben
2090 	sal_Bool bAppend = rBlockNr == 0;
2091 
2092 	if (!bAppend)
2093 	{
2094 		switch (m_aMemoHeader.db_typ)
2095 		{
2096 			case MemodBaseIII: // dBase III-Memofeld, endet mit 2 * Ctrl-Z
2097 				bAppend = nSize > (512 - 2);
2098 				break;
2099 			case MemoFoxPro:
2100 			case MemodBaseIV: // dBase IV-Memofeld mit Laengenangabe
2101 			{
2102 				char sHeader[4];
2103 				m_pMemoStream->Seek(rBlockNr * m_aMemoHeader.db_size);
2104 				m_pMemoStream->SeekRel(4L);
2105 				m_pMemoStream->Read(sHeader,4);
2106 
2107 				sal_uIntPtr nOldSize;
2108 				if (m_aMemoHeader.db_typ == MemoFoxPro)
2109 					nOldSize = ((((unsigned char)sHeader[0]) * 256 +
2110 								 (unsigned char)sHeader[1]) * 256 +
2111 								 (unsigned char)sHeader[2]) * 256 +
2112 								 (unsigned char)sHeader[3];
2113 				else
2114 					nOldSize = ((((unsigned char)sHeader[3]) * 256 +
2115 								 (unsigned char)sHeader[2]) * 256 +
2116 								 (unsigned char)sHeader[1]) * 256 +
2117 								 (unsigned char)sHeader[0]  - 8;
2118 
2119 				// passt die neue Laenge in die belegten Bloecke
2120 				sal_uIntPtr nUsedBlocks = ((nSize + 8) / m_aMemoHeader.db_size) + (((nSize + 8) % m_aMemoHeader.db_size > 0) ? 1 : 0),
2121 					  nOldUsedBlocks = ((nOldSize + 8) / m_aMemoHeader.db_size) + (((nOldSize + 8) % m_aMemoHeader.db_size > 0) ? 1 : 0);
2122 				bAppend = nUsedBlocks > nOldUsedBlocks;
2123 			}
2124 		}
2125 	}
2126 
2127 	if (bAppend)
2128 	{
2129 		sal_uIntPtr nStreamSize = m_pMemoStream->Seek(STREAM_SEEK_TO_END);
2130 		// letzten block auffuellen
2131 		rBlockNr = (nStreamSize / m_aMemoHeader.db_size) + ((nStreamSize % m_aMemoHeader.db_size) > 0 ? 1 : 0);
2132 
2133 		m_pMemoStream->SetStreamSize(rBlockNr * m_aMemoHeader.db_size);
2134 		m_pMemoStream->Seek(STREAM_SEEK_TO_END);
2135 	}
2136 	else
2137 	{
2138 		m_pMemoStream->Seek(rBlockNr * m_aMemoHeader.db_size);
2139 	}
2140 
2141 	switch (m_aMemoHeader.db_typ)
2142 	{
2143 		case MemodBaseIII: // dBase III-Memofeld, endet mit Ctrl-Z
2144 		{
2145 			const char cEOF = (char) DBF_EOL;
2146 			nSize++;
2147 			m_pMemoStream->Write( aStr.getStr(), aStr.getLength() );
2148 			(*m_pMemoStream) << cEOF << cEOF;
2149 		} break;
2150 		case MemoFoxPro:
2151 		case MemodBaseIV: // dBase IV-Memofeld mit Laengenangabe
2152 		{
2153             if ( MemodBaseIV == m_aMemoHeader.db_typ )
2154 			    (*m_pMemoStream) << (sal_uInt8)0xFF
2155 							     << (sal_uInt8)0xFF
2156 							     << (sal_uInt8)0x08;
2157             else
2158                 (*m_pMemoStream) << (sal_uInt8)0x00
2159 							     << (sal_uInt8)0x00
2160 							     << (sal_uInt8)0x00;
2161 
2162 			sal_uInt32 nWriteSize = nSize;
2163 			if (m_aMemoHeader.db_typ == MemoFoxPro)
2164 			{
2165                 if ( bBinary )
2166                     (*m_pMemoStream) << (sal_uInt8) 0x00; // Picture
2167                 else
2168 				    (*m_pMemoStream) << (sal_uInt8) 0x01; // Memo
2169 				for (int i = 4; i > 0; nWriteSize >>= 8)
2170 					nHeader[--i] = (sal_uInt8) (nWriteSize % 256);
2171 			}
2172 			else
2173 			{
2174 				(*m_pMemoStream) << (sal_uInt8) 0x00;
2175 				nWriteSize += 8;
2176 				for (int i = 0; i < 4; nWriteSize >>= 8)
2177 					nHeader[i++] = (sal_uInt8) (nWriteSize % 256);
2178 			}
2179 
2180 			m_pMemoStream->Write(nHeader,4);
2181             if ( bBinary )
2182                 m_pMemoStream->Write( aValue.getConstArray(), aValue.getLength() );
2183             else
2184 			    m_pMemoStream->Write( aStr.getStr(), aStr.getLength() );
2185 			m_pMemoStream->Flush();
2186 		}
2187 	}
2188 
2189 
2190 	// Schreiben der neuen Blocknummer
2191 	if (bAppend)
2192 	{
2193 		sal_uIntPtr nStreamSize = m_pMemoStream->Seek(STREAM_SEEK_TO_END);
2194 		m_aMemoHeader.db_next = (nStreamSize / m_aMemoHeader.db_size) + ((nStreamSize % m_aMemoHeader.db_size) > 0 ? 1 : 0);
2195 
2196 		// Schreiben der neuen Blocknummer
2197 		m_pMemoStream->Seek(0L);
2198 		(*m_pMemoStream) << m_aMemoHeader.db_next;
2199 		m_pMemoStream->Flush();
2200 	}
2201 	return sal_True;
2202 }
2203 
2204 // -----------------------------------------------------------------------------
2205 // XAlterTable
alterColumnByName(const::rtl::OUString & colName,const Reference<XPropertySet> & descriptor)2206 void SAL_CALL ODbaseTable::alterColumnByName( const ::rtl::OUString& colName, const Reference< XPropertySet >& descriptor ) throw(SQLException, NoSuchElementException, RuntimeException)
2207 {
2208     RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbase", "Ocke.Janssen@sun.com", "ODbaseTable::alterColumnByName" );
2209 	::osl::MutexGuard aGuard(m_aMutex);
2210 	checkDisposed(OTableDescriptor_BASE::rBHelper.bDisposed);
2211 
2212 
2213 	Reference<XDataDescriptorFactory> xOldColumn;
2214 	m_pColumns->getByName(colName) >>= xOldColumn;
2215 
2216 	alterColumn(m_pColumns->findColumn(colName)-1,descriptor,xOldColumn);
2217 }
2218 // -------------------------------------------------------------------------
alterColumnByIndex(sal_Int32 index,const Reference<XPropertySet> & descriptor)2219 void SAL_CALL ODbaseTable::alterColumnByIndex( sal_Int32 index, const Reference< XPropertySet >& descriptor ) throw(SQLException, ::com::sun::star::lang::IndexOutOfBoundsException, RuntimeException)
2220 {
2221     RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbase", "Ocke.Janssen@sun.com", "ODbaseTable::alterColumnByIndex" );
2222 	::osl::MutexGuard aGuard(m_aMutex);
2223 	checkDisposed(OTableDescriptor_BASE::rBHelper.bDisposed);
2224 
2225 	if(index < 0 || index >= m_pColumns->getCount())
2226 		throw IndexOutOfBoundsException(::rtl::OUString::valueOf(index),*this);
2227 
2228 	Reference<XDataDescriptorFactory> xOldColumn;
2229 	m_pColumns->getByIndex(index) >>= xOldColumn;
2230 	alterColumn(index,descriptor,xOldColumn);
2231 }
2232 // -----------------------------------------------------------------------------
alterColumn(sal_Int32 index,const Reference<XPropertySet> & descriptor,const Reference<XDataDescriptorFactory> & xOldColumn)2233 void ODbaseTable::alterColumn(sal_Int32 index,
2234 							  const Reference< XPropertySet >& descriptor ,
2235 							  const Reference< XDataDescriptorFactory >& xOldColumn )
2236 {
2237     RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbase", "Ocke.Janssen@sun.com", "ODbaseTable::alterColumn" );
2238 	if(index < 0 || index >= m_pColumns->getCount())
2239 		throw IndexOutOfBoundsException(::rtl::OUString::valueOf(index),*this);
2240 
2241 	ODbaseTable* pNewTable = NULL;
2242 	try
2243 	{
2244 		OSL_ENSURE(descriptor.is(),"ODbaseTable::alterColumn: descriptor can not be null!");
2245 		// creates a copy of the the original column and copy all properties from descriptor in xCopyColumn
2246 		Reference<XPropertySet> xCopyColumn;
2247 		if(xOldColumn.is())
2248 			xCopyColumn = xOldColumn->createDataDescriptor();
2249 		else
2250 			xCopyColumn = new OColumn(getConnection()->getMetaData()->supportsMixedCaseQuotedIdentifiers());
2251 
2252 		::comphelper::copyProperties(descriptor,xCopyColumn);
2253 
2254 		// creates a temp file
2255 
2256 		String sTempName = createTempFile();
2257 
2258 		pNewTable = new ODbaseTable(m_pTables,static_cast<ODbaseConnection*>(m_pConnection));
2259 		Reference<XPropertySet> xHoldTable = pNewTable;
2260 		pNewTable->setPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_NAME),makeAny(::rtl::OUString(sTempName)));
2261 		Reference<XAppend> xAppend(pNewTable->getColumns(),UNO_QUERY);
2262 		OSL_ENSURE(xAppend.is(),"ODbaseTable::alterColumn: No XAppend interface!");
2263 
2264 		// copy the structure
2265 		sal_Int32 i=0;
2266 		for(;i < index;++i)
2267 		{
2268 			Reference<XPropertySet> xProp;
2269 			m_pColumns->getByIndex(i) >>= xProp;
2270 			Reference<XDataDescriptorFactory> xColumn(xProp,UNO_QUERY);
2271 			Reference<XPropertySet> xCpy;
2272 			if(xColumn.is())
2273 				xCpy = xColumn->createDataDescriptor();
2274 			else
2275 				xCpy = new OColumn(getConnection()->getMetaData()->supportsMixedCaseQuotedIdentifiers());
2276 			::comphelper::copyProperties(xProp,xCpy);
2277 			xAppend->appendByDescriptor(xCpy);
2278 		}
2279 		++i; // now insert our new column
2280 		xAppend->appendByDescriptor(xCopyColumn);
2281 
2282 		for(;i < m_pColumns->getCount();++i)
2283 		{
2284 			Reference<XPropertySet> xProp;
2285 			m_pColumns->getByIndex(i) >>= xProp;
2286 			Reference<XDataDescriptorFactory> xColumn(xProp,UNO_QUERY);
2287 			Reference<XPropertySet> xCpy;
2288 			if(xColumn.is())
2289 				xCpy = xColumn->createDataDescriptor();
2290 			else
2291 				xCpy = new OColumn(getConnection()->getMetaData()->supportsMixedCaseQuotedIdentifiers());
2292 			::comphelper::copyProperties(xProp,xCpy);
2293 			xAppend->appendByDescriptor(xCpy);
2294 		}
2295 
2296 		// construct the new table
2297 		if(!pNewTable->CreateImpl())
2298 		{
2299             const ::rtl::OUString sError( getConnection()->getResources().getResourceStringWithSubstitution(
2300                     STR_COLUMN_NOT_ALTERABLE,
2301                     "$columnname$", ::comphelper::getString(descriptor->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_NAME)))
2302                  ) );
2303             ::dbtools::throwGenericSQLException( sError, *this );
2304 		}
2305 
2306 		pNewTable->construct();
2307 
2308 		// copy the data
2309 		copyData(pNewTable,0);
2310 
2311 		// now drop the old one
2312 		if( DropImpl() ) // we don't want to delete the memo columns too
2313 		{
2314 			// rename the new one to the old one
2315 			pNewTable->renameImpl(m_Name);
2316 			// release the temp file
2317 			pNewTable = NULL;
2318 			::comphelper::disposeComponent(xHoldTable);
2319 		}
2320 		else
2321 		{
2322 			pNewTable = NULL;
2323 		}
2324 		FileClose();
2325 		construct();
2326 		if(m_pColumns)
2327 			m_pColumns->refresh();
2328 
2329 	}
2330 	catch(const SQLException&)
2331 	{
2332 		throw;
2333 	}
2334 	catch(const Exception&)
2335 	{
2336 		OSL_ENSURE(0,"ODbaseTable::alterColumn: Exception occured!");
2337 		throw;
2338 	}
2339 }
2340 // -----------------------------------------------------------------------------
getMetaData() const2341 Reference< XDatabaseMetaData> ODbaseTable::getMetaData() const
2342 {
2343     RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbase", "Ocke.Janssen@sun.com", "ODbaseTable::getMetaData" );
2344 	return getConnection()->getMetaData();
2345 }
2346 // -------------------------------------------------------------------------
rename(const::rtl::OUString & newName)2347 void SAL_CALL ODbaseTable::rename( const ::rtl::OUString& newName ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::container::ElementExistException, ::com::sun::star::uno::RuntimeException)
2348 {
2349     RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbase", "Ocke.Janssen@sun.com", "ODbaseTable::rename" );
2350 	::osl::MutexGuard aGuard(m_aMutex);
2351 	checkDisposed(OTableDescriptor_BASE::rBHelper.bDisposed);
2352 	if(m_pTables && m_pTables->hasByName(newName))
2353 		throw ElementExistException(newName,*this);
2354 
2355 
2356 	renameImpl(newName);
2357 
2358 	ODbaseTable_BASE::rename(newName);
2359 
2360 	construct();
2361 	if(m_pColumns)
2362 		m_pColumns->refresh();
2363 }
2364 namespace
2365 {
renameFile(OConnection * _pConenction,const::rtl::OUString & oldName,const::rtl::OUString & newName,const String & _sExtension)2366 	void renameFile(OConnection* _pConenction,const ::rtl::OUString& oldName,
2367 					const ::rtl::OUString& newName,const String& _sExtension)
2368 	{
2369 		String aName = ODbaseTable::getEntry(_pConenction,oldName);
2370 		if(!aName.Len())
2371 		{
2372 			::rtl::OUString aIdent = _pConenction->getContent()->getIdentifier()->getContentIdentifier();
2373 			if ( aIdent.lastIndexOf('/') != (aIdent.getLength()-1) )
2374 				aIdent += ::rtl::OUString::createFromAscii("/");
2375 			aIdent += oldName;
2376 			aName = aIdent;
2377 		}
2378 		INetURLObject aURL;
2379 		aURL.SetURL(aName);
2380 
2381 		aURL.setExtension( _sExtension );
2382 		String sNewName(newName);
2383 		sNewName.AppendAscii(".");
2384 		sNewName += _sExtension;
2385 
2386 		try
2387 		{
2388 			Content aContent(aURL.GetMainURL(INetURLObject::NO_DECODE),Reference<XCommandEnvironment>());
2389 
2390 			Sequence< PropertyValue > aProps( 1 );
2391 			aProps[0].Name		= ::rtl::OUString::createFromAscii("Title");
2392 			aProps[0].Handle	= -1; // n/a
2393 			aProps[0].Value		= makeAny( ::rtl::OUString(sNewName) );
2394 			Sequence< Any > aValues;
2395 			aContent.executeCommand( rtl::OUString::createFromAscii( "setPropertyValues" ),makeAny(aProps) ) >>= aValues;
2396 			if(aValues.getLength() && aValues[0].hasValue())
2397 				throw Exception();
2398 		}
2399 		catch(Exception&)
2400 		{
2401 			throw ElementExistException(newName,NULL);
2402 		}
2403 	}
2404 }
2405 // -------------------------------------------------------------------------
renameImpl(const::rtl::OUString & newName)2406 void SAL_CALL ODbaseTable::renameImpl( const ::rtl::OUString& newName ) throw(::com::sun::star::sdbc::SQLException, ::com::sun::star::container::ElementExistException, ::com::sun::star::uno::RuntimeException)
2407 {
2408     RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbase", "Ocke.Janssen@sun.com", "ODbaseTable::getEntry" );
2409 	::osl::MutexGuard aGuard(m_aMutex);
2410 
2411 	FileClose();
2412 
2413 
2414 	renameFile(m_pConnection,m_Name,newName,m_pConnection->getExtension());
2415 	if ( HasMemoFields() )
2416 	{  // delete the memo fields
2417 		String sExt = String::CreateFromAscii("dbt");
2418 		renameFile(m_pConnection,m_Name,newName,sExt);
2419 	}
2420 }
2421 // -----------------------------------------------------------------------------
addColumn(const Reference<XPropertySet> & _xNewColumn)2422 void ODbaseTable::addColumn(const Reference< XPropertySet >& _xNewColumn)
2423 {
2424     RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbase", "Ocke.Janssen@sun.com", "ODbaseTable::addColumn" );
2425 	String sTempName = createTempFile();
2426 
2427 	ODbaseTable* pNewTable = new ODbaseTable(m_pTables,static_cast<ODbaseConnection*>(m_pConnection));
2428 	Reference< XPropertySet > xHold = pNewTable;
2429 	pNewTable->setPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_NAME),makeAny(::rtl::OUString(sTempName)));
2430 	{
2431 		Reference<XAppend> xAppend(pNewTable->getColumns(),UNO_QUERY);
2432 		sal_Bool bCase = getConnection()->getMetaData()->supportsMixedCaseQuotedIdentifiers();
2433 		// copy the structure
2434 		for(sal_Int32 i=0;i < m_pColumns->getCount();++i)
2435 		{
2436 			Reference<XPropertySet> xProp;
2437 			m_pColumns->getByIndex(i) >>= xProp;
2438 			Reference<XDataDescriptorFactory> xColumn(xProp,UNO_QUERY);
2439 			Reference<XPropertySet> xCpy;
2440 			if(xColumn.is())
2441 				xCpy = xColumn->createDataDescriptor();
2442 			else
2443 			{
2444 				xCpy = new OColumn(bCase);
2445 				::comphelper::copyProperties(xProp,xCpy);
2446 			}
2447 
2448 			xAppend->appendByDescriptor(xCpy);
2449 		}
2450 		Reference<XPropertySet> xCpy = new OColumn(bCase);
2451 		::comphelper::copyProperties(_xNewColumn,xCpy);
2452 		xAppend->appendByDescriptor(xCpy);
2453 	}
2454 
2455 	// construct the new table
2456 	if(!pNewTable->CreateImpl())
2457 	{
2458         const ::rtl::OUString sError( getConnection()->getResources().getResourceStringWithSubstitution(
2459                 STR_COLUMN_NOT_ADDABLE,
2460                 "$columnname$", ::comphelper::getString(_xNewColumn->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_NAME)))
2461              ) );
2462         ::dbtools::throwGenericSQLException( sError, *this );
2463 	}
2464 
2465 	sal_Bool bAlreadyDroped = sal_False;
2466 	try
2467 	{
2468 		pNewTable->construct();
2469 		// copy the data
2470 		copyData(pNewTable,pNewTable->m_pColumns->getCount());
2471 		// drop the old table
2472 		if(DropImpl())
2473 		{
2474 			bAlreadyDroped = sal_True;
2475 			pNewTable->renameImpl(m_Name);
2476 			// release the temp file
2477 		}
2478 		xHold = pNewTable = NULL;
2479 
2480 		FileClose();
2481 		construct();
2482 		if(m_pColumns)
2483 			m_pColumns->refresh();
2484 	}
2485 	catch(const SQLException&)
2486 	{
2487 		// here we know that the old table wasn't droped before
2488 		if(!bAlreadyDroped)
2489 			xHold = pNewTable = NULL;
2490 
2491 		throw;
2492 	}
2493 }
2494 // -----------------------------------------------------------------------------
dropColumn(sal_Int32 _nPos)2495 void ODbaseTable::dropColumn(sal_Int32 _nPos)
2496 {
2497     RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbase", "Ocke.Janssen@sun.com", "ODbaseTable::dropColumn" );
2498 	String sTempName = createTempFile();
2499 
2500 	ODbaseTable* pNewTable = new ODbaseTable(m_pTables,static_cast<ODbaseConnection*>(m_pConnection));
2501 	Reference< XPropertySet > xHold = pNewTable;
2502 	pNewTable->setPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_NAME),makeAny(::rtl::OUString(sTempName)));
2503 	{
2504 		Reference<XAppend> xAppend(pNewTable->getColumns(),UNO_QUERY);
2505 		sal_Bool bCase = getConnection()->getMetaData()->supportsMixedCaseQuotedIdentifiers();
2506 		// copy the structure
2507 		for(sal_Int32 i=0;i < m_pColumns->getCount();++i)
2508 		{
2509 			if(_nPos != i)
2510 			{
2511 				Reference<XPropertySet> xProp;
2512 				m_pColumns->getByIndex(i) >>= xProp;
2513 				Reference<XDataDescriptorFactory> xColumn(xProp,UNO_QUERY);
2514 				Reference<XPropertySet> xCpy;
2515 				if(xColumn.is())
2516 					xCpy = xColumn->createDataDescriptor();
2517 				else
2518 				{
2519 					xCpy = new OColumn(bCase);
2520 					::comphelper::copyProperties(xProp,xCpy);
2521 				}
2522 				xAppend->appendByDescriptor(xCpy);
2523 			}
2524 		}
2525 	}
2526 
2527 	// construct the new table
2528 	if(!pNewTable->CreateImpl())
2529 	{
2530 		xHold = pNewTable = NULL;
2531         const ::rtl::OUString sError( getConnection()->getResources().getResourceStringWithSubstitution(
2532                 STR_COLUMN_NOT_DROP,
2533                 "$position$", ::rtl::OUString::valueOf(_nPos)
2534              ) );
2535         ::dbtools::throwGenericSQLException( sError, *this );
2536 	}
2537 	pNewTable->construct();
2538 	// copy the data
2539 	copyData(pNewTable,_nPos);
2540 	// drop the old table
2541 	if(DropImpl())
2542 		pNewTable->renameImpl(m_Name);
2543 		// release the temp file
2544 
2545 	xHold = pNewTable = NULL;
2546 
2547 	FileClose();
2548 	construct();
2549 }
2550 // -----------------------------------------------------------------------------
createTempFile()2551 String ODbaseTable::createTempFile()
2552 {
2553     RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbase", "Ocke.Janssen@sun.com", "ODbaseTable::createTempFile" );
2554 	::rtl::OUString aIdent = m_pConnection->getContent()->getIdentifier()->getContentIdentifier();
2555 	if ( aIdent.lastIndexOf('/') != (aIdent.getLength()-1) )
2556 		aIdent += ::rtl::OUString::createFromAscii("/");
2557 	String sTempName(aIdent);
2558 	String sExt;
2559 	sExt.AssignAscii(".");
2560 	sExt += m_pConnection->getExtension();
2561 
2562 	String sName(m_Name);
2563 	TempFile aTempFile(sName,&sExt,&sTempName);
2564 	if(!aTempFile.IsValid())
2565         getConnection()->throwGenericSQLException(STR_COULD_NOT_ALTER_TABLE,*this);
2566 
2567 	INetURLObject aURL;
2568 	aURL.SetSmartProtocol(INET_PROT_FILE);
2569 	aURL.SetURL(aTempFile.GetURL());
2570 
2571 	String sNewName(aURL.getName());
2572 	sNewName.Erase(sNewName.Len() - sExt.Len());
2573 	return sNewName;
2574 }
2575 // -----------------------------------------------------------------------------
copyData(ODbaseTable * _pNewTable,sal_Int32 _nPos)2576 void ODbaseTable::copyData(ODbaseTable* _pNewTable,sal_Int32 _nPos)
2577 {
2578     RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbase", "Ocke.Janssen@sun.com", "ODbaseTable::copyData" );
2579 	sal_Int32 nPos = _nPos + 1; // +1 because we always have the bookmark clumn as well
2580 	OValueRefRow aRow = new OValueRefVector(m_pColumns->getCount());
2581 	OValueRefRow aInsertRow;
2582 	if(_nPos)
2583 	{
2584 		aInsertRow = new OValueRefVector(_pNewTable->m_pColumns->getCount());
2585 		::std::for_each(aInsertRow->get().begin(),aInsertRow->get().end(),TSetRefBound(sal_True));
2586 	}
2587 	else
2588 		aInsertRow = aRow;
2589 
2590 	// we only have to bind the values which we need to copy into the new table
2591 	::std::for_each(aRow->get().begin(),aRow->get().end(),TSetRefBound(sal_True));
2592 	if(_nPos && (_nPos < (sal_Int32)aRow->get().size()))
2593 		(aRow->get())[nPos]->setBound(sal_False);
2594 
2595 
2596 	sal_Bool bOk = sal_True;
2597 	sal_Int32 nCurPos;
2598 	OValueRefVector::Vector::iterator aIter;
2599 	for(sal_uInt32 nRowPos = 0; nRowPos < m_aHeader.db_anz;++nRowPos)
2600 	{
2601         bOk = seekRow( IResultSetHelper::BOOKMARK, nRowPos+1, nCurPos );
2602         if ( bOk )
2603 		{
2604             bOk = fetchRow( aRow, m_aColumns.getBody(), sal_True, sal_True);
2605             if ( bOk && !aRow->isDeleted() ) // copy only not deleted rows
2606 			{
2607 				// special handling when pos == 0 then we don't have to distinguish	between the two rows
2608 				if(_nPos)
2609 				{
2610 					aIter = aRow->get().begin()+1;
2611 					sal_Int32 nCount = 1;
2612 					for(OValueRefVector::Vector::iterator aInsertIter = aInsertRow->get().begin()+1; aIter != aRow->get().end() && aInsertIter != aInsertRow->get().end();++aIter,++nCount)
2613 					{
2614 						if(nPos != nCount)
2615 						{
2616 							(*aInsertIter)->setValue( (*aIter)->getValue() );
2617 							++aInsertIter;
2618 						}
2619 					}
2620 				}
2621 				bOk = _pNewTable->InsertRow(*aInsertRow,sal_True,_pNewTable->m_pColumns);
2622 				OSL_ENSURE(bOk,"Row could not be inserted!");
2623 			}
2624 			else
2625 				OSL_ENSURE(bOk,"Row could not be fetched!");
2626 		}
2627 		else
2628 		{
2629 			OSL_ASSERT(0);
2630 		}
2631 	} // for(sal_uInt32 nRowPos = 0; nRowPos < m_aHeader.db_anz;++nRowPos)
2632 }
2633 // -----------------------------------------------------------------------------
throwInvalidDbaseFormat()2634 void ODbaseTable::throwInvalidDbaseFormat()
2635 {
2636     RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbase", "Ocke.Janssen@sun.com", "ODbaseTable::throwInvalidDbaseFormat" );
2637 	FileClose();
2638 	// no dbase file
2639 
2640     const ::rtl::OUString sError( getConnection()->getResources().getResourceStringWithSubstitution(
2641                 STR_INVALID_DBASE_FILE,
2642                 "$filename$", getEntry(m_pConnection,m_Name)
2643              ) );
2644     ::dbtools::throwGenericSQLException( sError, *this );
2645 }
2646 // -----------------------------------------------------------------------------
refreshHeader()2647 void ODbaseTable::refreshHeader()
2648 {
2649     RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbase", "Ocke.Janssen@sun.com", "ODbaseTable::refreshHeader" );
2650     if ( m_aHeader.db_anz == 0 )
2651 	    readHeader();
2652 }
2653 //------------------------------------------------------------------
seekRow(IResultSetHelper::Movement eCursorPosition,sal_Int32 nOffset,sal_Int32 & nCurPos)2654 sal_Bool ODbaseTable::seekRow(IResultSetHelper::Movement eCursorPosition, sal_Int32 nOffset, sal_Int32& nCurPos)
2655 {
2656     RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbase", "Ocke.Janssen@sun.com", "ODbaseTable::seekRow" );
2657 	// ----------------------------------------------------------
2658 	// Positionierung vorbereiten:
2659 	OSL_ENSURE(m_pFileStream,"ODbaseTable::seekRow: FileStream is NULL!");
2660 
2661 	sal_uInt32  nNumberOfRecords = (sal_uInt32)m_aHeader.db_anz;
2662 	sal_uInt32 nTempPos = m_nFilePos;
2663 	m_nFilePos = nCurPos;
2664 
2665 	switch(eCursorPosition)
2666 	{
2667 		case IResultSetHelper::NEXT:
2668 			++m_nFilePos;
2669 			break;
2670 		case IResultSetHelper::PRIOR:
2671 			if (m_nFilePos > 0)
2672 				--m_nFilePos;
2673 			break;
2674 		case IResultSetHelper::FIRST:
2675 			m_nFilePos = 1;
2676 			break;
2677 		case IResultSetHelper::LAST:
2678 			m_nFilePos = nNumberOfRecords;
2679 			break;
2680 		case IResultSetHelper::RELATIVE:
2681 			m_nFilePos = (((sal_Int32)m_nFilePos) + nOffset < 0) ? 0L
2682 							: (sal_uInt32)(((sal_Int32)m_nFilePos) + nOffset);
2683 			break;
2684 		case IResultSetHelper::ABSOLUTE:
2685 		case IResultSetHelper::BOOKMARK:
2686 			m_nFilePos = (sal_uInt32)nOffset;
2687 			break;
2688 	}
2689 
2690 	if (m_nFilePos > (sal_Int32)nNumberOfRecords)
2691 		m_nFilePos = (sal_Int32)nNumberOfRecords + 1;
2692 
2693 	if (m_nFilePos == 0 || m_nFilePos == (sal_Int32)nNumberOfRecords + 1)
2694 		goto Error;
2695 	else
2696 	{
2697 		sal_uInt16 nEntryLen = m_aHeader.db_slng;
2698 
2699 		OSL_ENSURE(m_nFilePos >= 1,"SdbDBFCursor::FileFetchRow: ungueltige Record-Position");
2700 		sal_Int32 nPos = m_aHeader.db_kopf + (sal_Int32)(m_nFilePos-1) * nEntryLen;
2701 
2702 		sal_uIntPtr nLen = m_pFileStream->Seek(nPos);
2703 		if (m_pFileStream->GetError() != ERRCODE_NONE)
2704 			goto Error;
2705 
2706 		nLen = m_pFileStream->Read((char*)m_pBuffer, nEntryLen);
2707 		if (m_pFileStream->GetError() != ERRCODE_NONE)
2708 			goto Error;
2709 	}
2710 	goto End;
2711 
2712 Error:
2713 	switch(eCursorPosition)
2714 	{
2715 		case IResultSetHelper::PRIOR:
2716 		case IResultSetHelper::FIRST:
2717 			m_nFilePos = 0;
2718 			break;
2719 		case IResultSetHelper::LAST:
2720 		case IResultSetHelper::NEXT:
2721 		case IResultSetHelper::ABSOLUTE:
2722 		case IResultSetHelper::RELATIVE:
2723 			if (nOffset > 0)
2724 				m_nFilePos = nNumberOfRecords + 1;
2725 			else if (nOffset < 0)
2726 				m_nFilePos = 0;
2727 			break;
2728 		case IResultSetHelper::BOOKMARK:
2729 			m_nFilePos = nTempPos;	 // vorherige Position
2730 	}
2731 	//	aStatus.Set(SDB_STAT_NO_DATA_FOUND);
2732 	return sal_False;
2733 
2734 End:
2735 	nCurPos = m_nFilePos;
2736 	return sal_True;
2737 }
2738 // -----------------------------------------------------------------------------
ReadMemo(sal_uIntPtr nBlockNo,ORowSetValue & aVariable)2739 sal_Bool ODbaseTable::ReadMemo(sal_uIntPtr nBlockNo, ORowSetValue& aVariable)
2740 {
2741     RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbase", "Ocke.Janssen@sun.com", "ODbaseTable::ReadMemo" );
2742 	sal_Bool bIsText = sal_True;
2743 	//	SdbConnection* pConnection = GetConnection();
2744 
2745 	m_pMemoStream->Seek(nBlockNo * m_aMemoHeader.db_size);
2746 	switch (m_aMemoHeader.db_typ)
2747 	{
2748 		case MemodBaseIII: // dBase III-Memofeld, endet mit Ctrl-Z
2749 		{
2750 			const char cEOF = (char) DBF_EOL;
2751 			ByteString aBStr;
2752 			static char aBuf[514];
2753 			aBuf[512] = 0;			// sonst kann der Zufall uebel mitspielen
2754 			sal_Bool bReady = sal_False;
2755 
2756 			do
2757 			{
2758 				m_pMemoStream->Read(&aBuf,512);
2759 
2760 				sal_uInt16 i = 0;
2761 				while (aBuf[i] != cEOF && ++i < 512)
2762 					;
2763 				bReady = aBuf[i] == cEOF;
2764 
2765 				aBuf[i] = 0;
2766 				aBStr += aBuf;
2767 
2768 			} while (!bReady && !m_pMemoStream->IsEof() && aBStr.Len() < STRING_MAXLEN);
2769 
2770 			::rtl::OUString aStr(aBStr.GetBuffer(), aBStr.Len(),m_eEncoding);
2771 			aVariable = aStr;
2772 
2773 		} break;
2774 		case MemoFoxPro:
2775 		case MemodBaseIV: // dBase IV-Memofeld mit Laengenangabe
2776 		{
2777 			char sHeader[4];
2778 			m_pMemoStream->Read(sHeader,4);
2779 			// Foxpro stores text and binary data
2780 			if (m_aMemoHeader.db_typ == MemoFoxPro)
2781 			{
2782 //				if (((sal_uInt8)sHeader[0]) != 0 || ((sal_uInt8)sHeader[1]) != 0 || ((sal_uInt8)sHeader[2]) != 0)
2783 //				{
2784 ////					String aText = String(SdbResId(STR_STAT_IResultSetHelper::INVALID));
2785 ////					aText.SearchAndReplace(String::CreateFromAscii("%%d"),m_pMemoStream->GetFileName());
2786 ////					aText.SearchAndReplace(String::CreateFromAscii("%%t"),aStatus.TypeToString(MEMO));
2787 ////					aStatus.Set(SDB_STAT_ERROR,
2788 ////							String::CreateFromAscii("01000"),
2789 ////							aStatus.CreateErrorMessage(aText),
2790 ////							0, String() );
2791 //					return sal_False;
2792 //				}
2793 //
2794 				bIsText = sHeader[3] != 0;
2795 			}
2796 			else if (((sal_uInt8)sHeader[0]) != 0xFF || ((sal_uInt8)sHeader[1]) != 0xFF || ((sal_uInt8)sHeader[2]) != 0x08)
2797 			{
2798 //				String aText = String(SdbResId(STR_STAT_IResultSetHelper::INVALID));
2799 //				aText.SearchAndReplace(String::CreateFromAscii("%%d"),m_pMemoStream->GetFileName());
2800 //				aText.SearchAndReplace(String::CreateFromAscii("%%t"),aStatus.TypeToString(MEMO));
2801 //				aStatus.Set(SDB_STAT_ERROR,
2802 //						String::CreateFromAscii("01000"),
2803 //						aStatus.CreateErrorMessage(aText),
2804 //						0, String() );
2805 				return sal_False;
2806 			}
2807 
2808 			sal_uInt32 nLength(0);
2809 			(*m_pMemoStream) >> nLength;
2810 
2811 			if (m_aMemoHeader.db_typ == MemodBaseIV)
2812 				nLength -= 8;
2813 
2814             if ( nLength )
2815             {
2816                 if ( bIsText )
2817                 {
2818 			        //	char cChar;
2819 					::rtl::OUStringBuffer aStr;
2820 			        while ( nLength > STRING_MAXLEN )
2821 			        {
2822 				        ByteString aBStr;
2823 				        aBStr.Expand(STRING_MAXLEN);
2824 				        m_pMemoStream->Read(aBStr.AllocBuffer(STRING_MAXLEN),STRING_MAXLEN);
2825 						aStr.append(::rtl::OUString(aBStr.GetBuffer(),aBStr.Len(), m_eEncoding));
2826 				        nLength -= STRING_MAXLEN;
2827 			        }
2828 			        if ( nLength > 0 )
2829 			        {
2830 				        ByteString aBStr;
2831 				        aBStr.Expand(static_cast<xub_StrLen>(nLength));
2832 				        m_pMemoStream->Read(aBStr.AllocBuffer(static_cast<xub_StrLen>(nLength)),nLength);
2833 				        //	aBStr.ReleaseBufferAccess();
2834 						aStr.append(::rtl::OUString(aBStr.GetBuffer(),aBStr.Len(), m_eEncoding));
2835 			        }
2836 			        if ( aStr.getLength() )
2837 						aVariable = aStr.makeStringAndClear();
2838                 } // if ( bIsText )
2839                 else
2840                 {
2841                     ::com::sun::star::uno::Sequence< sal_Int8 > aData(nLength);
2842                     m_pMemoStream->Read(aData.getArray(),nLength);
2843                     aVariable = aData;
2844                 }
2845             } // if ( nLength )
2846 		}
2847 	}
2848 	return sal_True;
2849 }
2850 // -----------------------------------------------------------------------------
AllocBuffer()2851 void ODbaseTable::AllocBuffer()
2852 {
2853     RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbase", "Ocke.Janssen@sun.com", "ODbaseTable::AllocBuffer" );
2854 	sal_uInt16 nSize = m_aHeader.db_slng;
2855 	OSL_ENSURE(nSize > 0, "Size too small");
2856 
2857 	if (m_nBufferSize != nSize)
2858 	{
2859 		delete m_pBuffer;
2860 		m_pBuffer = NULL;
2861 	}
2862 
2863 	// Falls noch kein Puffer vorhanden: allozieren:
2864 	if (m_pBuffer == NULL && nSize > 0)
2865 	{
2866 		m_nBufferSize = nSize;
2867 		m_pBuffer		= new sal_uInt8[m_nBufferSize+1];
2868 	}
2869 }
2870 // -----------------------------------------------------------------------------
WriteBuffer()2871 sal_Bool ODbaseTable::WriteBuffer()
2872 {
2873     RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbase", "Ocke.Janssen@sun.com", "ODbaseTable::WriteBuffer" );
2874 	OSL_ENSURE(m_nFilePos >= 1,"SdbDBFCursor::FileFetchRow: ungueltige Record-Position");
2875 
2876 	// Auf gewuenschten Record positionieren:
2877 	long nPos = m_aHeader.db_kopf + (long)(m_nFilePos-1) * m_aHeader.db_slng;
2878 	m_pFileStream->Seek(nPos);
2879 	return m_pFileStream->Write((char*) m_pBuffer, m_aHeader.db_slng) > 0;
2880 }
2881 // -----------------------------------------------------------------------------
getCurrentLastPos() const2882 sal_Int32 ODbaseTable::getCurrentLastPos() const
2883 {
2884     RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbase", "Ocke.Janssen@sun.com", "ODbaseTable::getCurrentLastPos" );
2885 	return m_aHeader.db_anz;
2886 }
2887