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