Branch data Line data Source code
1 : : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 : : /*************************************************************************
3 : : *
4 : : * Effective License of whole file:
5 : : *
6 : : * This library is free software; you can redistribute it and/or
7 : : * modify it under the terms of the GNU Lesser General Public
8 : : * License version 2.1, as published by the Free Software Foundation.
9 : : *
10 : : * This library is distributed in the hope that it will be useful,
11 : : * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 : : * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 : : * Lesser General Public License for more details.
14 : : *
15 : : * You should have received a copy of the GNU Lesser General Public
16 : : * License along with this library; if not, write to the Free Software
17 : : * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
18 : : * MA 02111-1307 USA
19 : : *
20 : : * Parts "Copyright by Sun Microsystems, Inc" prior to August 2011:
21 : : *
22 : : * The Contents of this file are made available subject to the terms of
23 : : * the GNU Lesser General Public License Version 2.1
24 : : *
25 : : * Copyright: 2000 by Sun Microsystems, Inc.
26 : : *
27 : : * Contributor(s): Joerg Budischewski
28 : : *
29 : : * All parts contributed on or after August 2011:
30 : : *
31 : : * Version: MPL 1.1 / GPLv3+ / LGPLv2.1+
32 : : *
33 : : * The contents of this file are subject to the Mozilla Public License Version
34 : : * 1.1 (the "License"); you may not use this file except in compliance with
35 : : * the License or as specified alternatively below. You may obtain a copy of
36 : : * the License at http://www.mozilla.org/MPL/
37 : : *
38 : : * Software distributed under the License is distributed on an "AS IS" basis,
39 : : * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
40 : : * for the specific language governing rights and limitations under the
41 : : * License.
42 : : *
43 : : * Major Contributor(s):
44 : : * [ Copyright (C) 2011 Lionel Elie Mamane <lionel@mamane.lu> ]
45 : : *
46 : : * All Rights Reserved.
47 : : *
48 : : * For minor contributions see the git repository.
49 : : *
50 : : * Alternatively, the contents of this file may be used under the terms of
51 : : * either the GNU General Public License Version 3 or later (the "GPLv3+"), or
52 : : * the GNU Lesser General Public License Version 2.1 or later (the "LGPLv2.1+"),
53 : : * in which case the provisions of the GPLv3+ or the LGPLv2.1+ are applicable
54 : : * instead of those above.
55 : : *
56 : : ************************************************************************/
57 : :
58 : : #include <rtl/strbuf.hxx>
59 : : #include <rtl/ustrbuf.hxx>
60 : :
61 : : #include <com/sun/star/beans/XPropertySet.hpp>
62 : : #include <com/sun/star/lang/XComponent.hpp>
63 : :
64 : : #include <com/sun/star/sdbc/XRow.hpp>
65 : : #include <com/sun/star/sdbc/XParameters.hpp>
66 : : #include <com/sun/star/sdbc/DataType.hpp>
67 : : #include <com/sun/star/sdbc/KeyRule.hpp>
68 : : #include <com/sun/star/sdbcx/KeyType.hpp>
69 : : #include <com/sun/star/sdbcx/XColumnsSupplier.hpp>
70 : :
71 : : #include "pq_xcontainer.hxx"
72 : : #include "pq_tools.hxx"
73 : : #include "pq_statics.hxx"
74 : :
75 : : #include <libpq-fe.h>
76 : : #include <string.h>
77 : :
78 : : using rtl::OUString;
79 : : using rtl::OUStringBuffer;
80 : :
81 : : using com::sun::star::beans::XPropertySet;
82 : :
83 : : using com::sun::star::lang::XComponent;
84 : :
85 : : using com::sun::star::sdbc::SQLException;
86 : : using com::sun::star::sdbc::XStatement;
87 : : using com::sun::star::sdbc::XConnection;
88 : : using com::sun::star::sdbc::XPreparedStatement;
89 : : using com::sun::star::sdbc::XParameters;
90 : : using com::sun::star::sdbc::XResultSet;
91 : : using com::sun::star::sdbc::XRow;
92 : :
93 : : using com::sun::star::sdbcx::XColumnsSupplier;
94 : :
95 : : using com::sun::star::uno::RuntimeException;
96 : : using com::sun::star::uno::UNO_QUERY;
97 : : using com::sun::star::uno::UNO_QUERY_THROW;
98 : : using com::sun::star::uno::Reference;
99 : : using com::sun::star::uno::Sequence;
100 : : using com::sun::star::uno::XInterface;
101 : : using com::sun::star::uno::Any;
102 : : using com::sun::star::uno::makeAny;
103 : :
104 : : using com::sun::star::container::XEnumeration;
105 : : using com::sun::star::container::XEnumerationAccess;
106 : :
107 : : namespace pq_sdbc_driver
108 : : {
109 : : #define ASCII_STR(x) rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( x ) )
110 : :
111 : 0 : rtl::OUString date2String( const com::sun::star::util::Date & x )
112 : : {
113 : : char buffer[64];
114 : 0 : sprintf( buffer, "%d-%02d-%02d", x.Year, x.Month, x.Day );
115 : 0 : return OUString::createFromAscii( buffer );
116 : : }
117 : :
118 : 0 : com::sun::star::util::Date string2Date( const rtl::OUString &date )
119 : : {
120 : : // Format: Year-Month-Day
121 : 0 : com::sun::star::util::Date ret;
122 : :
123 : 0 : ret.Year = (sal_Int32) rtl_ustr_toInt32( date.pData->buffer, 10 );
124 : :
125 : 0 : int index = date.indexOf( '-' );
126 : 0 : if( index >= 0 )
127 : : {
128 : 0 : ret.Month = (sal_Int32)rtl_ustr_toInt32( &(date.pData->buffer[ index+1]), 10 );
129 : 0 : int start = index;
130 : 0 : index = date.indexOf( '-', start+1 );
131 : 0 : if( index >= 0 )
132 : : {
133 : 0 : ret.Day = (sal_Int32)rtl_ustr_toInt32( &date.pData->buffer[index+1], 10 );
134 : : }
135 : : }
136 : 0 : return ret;
137 : : }
138 : :
139 : 0 : rtl::OUString time2String( const com::sun::star::util::Time & x )
140 : : {
141 : : char buffer[64];
142 : 0 : sprintf( buffer, "%02d:%02d:%02d.%02d", x.Hours, x.Minutes, x.Seconds, x.HundredthSeconds );
143 : 0 : return OUString::createFromAscii( buffer );
144 : :
145 : : }
146 : :
147 : :
148 : 0 : com::sun::star::util::Time string2Time( const rtl::OUString & time )
149 : : {
150 : 0 : com::sun::star::util::Time ret;
151 : :
152 : : sal_Unicode temp[4];
153 : :
154 : 0 : temp[0] = time[0];
155 : 0 : temp[1] = time[1];
156 : 0 : temp[2] = 0;
157 : 0 : ret.Hours = (sal_Int32)rtl_ustr_toInt32( temp , 10 );
158 : :
159 : 0 : temp[0] = time[3];
160 : 0 : temp[1] = time[4];
161 : 0 : ret.Minutes = (sal_Int32)rtl_ustr_toInt32( temp , 10 );
162 : :
163 : 0 : temp[0] = time[6];
164 : 0 : temp[1] = time[7];
165 : 0 : ret.Seconds = (sal_Int32)rtl_ustr_toInt32( temp , 10 );
166 : :
167 : 0 : if( time.getLength() >9 )
168 : : {
169 : 0 : ret.HundredthSeconds = (sal_Int32)rtl_ustr_toInt32( &time.getStr()[9] , 10 );
170 : : }
171 : 0 : return ret;
172 : :
173 : : }
174 : :
175 : :
176 : :
177 : 0 : rtl::OUString dateTime2String( const com::sun::star::util::DateTime & x )
178 : : {
179 : : char buffer[128];
180 : : sprintf( buffer, "%d-%02d-%02d %02d:%02d:%02d.%02d",
181 : : x.Year, x.Month, x.Day,
182 : 0 : x.Hours, x.Minutes, x.Seconds, x.HundredthSeconds );
183 : 0 : return OUString::createFromAscii( buffer );
184 : :
185 : : }
186 : :
187 : 0 : com::sun::star::util::DateTime string2DateTime( const rtl::OUString & dateTime )
188 : : {
189 : 0 : int space = dateTime.indexOf( ' ' );
190 : 0 : com::sun::star::util::DateTime ret;
191 : :
192 : 0 : if( space >= 0 )
193 : : {
194 : 0 : com::sun::star::util::Date date ( string2Date( OUString( dateTime.getStr(), space ) ) );
195 : 0 : com::sun::star::util::Time time( string2Time( OUString( dateTime.getStr() + space +1 ) ) );
196 : 0 : ret.Day = date.Day;
197 : 0 : ret.Month = date.Month;
198 : 0 : ret.Year = date.Year;
199 : :
200 : 0 : ret.Hours = time.Hours;
201 : 0 : ret.Minutes = time.Minutes;
202 : 0 : ret.Seconds = time.Seconds;
203 : 0 : ret.HundredthSeconds = time.HundredthSeconds;
204 : : }
205 : 0 : return ret;
206 : : }
207 : :
208 : 0 : rtl::OUString concatQualified( const rtl::OUString & a, const rtl::OUString &b)
209 : : {
210 : 0 : rtl::OUStringBuffer buf( a.getLength() + 2 + b.getLength() );
211 : 0 : buf.append( a );
212 : 0 : buf.appendAscii( RTL_CONSTASCII_STRINGPARAM( "." ) );
213 : 0 : buf.append( b );
214 : 0 : return buf.makeStringAndClear();
215 : : }
216 : :
217 : 0 : static inline rtl::OString iOUStringToOString( const rtl::OUString str, ConnectionSettings *settings) {
218 : : OSL_ENSURE(settings, "pgsql-sdbc: OUStringToOString got NULL settings");
219 : 0 : return rtl::OUStringToOString( str, settings->encoding );
220 : : }
221 : :
222 : 0 : rtl::OString OUStringToOString( const rtl::OUString str, ConnectionSettings *settings) {
223 : 0 : return iOUStringToOString( str, settings );
224 : : }
225 : :
226 : 0 : void bufferEscapeConstant( rtl::OUStringBuffer & buf, const rtl::OUString & value, ConnectionSettings *settings )
227 : : {
228 : :
229 : 0 : rtl::OString y = iOUStringToOString( value, settings );
230 : 0 : rtl::OStringBuffer strbuf( y.getLength() * 2 + 2 );
231 : : int error;
232 : 0 : int len = PQescapeStringConn(settings->pConnection, ((char*)strbuf.getStr()), y.getStr() , y.getLength(), &error );
233 : 0 : if ( error )
234 : : {
235 : 0 : char *errstr = PQerrorMessage(settings->pConnection);
236 : : // As of PostgreSQL 9.1, the only possible errors "involve invalid multibyte encoding"
237 : : // According to https://www2.opengroup.org/ogsys/jsp/publications/PublicationDetails.jsp?publicationid=11216
238 : : // (X/Open SQL CLI, March 1995, ISBN: 1-85912-081-4, X/Open Document Number: C451)
239 : : // 22018 is for "Invalid character value" and seems to be the best match.
240 : : // We have no good XInterface Reference to pass here, so just give NULL
241 : 0 : throw SQLException(OUString(errstr, strlen(errstr), settings->encoding),
242 : : NULL,
243 : : OUString(RTL_CONSTASCII_USTRINGPARAM("22018")),
244 : : -1,
245 : 0 : Any());
246 : : }
247 : 0 : strbuf.setLength( len );
248 : : // Previously here RTL_TEXTENCODING_ASCII_US; as we set the PostgreSQL client_encoding to UTF8,
249 : : // we get UTF8 here, too. I'm not sure why it worked well before...
250 : 0 : buf.append( rtl::OStringToOUString( strbuf.makeStringAndClear(), RTL_TEXTENCODING_UTF8 ) );
251 : 0 : }
252 : :
253 : 0 : static inline void ibufferQuoteConstant( rtl::OUStringBuffer & buf, const rtl::OUString & value, ConnectionSettings *settings )
254 : : {
255 : 0 : buf.appendAscii( RTL_CONSTASCII_STRINGPARAM( "'" ) );
256 : 0 : bufferEscapeConstant( buf, value, settings );
257 : 0 : buf.appendAscii( RTL_CONSTASCII_STRINGPARAM( "'" ) );
258 : 0 : }
259 : :
260 : 0 : void bufferQuoteConstant( rtl::OUStringBuffer & buf, const rtl::OUString & value, ConnectionSettings *settings )
261 : : {
262 : 0 : return ibufferQuoteConstant( buf, value, settings );
263 : : }
264 : :
265 : 0 : void bufferQuoteAnyConstant( rtl::OUStringBuffer & buf, const Any &val, ConnectionSettings *settings )
266 : : {
267 : 0 : if( val.hasValue() )
268 : : {
269 : 0 : OUString str;
270 : 0 : val >>= str;
271 : 0 : bufferQuoteConstant( buf, str, settings );
272 : : }
273 : : else
274 : 0 : buf.appendAscii( RTL_CONSTASCII_STRINGPARAM( "NULL" ) );
275 : 0 : }
276 : :
277 : 0 : static inline void ibufferQuoteIdentifier( rtl::OUStringBuffer & buf, const rtl::OUString &toQuote, ConnectionSettings *settings )
278 : : {
279 : : OSL_ENSURE(settings, "pgsql-sdbc: bufferQuoteIdentifier got NULL settings");
280 : :
281 : 0 : rtl::OString y = iOUStringToOString( toQuote, settings );
282 : 0 : char *cstr = PQescapeIdentifier(settings->pConnection, y.getStr(), y.getLength());
283 : 0 : if ( cstr == NULL )
284 : : {
285 : 0 : char *errstr = PQerrorMessage(settings->pConnection);
286 : : // Implementation-defined SQLACCESS error
287 : 0 : throw SQLException(OUString(errstr, strlen(errstr), settings->encoding),
288 : : NULL,
289 : : OUString(RTL_CONSTASCII_USTRINGPARAM("22018")),
290 : : -1,
291 : 0 : Any());
292 : : }
293 : 0 : buf.append( rtl::OStringToOUString( cstr, RTL_TEXTENCODING_UTF8 ) );
294 : 0 : PQfreemem( cstr );
295 : 0 : }
296 : :
297 : 0 : void bufferQuoteIdentifier( rtl::OUStringBuffer & buf, const rtl::OUString &toQuote, ConnectionSettings *settings )
298 : : {
299 : 0 : return ibufferQuoteIdentifier(buf, toQuote, settings);
300 : : }
301 : :
302 : :
303 : 0 : void bufferQuoteQualifiedIdentifier(
304 : : rtl::OUStringBuffer & buf, const rtl::OUString &schema, const rtl::OUString &table, ConnectionSettings *settings )
305 : : {
306 : 0 : ibufferQuoteIdentifier(buf, schema, settings);
307 : 0 : buf.appendAscii( RTL_CONSTASCII_STRINGPARAM( "." ) );
308 : 0 : ibufferQuoteIdentifier(buf, table, settings);
309 : 0 : }
310 : :
311 : 0 : void bufferQuoteQualifiedIdentifier(
312 : : rtl::OUStringBuffer & buf,
313 : : const rtl::OUString &schema,
314 : : const rtl::OUString &table,
315 : : const rtl::OUString &col,
316 : : ConnectionSettings *settings)
317 : : {
318 : 0 : ibufferQuoteIdentifier(buf, schema, settings);
319 : 0 : buf.appendAscii( RTL_CONSTASCII_STRINGPARAM( "." ) );
320 : 0 : ibufferQuoteIdentifier(buf, table, settings);
321 : 0 : buf.appendAscii( RTL_CONSTASCII_STRINGPARAM( "." ) );
322 : 0 : ibufferQuoteIdentifier(buf, col, settings);
323 : 0 : }
324 : :
325 : :
326 : 0 : rtl::OUString extractStringProperty(
327 : : const Reference< XPropertySet > & descriptor, const rtl::OUString &name )
328 : : {
329 : 0 : rtl::OUString value;
330 : 0 : descriptor->getPropertyValue( name ) >>= value;
331 : 0 : return value;
332 : : }
333 : :
334 : 0 : sal_Bool extractBoolProperty(
335 : : const Reference< XPropertySet > & descriptor, const rtl::OUString &name )
336 : : {
337 : 0 : sal_Bool value = sal_False;
338 : 0 : descriptor->getPropertyValue( name ) >>= value;
339 : 0 : return value;
340 : : }
341 : :
342 : 0 : sal_Int32 extractIntProperty(
343 : : const Reference< XPropertySet > & descriptor, const rtl::OUString &name )
344 : : {
345 : 0 : sal_Int32 ret = 0;
346 : 0 : descriptor->getPropertyValue( name ) >>= ret;
347 : 0 : return ret;
348 : : }
349 : :
350 : 0 : void disposeObject( const com::sun::star::uno::Reference< com::sun::star::uno::XInterface > & r )
351 : : {
352 : 0 : Reference< XComponent > comp( r, UNO_QUERY );
353 : 0 : if( comp.is() )
354 : 0 : comp->dispose();
355 : 0 : }
356 : :
357 : 0 : void disposeNoThrow( const com::sun::star::uno::Reference< com::sun::star::uno::XInterface > & r )
358 : : {
359 : : try
360 : : {
361 : 0 : disposeObject( r );
362 : : }
363 : 0 : catch( SQLException & )
364 : : {
365 : : // ignore this
366 : : }
367 : :
368 : 0 : }
369 : :
370 : 0 : Reference< XConnection > extractConnectionFromStatement( const Reference< XInterface > & stmt )
371 : : {
372 : 0 : Reference< XConnection > ret;
373 : :
374 : 0 : Reference< com::sun::star::sdbc::XStatement > owner( stmt, UNO_QUERY );
375 : 0 : if( owner.is() )
376 : 0 : ret = owner->getConnection();
377 : : else
378 : : {
379 : 0 : Reference< com::sun::star::sdbc::XPreparedStatement > myowner( stmt, UNO_QUERY );
380 : 0 : if( myowner.is() )
381 : 0 : ret = myowner->getConnection();
382 : 0 : if( ! ret.is() )
383 : : throw SQLException(
384 : : ASCII_STR( "PQSDBC: Couldn't retrieve connection from statement" ),
385 : 0 : Reference< XInterface > () , rtl::OUString(), 0 , com::sun::star::uno::Any() );
386 : : }
387 : :
388 : 0 : return ret;
389 : :
390 : : }
391 : :
392 : 0 : DisposeGuard::DisposeGuard( const Reference< XInterface > & r )
393 : 0 : : d( r )
394 : 0 : {}
395 : :
396 : 0 : DisposeGuard::~DisposeGuard()
397 : : {
398 : 0 : disposeNoThrow( d );
399 : 0 : }
400 : :
401 : 0 : TransactionGuard::TransactionGuard( const Reference< XStatement > &stmt )
402 : : : m_stmt( stmt ),
403 : 0 : m_commited( sal_False )
404 : : {
405 : 0 : m_stmt->executeUpdate( getStatics().BEGIN );
406 : 0 : }
407 : :
408 : 0 : void TransactionGuard::commit()
409 : : {
410 : 0 : m_stmt->executeUpdate( getStatics().COMMIT );
411 : 0 : m_commited = sal_True;
412 : 0 : }
413 : :
414 : 0 : void TransactionGuard::executeUpdate( const rtl::OUString & sql )
415 : : {
416 : 0 : m_stmt->executeUpdate( sql );
417 : 0 : }
418 : :
419 : 0 : TransactionGuard::~TransactionGuard()
420 : : {
421 : : try
422 : : {
423 : 0 : if( ! m_commited )
424 : 0 : m_stmt->executeUpdate( getStatics().ROLLBACK );
425 : : }
426 : 0 : catch( com::sun::star::uno::Exception & )
427 : : {
428 : : // ignore, we are within a dtor
429 : : }
430 : :
431 : 0 : disposeNoThrow( m_stmt );
432 : 0 : }
433 : :
434 : :
435 : 0 : bool isWhitespace( sal_Unicode c )
436 : : {
437 : 0 : return ' ' == c || 9 == c || 10 == c || 13 == c;
438 : : }
439 : :
440 : 0 : ::rtl::OUString extractTableFromInsert( const rtl::OUString & sql )
441 : : {
442 : 0 : rtl::OUString ret;
443 : 0 : int i = 0;
444 : 0 : for( ; i < sql.getLength() && isWhitespace(sql[i]) ; i++ );
445 : :
446 : 0 : if( 0 == rtl_ustr_ascii_shortenedCompareIgnoreAsciiCase_WithLength(
447 : 0 : &sql.getStr()[i], sql.getLength() - i, "insert" , 6 ) )
448 : : {
449 : 0 : i += 6;
450 : 0 : for( ; i < sql.getLength() && isWhitespace(sql[i]) ; i++ );
451 : 0 : if( 0 == rtl_ustr_ascii_shortenedCompareIgnoreAsciiCase_WithLength(
452 : 0 : &sql.getStr()[i], sql.getLength() - i, "into" , 4 ) )
453 : : {
454 : 0 : i +=4;
455 : 0 : for( ; i < sql.getLength() && isWhitespace(sql[i]) ; i++ );
456 : 0 : int start = i;
457 : 0 : bool quote = (sql[i] == '"');
458 : 0 : for( i++ ; i < sql.getLength() ; i ++ )
459 : : {
460 : 0 : if( quote && sql[i] == '"' )
461 : : {
462 : 0 : for( i++ ; i < sql.getLength() && isWhitespace(sql[i]) ; i++ );
463 : 0 : if( '.' == sql[i] )
464 : : {
465 : 0 : for( i++ ; i < sql.getLength() && isWhitespace(sql[i]) ; i++ );
466 : 0 : if( '"' == sql[i] )
467 : : {
468 : : // the second part of the table name does not use quotes
469 : : // parse on
470 : 0 : quote = 0;
471 : : }
472 : : }
473 : : else
474 : : {
475 : : // end quoted name, ok
476 : 0 : break;
477 : : }
478 : : }
479 : : else
480 : : {
481 : 0 : if( isWhitespace( sql[i] ) )
482 : : {
483 : : // found the end of an unquoted name
484 : 0 : break;
485 : : }
486 : : }
487 : : }
488 : 0 : ret = rtl::OUString( &sql.getStr()[start], i - start ).trim();
489 : : // printf( "pq_statement: parsed table name %s from insert\n" ,
490 : : // OUStringToOString( ret, RTL_TEXTENCODING_ASCII_US).getStr() );
491 : : }
492 : : }
493 : 0 : return ret;
494 : : }
495 : :
496 : :
497 : 0 : static bool isOperator( char c )
498 : : {
499 : : bool ret;
500 : 0 : switch(c)
501 : : {
502 : : case '+':
503 : : case '-':
504 : : case '*':
505 : : case '/':
506 : : case '<':
507 : : case '>':
508 : : case '=':
509 : : case '~':
510 : : case '!':
511 : : case '@':
512 : : case '#':
513 : : case '%':
514 : : case '^':
515 : : case '&':
516 : : case '|':
517 : : case '`':
518 : : case '?':
519 : : case '$':
520 : 0 : ret = true;
521 : 0 : break;
522 : : default:
523 : 0 : ret = false;
524 : : }
525 : 0 : return ret;
526 : : }
527 : :
528 : 0 : void splitSQL( const rtl::OString & sql, OStringVector &vec )
529 : : {
530 : 0 : int length = sql.getLength();
531 : :
532 : 0 : int i = 0;
533 : 0 : bool singleQuote = false;
534 : 0 : bool doubleQuote = false;
535 : 0 : int start = 0;
536 : 0 : for( ; i < length ; i ++ )
537 : : {
538 : 0 : char c = sql[i];
539 : 0 : if( doubleQuote )
540 : : {
541 : 0 : if( '"' == c )
542 : : {
543 : 0 : vec.push_back( rtl::OString( &sql.getStr()[start], i-start+1 ) );
544 : 0 : start = i + 1;
545 : 0 : doubleQuote = false;
546 : : }
547 : : }
548 : 0 : else if( singleQuote )
549 : : {
550 : 0 : if( '\'' == c && '\'' == sql[i+1] )
551 : : {
552 : : // two subsequent single quotes within a quoted string
553 : : // mean a single quote within the string
554 : 0 : i ++;
555 : : }
556 : 0 : else if( '\'' == c )
557 : : {
558 : 0 : vec.push_back( rtl::OString( &sql.getStr()[start], i - start +1 ) );
559 : 0 : start = i + 1; // leave single quotes !
560 : 0 : singleQuote = false;
561 : : }
562 : : }
563 : : else
564 : : {
565 : 0 : if( '"' == c )
566 : : {
567 : 0 : vec.push_back( rtl::OString( &sql.getStr()[start], i - start ) );
568 : 0 : doubleQuote = true;
569 : 0 : start = i;
570 : : }
571 : 0 : else if( '\'' == c )
572 : : {
573 : 0 : vec.push_back( rtl::OString( &sql.getStr()[start], i - start ) );
574 : 0 : singleQuote = true;
575 : 0 : start = i;
576 : : }
577 : : }
578 : : }
579 : 0 : if( start < i )
580 : 0 : vec.push_back( rtl::OString( &sql.getStr()[start] , i - start ) );
581 : :
582 : : // for( i = 0 ; i < vec.size() ; i ++ )
583 : : // printf( "%s!" , vec[i].getStr() );
584 : : // printf( "\n" );
585 : :
586 : 0 : }
587 : :
588 : 0 : void tokenizeSQL( const rtl::OString & sql, OStringVector &vec )
589 : : {
590 : 0 : int length = sql.getLength();
591 : :
592 : 0 : int i = 0;
593 : 0 : bool singleQuote = false;
594 : 0 : bool doubleQuote = false;
595 : 0 : int start = 0;
596 : 0 : for( ; i < length ; i ++ )
597 : : {
598 : 0 : char c = sql[i];
599 : 0 : if( doubleQuote )
600 : : {
601 : 0 : if( '"' == c )
602 : : {
603 : 0 : vec.push_back( rtl::OString( &sql.getStr()[start], i-start ) );
604 : 0 : start = i + 1;
605 : 0 : doubleQuote = false;
606 : : }
607 : : }
608 : 0 : else if( singleQuote )
609 : : {
610 : 0 : if( '\'' == c )
611 : : {
612 : 0 : vec.push_back( rtl::OString( &sql.getStr()[start], i - start +1 ) );
613 : 0 : start = i + 1; // leave single quotes !
614 : 0 : singleQuote = false;
615 : : }
616 : : }
617 : : else
618 : : {
619 : 0 : if( '"' == c )
620 : : {
621 : 0 : doubleQuote = true;
622 : 0 : start = i +1; // skip double quotes !
623 : : }
624 : 0 : else if( '\'' == c )
625 : : {
626 : 0 : singleQuote = true;
627 : 0 : start = i; // leave single quotes
628 : : }
629 : 0 : else if( isWhitespace( c ) )
630 : : {
631 : 0 : if( i == start )
632 : 0 : start ++; // skip additional whitespace
633 : : else
634 : : {
635 : 0 : vec.push_back( rtl::OString( &sql.getStr()[start], i - start ) );
636 : 0 : start = i +1;
637 : : }
638 : : }
639 : 0 : else if( ',' == c || isOperator( c ) || '(' == c || ')' == c )
640 : : {
641 : 0 : if( i - start )
642 : 0 : vec.push_back( rtl::OString( &sql.getStr()[start], i - start ) );
643 : 0 : vec.push_back( rtl::OString( &sql.getStr()[i], 1 ) );
644 : 0 : start = i + 1;
645 : : }
646 : 0 : else if( '.' == c )
647 : : {
648 : 0 : if( ( i > start && sql[start] >= '0' && sql[start] <= '9' ) ||
649 : 0 : ( i == start && i > 1 && isWhitespace( sql[i-1] ) ) )
650 : : {
651 : : // ignore, is a literal
652 : : }
653 : : else
654 : : {
655 : 0 : if( i - start )
656 : 0 : vec.push_back( rtl::OString( &sql.getStr()[start], i - start ) );
657 : 0 : vec.push_back( rtl::OString( RTL_CONSTASCII_STRINGPARAM( "." ) ) );
658 : 0 : start = i + 1;
659 : : }
660 : : }
661 : : }
662 : : }
663 : 0 : if( start < i )
664 : 0 : vec.push_back( rtl::OString( &sql.getStr()[start] , i - start ) );
665 : :
666 : : // for( i = 0 ; i < vec.size() ; i ++ )
667 : : // printf( "%s!" , vec[i].getStr() );
668 : : // printf( "\n" );
669 : 0 : }
670 : :
671 : :
672 : 0 : void splitConcatenatedIdentifier( const rtl::OUString & source, rtl::OUString *first, rtl::OUString *second)
673 : : {
674 : 0 : OStringVector vec;
675 : 0 : tokenizeSQL( rtl::OUStringToOString( source, RTL_TEXTENCODING_UTF8 ), vec );
676 : 0 : if( vec.size() == 3 )
677 : : {
678 : 0 : *first = rtl::OStringToOUString( vec[0] , RTL_TEXTENCODING_UTF8 );
679 : 0 : *second = rtl::OStringToOUString( vec[2], RTL_TEXTENCODING_UTF8 );
680 : 0 : }
681 : 0 : }
682 : :
683 : : typedef std::vector< sal_Int32 , Allocator< sal_Int32 > > IntVector;
684 : :
685 : :
686 : 0 : rtl::OUString array2String( const com::sun::star::uno::Sequence< Any > &seq )
687 : : {
688 : 0 : OUStringBuffer buf(128);
689 : 0 : int len = seq.getLength();
690 : 0 : buf.appendAscii( RTL_CONSTASCII_STRINGPARAM( "{" ) );
691 : 0 : for( int i = 0 ; i < len ; i ++ )
692 : : {
693 : 0 : OUString element;
694 : 0 : seq[i] >>= element;
695 : :
696 : 0 : if( i > 0 )
697 : 0 : buf.appendAscii( RTL_CONSTASCII_STRINGPARAM(",") );
698 : 0 : int strLength = element.getLength();
699 : 0 : buf.appendAscii( RTL_CONSTASCII_STRINGPARAM( "\"") );
700 : 0 : for( int j = 0 ; j < strLength ; j ++ )
701 : : {
702 : 0 : sal_Unicode c = element[j];
703 : 0 : if( c == '\\' || c == '"' || c == '{' || c == '}' )
704 : : {
705 : 0 : buf.appendAscii( RTL_CONSTASCII_STRINGPARAM( "\\" ) );
706 : : }
707 : 0 : buf.append( c );
708 : : }
709 : 0 : buf.appendAscii( RTL_CONSTASCII_STRINGPARAM( "\"" ) );
710 : 0 : }
711 : 0 : buf.appendAscii( RTL_CONSTASCII_STRINGPARAM( "}" ) );
712 : 0 : return buf.makeStringAndClear();
713 : : }
714 : :
715 : : typedef
716 : : std::vector
717 : : <
718 : : com::sun::star::uno::Any,
719 : : Allocator< com::sun::star::uno::Any >
720 : : > AnyVector;
721 : :
722 : 0 : com::sun::star::uno::Sequence< Any > parseArray( const rtl::OUString & str ) throw( SQLException )
723 : : {
724 : 0 : com::sun::star::uno::Sequence< Any > ret;
725 : :
726 : 0 : int len = str.getLength();
727 : 0 : bool doubleQuote = false;
728 : 0 : int brackets = 0;
729 : 0 : int i = 0;
730 : :
731 : 0 : OUStringBuffer current;
732 : 0 : AnyVector elements;
733 : 0 : bool doubleQuotedValue = false;
734 : 0 : while( i < len )
735 : : {
736 : 0 : sal_Unicode c = str[i];
737 : 0 : sal_Unicode cnext = str[i+1];
738 : 0 : if( doubleQuote )
739 : : {
740 : 0 : if( '\\' == c )
741 : : {
742 : 0 : i ++;
743 : 0 : current.append( cnext );
744 : : }
745 : 0 : else if( '"' == c )
746 : : {
747 : 0 : doubleQuote = false;
748 : 0 : doubleQuotedValue = true; // signal, that there was an empty element
749 : : }
750 : : else
751 : : {
752 : 0 : current.append( c );
753 : : }
754 : : }
755 : 0 : else if ( '{' == c )
756 : : {
757 : 0 : brackets ++;
758 : : }
759 : 0 : else if( '}' == c )
760 : : {
761 : 0 : brackets --;
762 : 0 : if( brackets < 0 )
763 : : {
764 : :
765 : 0 : OUStringBuffer buf;
766 : 0 : buf.appendAscii( "error during array parsing, didn't expect a } at position " );
767 : 0 : buf.append( (sal_Int32) i );
768 : 0 : buf.appendAscii( " ('" );
769 : 0 : buf.append( str );
770 : 0 : buf.appendAscii( "')" );
771 : : throw SQLException(
772 : : buf.makeStringAndClear(),
773 : 0 : Reference< XInterface > (), rtl::OUString(), 1, Any() );
774 : : }
775 : 0 : if( brackets == 0 )
776 : : {
777 : 0 : if( current.getLength() > 0 || doubleQuotedValue )
778 : 0 : elements.push_back( makeAny( current.makeStringAndClear() ) );
779 : : }
780 : : else
781 : : {
782 : 0 : current.append( c );
783 : : }
784 : : }
785 : 0 : else if( '"' == c )
786 : : {
787 : : // if( current.getLength() != 0 )
788 : : // {
789 : : // OUStringBuffer buf;
790 : : // buf.appendAscii( "error during array parsing, didn't expect a \" at position " );
791 : : // buf.append( i );
792 : : // buf.append( " ('" );
793 : : // buf.append( str );
794 : : // buf.append( "')" );
795 : : // throw SDBCException(
796 : : // buf.makeStringAndClear(),
797 : : // Reference< XInterface > (), 1, Any() );
798 : : // }
799 : : // else
800 : : // {
801 : 0 : doubleQuote = true;
802 : : // }
803 : : }
804 : 0 : else if( ',' == c && brackets == 1)
805 : : {
806 : 0 : doubleQuotedValue = false;
807 : 0 : elements.push_back( makeAny( current.makeStringAndClear() ) );
808 : : }
809 : 0 : else if( isWhitespace( c ) )
810 : : {
811 : : // ignore whitespace without quotes
812 : : }
813 : : else
814 : : {
815 : 0 : current.append( c );
816 : : }
817 : 0 : i++;
818 : : }
819 : 0 : return sequence_of_vector(elements);
820 : : }
821 : :
822 : 0 : com::sun::star::uno::Sequence< sal_Int32 > parseIntArray( const ::rtl::OUString & str )
823 : : {
824 : 0 : sal_Int32 start = 0;
825 : 0 : IntVector vec;
826 : : // printf( ">%s<\n" , OUStringToOString( str, RTL_TEXTENCODING_UTF8 ).getStr() );
827 : 0 : for( sal_Int32 i = str.indexOf( ' ' ) ; i != -1 ; i = str.indexOf( ' ', start) )
828 : : {
829 : 0 : vec.push_back( (sal_Int32)rtl_ustr_toInt32( &str.pData->buffer[start], 10 ) );
830 : : // printf( "found %d\n" , rtl_ustr_toInt32( &str.pData->buffer[start], 10 ));
831 : 0 : start = i + 1;
832 : : }
833 : 0 : vec.push_back( (sal_Int32)rtl_ustr_toInt32( &str.pData->buffer[start], 10 ) );
834 : : // printf( "found %d\n" , rtl_ustr_toInt32( &str.pData->buffer[start], 10 ));
835 : 0 : return sequence_of_vector(vec);
836 : : }
837 : :
838 : 0 : void fillAttnum2attnameMap(
839 : : Int2StringMap &map,
840 : : const Reference< com::sun::star::sdbc::XConnection > &conn,
841 : : const rtl::OUString &schema,
842 : : const rtl::OUString &table )
843 : : {
844 : 0 : Reference< XPreparedStatement > prep = conn->prepareStatement(
845 : : ASCII_STR( "SELECT attname,attnum "
846 : : "FROM pg_attribute "
847 : : "INNER JOIN pg_class ON attrelid = pg_class.oid "
848 : : "INNER JOIN pg_namespace ON pg_class.relnamespace = pg_namespace.oid "
849 : 0 : "WHERE relname=? AND nspname=?" ) );
850 : :
851 : 0 : Reference< XParameters > paras( prep, UNO_QUERY_THROW );
852 : 0 : paras->setString( 1 , table );
853 : 0 : paras->setString( 2 , schema );
854 : 0 : Reference< XResultSet > rs = prep->executeQuery();
855 : :
856 : 0 : Reference< XRow > xRow( rs , UNO_QUERY_THROW );
857 : 0 : while( rs->next() )
858 : : {
859 : 0 : map[ xRow->getInt(2) ] = xRow->getString(1);
860 : 0 : }
861 : 0 : }
862 : :
863 : 0 : ::rtl::OString extractSingleTableFromSelect( const OStringVector &vec )
864 : : {
865 : 0 : rtl::OString ret;
866 : :
867 : 0 : if( 0 == rtl_str_shortenedCompareIgnoreAsciiCase_WithLength(
868 : 0 : vec[0].pData->buffer, vec[0].pData->length, "select" , 6 , 6 ) )
869 : : {
870 : 0 : size_t token = 0;
871 : :
872 : 0 : for( token = 1; token < vec.size() ; token ++ )
873 : : {
874 : 0 : if( 0 == rtl_str_shortenedCompareIgnoreAsciiCase_WithLength(
875 : 0 : vec[token].getStr(), vec[token].getLength(), "from" , 4 , 4 ) )
876 : : {
877 : : // found from
878 : 0 : break;
879 : : }
880 : : }
881 : 0 : token ++;
882 : :
883 : 0 : if( token < vec.size() && 0 == rtl_str_shortenedCompareIgnoreAsciiCase_WithLength(
884 : 0 : vec[token].pData->buffer, vec[token].pData->length, "only " , 4 , 4 ) )
885 : : {
886 : 0 : token ++;
887 : : }
888 : :
889 : 0 : if( token < vec.size() && rtl_str_compare_WithLength(
890 : 0 : vec[token].getStr(), vec[token].getLength(),
891 : 0 : RTL_CONSTASCII_STRINGPARAM("(") ) )
892 : : {
893 : : // it is a table or a function name
894 : 0 : rtl::OStringBuffer buf(128);
895 : 0 : if( '"' == vec[token][0] )
896 : 0 : buf.append( &(vec[token].getStr()[1]) , vec[token].getLength() -2 );
897 : : else
898 : 0 : buf.append( vec[token] );
899 : 0 : token ++;
900 : :
901 : 0 : if( token < vec.size() )
902 : : {
903 : 0 : if( rtl_str_compare_WithLength(
904 : 0 : vec[token].getStr(), vec[token].getLength(),
905 : 0 : RTL_CONSTASCII_STRINGPARAM( "." ) ) == 0 )
906 : : {
907 : 0 : buf.append( vec[token] );
908 : 0 : token ++;
909 : 0 : if( token < vec.size() )
910 : : {
911 : 0 : if( '"' == vec[token][0] )
912 : 0 : buf.append( &(vec[token].getStr()[1]) , vec[token].getLength() -2 );
913 : : else
914 : 0 : buf.append( vec[token] );
915 : 0 : token ++;
916 : : }
917 : : }
918 : : }
919 : :
920 : 0 : ret = buf.makeStringAndClear();
921 : : // now got my table candidate
922 : :
923 : 0 : if( token < vec.size() && rtl_str_compare_WithLength(
924 : 0 : vec[token].getStr(), vec[token].getLength(),
925 : 0 : RTL_CONSTASCII_STRINGPARAM( "(" ) ) == 0 )
926 : : {
927 : : // whoops, it is a function
928 : 0 : ret = rtl::OString();
929 : : }
930 : : else
931 : : {
932 : 0 : if( token < vec.size() )
933 : : {
934 : 0 : if( 0 == rtl_str_shortenedCompareIgnoreAsciiCase_WithLength(
935 : 0 : vec[token].pData->buffer, vec[token].pData->length, "as" , 2, 2 ) )
936 : : {
937 : 0 : token += 2; // skip alias
938 : : }
939 : : }
940 : :
941 : 0 : if( token < vec.size() )
942 : : {
943 : 0 : if( rtl_str_compare_WithLength(
944 : 0 : vec[token].getStr(), vec[token].getLength(),
945 : 0 : RTL_CONSTASCII_STRINGPARAM( "," ) ) == 0 )
946 : : {
947 : : // whoops, multiple tables are used
948 : 0 : ret = rtl::OString();
949 : : }
950 : : else
951 : : {
952 : : static const char * forbiddenKeywords[] =
953 : : { "join", "natural", "outer", "inner", "left", "right", "full" , 0 };
954 : 0 : for( int i = 0 ; forbiddenKeywords[i] ; i ++ )
955 : : {
956 : 0 : if( 0 == rtl_str_shortenedCompareIgnoreAsciiCase_WithLength(
957 : 0 : vec[token].pData->buffer, vec[token].pData->length,
958 : 0 : forbiddenKeywords[i], strlen(forbiddenKeywords[i]),
959 : 0 : strlen(forbiddenKeywords[i]) ) )
960 : : {
961 : : // whoops, it is a join
962 : 0 : ret = rtl::OString();
963 : : }
964 : : }
965 : : }
966 : : }
967 : 0 : }
968 : : }
969 : : }
970 : 0 : return ret;
971 : :
972 : : }
973 : :
974 : 0 : com::sun::star::uno::Sequence< sal_Int32 > string2intarray( const ::rtl::OUString & str )
975 : : {
976 : 0 : com::sun::star::uno::Sequence< sal_Int32 > ret;
977 : 0 : const sal_Int32 strlen = str.getLength();
978 : 0 : if( str.getLength() > 1 )
979 : : {
980 : 0 : sal_Int32 start = 0;
981 : 0 : while ( iswspace( str.iterateCodePoints(&start) ) )
982 : 0 : if ( start == strlen)
983 : : return ret;
984 : 0 : if ( str.iterateCodePoints(&start) != L'{' )
985 : : return ret;
986 : 0 : while ( iswspace( str.iterateCodePoints(&start) ) )
987 : 0 : if ( start == strlen)
988 : : return ret;
989 : 0 : if ( str.iterateCodePoints(&start, 0) == L'}' )
990 : : return ret;
991 : :
992 : 0 : std::vector< sal_Int32, Allocator< sal_Int32 > > vec;
993 : 0 : do
994 : : {
995 : 0 : ::rtl::OUString digits;
996 : : sal_Int32 c;
997 : 0 : while ( isdigit( c = str.iterateCodePoints(&start) ) )
998 : : {
999 : 0 : if ( start == strlen)
1000 : : return ret;
1001 : 0 : digits += OUString(c);
1002 : : }
1003 : 0 : vec.push_back( digits.toInt32() );
1004 : 0 : while ( iswspace( str.iterateCodePoints(&start) ) )
1005 : 0 : if ( start == strlen)
1006 : : return ret;
1007 : 0 : if ( str.iterateCodePoints(&start, 0) == L'}' )
1008 : : break;
1009 : 0 : if ( str.iterateCodePoints(&start) != L',' )
1010 : : return ret;
1011 : 0 : if ( start == strlen)
1012 : 0 : return ret;
1013 : : } while( true );
1014 : : // vec is guaranteed non-empty
1015 : 0 : ret = com::sun::star::uno::Sequence< sal_Int32 > ( &vec[0] , vec.size() );
1016 : : }
1017 : 0 : return ret;
1018 : : }
1019 : :
1020 : :
1021 : 0 : Sequence< rtl::OUString > convertMappedIntArray2StringArray(
1022 : : const Int2StringMap &map, const Sequence< sal_Int32 > &intArray )
1023 : : {
1024 : 0 : Sequence< ::rtl::OUString > ret( intArray.getLength() );
1025 : 0 : for( int i = 0; i < intArray.getLength() ; i ++ )
1026 : : {
1027 : 0 : Int2StringMap::const_iterator ii = map.find( intArray[i] );
1028 : 0 : if( ii != map.end() )
1029 : 0 : ret[i] = ii->second;
1030 : : }
1031 : 0 : return ret;
1032 : : }
1033 : :
1034 : :
1035 : 0 : ::rtl::OUString sqltype2string( const Reference< XPropertySet > & desc )
1036 : : {
1037 : 0 : OUStringBuffer typeName;
1038 : 0 : typeName.append( extractStringProperty( desc, getStatics().TYPE_NAME ) );
1039 : 0 : sal_Int32 precision = extractIntProperty( desc, getStatics().PRECISION );
1040 : :
1041 : 0 : if( precision )
1042 : : {
1043 : 0 : switch( extractIntProperty( desc, getStatics().TYPE ) )
1044 : : {
1045 : : case com::sun::star::sdbc::DataType::VARBINARY:
1046 : : case com::sun::star::sdbc::DataType::VARCHAR:
1047 : : case com::sun::star::sdbc::DataType::CHAR:
1048 : : {
1049 : 0 : typeName.appendAscii( RTL_CONSTASCII_STRINGPARAM( "(" ) );
1050 : 0 : typeName.append( precision );
1051 : 0 : typeName.appendAscii( RTL_CONSTASCII_STRINGPARAM( ")" ) );
1052 : 0 : break;
1053 : : }
1054 : : case com::sun::star::sdbc::DataType::DECIMAL:
1055 : : case com::sun::star::sdbc::DataType::NUMERIC:
1056 : : {
1057 : 0 : typeName.appendAscii( RTL_CONSTASCII_STRINGPARAM( "(" ) );
1058 : 0 : typeName.append( precision );
1059 : 0 : typeName.appendAscii( RTL_CONSTASCII_STRINGPARAM( "," ) );
1060 : 0 : typeName.append( extractIntProperty( desc, getStatics().SCALE ) );
1061 : 0 : typeName.appendAscii( RTL_CONSTASCII_STRINGPARAM( ")" ) );
1062 : 0 : break;
1063 : : }
1064 : : default:
1065 : : ((void)0);
1066 : : }
1067 : : }
1068 : 0 : return typeName.makeStringAndClear();
1069 : : }
1070 : :
1071 : :
1072 : :
1073 : :
1074 : 0 : static void keyType2String( OUStringBuffer & buf, sal_Int32 keyType )
1075 : : {
1076 : 0 : if( com::sun::star::sdbc::KeyRule::CASCADE == keyType )
1077 : : {
1078 : 0 : buf.appendAscii( RTL_CONSTASCII_STRINGPARAM( "CASCADE " ) );
1079 : : }
1080 : 0 : else if( com::sun::star::sdbc::KeyRule::RESTRICT == keyType )
1081 : : {
1082 : 0 : buf.appendAscii( RTL_CONSTASCII_STRINGPARAM( "RESTRICT " ) );
1083 : : }
1084 : 0 : else if( com::sun::star::sdbc::KeyRule::SET_DEFAULT == keyType )
1085 : : {
1086 : 0 : buf.appendAscii( RTL_CONSTASCII_STRINGPARAM( "SET DEFAULT " ) );
1087 : : }
1088 : 0 : else if( com::sun::star::sdbc::KeyRule::SET_NULL == keyType )
1089 : : {
1090 : 0 : buf.appendAscii( RTL_CONSTASCII_STRINGPARAM( "SET NULL " ) );
1091 : : }
1092 : : else //if( com::sun::star::sdbc::KeyRule::NO_ACTION == keyType )
1093 : : {
1094 : 0 : buf.appendAscii( RTL_CONSTASCII_STRINGPARAM( "NO ACTION " ) );
1095 : : }
1096 : 0 : }
1097 : :
1098 : 0 : void bufferKey2TableConstraint(
1099 : : OUStringBuffer &buf, const Reference< XPropertySet > &key, ConnectionSettings *settings )
1100 : : {
1101 : 0 : Statics &st = getStatics();
1102 : 0 : sal_Int32 type = extractIntProperty( key, st.TYPE );
1103 : 0 : OUString referencedTable = extractStringProperty( key, st.REFERENCED_TABLE );
1104 : 0 : sal_Int32 updateRule = extractIntProperty( key, st.UPDATE_RULE );
1105 : 0 : sal_Int32 deleteRule = extractIntProperty( key, st.DELETE_RULE );
1106 : 0 : bool foreign = false;
1107 : 0 : if( type == com::sun::star::sdbcx::KeyType::UNIQUE )
1108 : : {
1109 : 0 : buf.appendAscii( RTL_CONSTASCII_STRINGPARAM( "UNIQUE( " ) );
1110 : : }
1111 : 0 : else if( type == com::sun::star::sdbcx::KeyType::PRIMARY )
1112 : : {
1113 : 0 : buf.appendAscii( RTL_CONSTASCII_STRINGPARAM( "PRIMARY KEY( " ) );
1114 : : }
1115 : 0 : else if( type == com::sun::star::sdbcx::KeyType::FOREIGN )
1116 : : {
1117 : 0 : foreign = true;
1118 : 0 : buf.appendAscii( RTL_CONSTASCII_STRINGPARAM( "FOREIGN KEY( " ) );
1119 : : }
1120 : :
1121 : 0 : Reference< XColumnsSupplier > columns( key, UNO_QUERY );
1122 : 0 : if( columns.is() )
1123 : : {
1124 : 0 : Reference< XEnumerationAccess > colEnumAccess( columns->getColumns(), UNO_QUERY );
1125 : 0 : if( colEnumAccess.is() )
1126 : : {
1127 : 0 : Reference< XEnumeration > colEnum = colEnumAccess->createEnumeration();
1128 : 0 : bool first = true;
1129 : 0 : while(colEnum.is() && colEnum->hasMoreElements() )
1130 : : {
1131 : 0 : if( first )
1132 : : {
1133 : 0 : first = false;
1134 : : }
1135 : : else
1136 : : {
1137 : 0 : buf.appendAscii( RTL_CONSTASCII_STRINGPARAM( ", " ) );
1138 : : }
1139 : 0 : Reference< XPropertySet > keyColumn( colEnum->nextElement(), UNO_QUERY_THROW );
1140 : 0 : bufferQuoteIdentifier(buf, extractStringProperty( keyColumn, st.NAME ), settings );
1141 : 0 : }
1142 : 0 : }
1143 : : }
1144 : 0 : buf.appendAscii( RTL_CONSTASCII_STRINGPARAM( ") " ));
1145 : :
1146 : 0 : if( foreign )
1147 : : {
1148 : 0 : buf.appendAscii( RTL_CONSTASCII_STRINGPARAM( "REFERENCES " ) );
1149 : 0 : OUString schema;
1150 : 0 : OUString tableName;
1151 : 0 : splitConcatenatedIdentifier( referencedTable, &schema, &tableName );
1152 : 0 : bufferQuoteQualifiedIdentifier(buf , schema, tableName, settings );
1153 : 0 : if(columns.is() )
1154 : : {
1155 : 0 : Reference< XEnumerationAccess > colEnumAccess( columns->getColumns(), UNO_QUERY);
1156 : 0 : if( colEnumAccess.is() )
1157 : : {
1158 : 0 : buf.appendAscii( RTL_CONSTASCII_STRINGPARAM( " (" ) );
1159 : 0 : Reference< XEnumeration > colEnum(colEnumAccess->createEnumeration());
1160 : 0 : bool first = true;
1161 : 0 : while(colEnum.is() && colEnum->hasMoreElements() )
1162 : : {
1163 : 0 : if( first )
1164 : : {
1165 : 0 : first = false;
1166 : : }
1167 : : else
1168 : : {
1169 : 0 : buf.appendAscii( RTL_CONSTASCII_STRINGPARAM( ", " ) );
1170 : : }
1171 : 0 : Reference< XPropertySet > keyColumn( colEnum->nextElement(), UNO_QUERY_THROW );
1172 : : bufferQuoteIdentifier(
1173 : 0 : buf, extractStringProperty( keyColumn, st.RELATED_COLUMN ), settings );
1174 : 0 : }
1175 : 0 : buf.appendAscii( RTL_CONSTASCII_STRINGPARAM( ") " ) );
1176 : 0 : }
1177 : : }
1178 : :
1179 : 0 : buf.appendAscii( RTL_CONSTASCII_STRINGPARAM( "ON DELETE " ) );
1180 : 0 : keyType2String( buf, deleteRule );
1181 : 0 : buf.appendAscii( RTL_CONSTASCII_STRINGPARAM( " ON UPDATE " ) );
1182 : 0 : keyType2String( buf, updateRule );
1183 : 0 : }
1184 : :
1185 : 0 : }
1186 : :
1187 : 0 : static bool equalsIgnoreCase( const rtl::OString & str, const char *str2, int length2 )
1188 : : {
1189 : : return 0 == rtl_str_compareIgnoreAsciiCase_WithLength(
1190 : 0 : str.pData->buffer, str.pData->length, str2, length2 );
1191 : : }
1192 : :
1193 : 0 : void extractNameValuePairsFromInsert( String2StringMap & map, const rtl::OString & lastQuery )
1194 : : {
1195 : 0 : OStringVector vec;
1196 : 0 : tokenizeSQL( lastQuery, vec );
1197 : :
1198 : 0 : int nSize = vec.size();
1199 : : // printf( "1 %d\n", nSize );
1200 : 0 : if( nSize > 6 &&
1201 : 0 : equalsIgnoreCase( vec[0] , RTL_CONSTASCII_STRINGPARAM( "insert" ) ) &&
1202 : 0 : equalsIgnoreCase( vec[1] , RTL_CONSTASCII_STRINGPARAM( "into" ) ) )
1203 : : {
1204 : 0 : int n = 2;
1205 : :
1206 : : // printf( "1a\n" );
1207 : : // extract table name
1208 : 0 : rtl::OString tableName;
1209 : 0 : if( equalsIgnoreCase( vec[n+1], RTL_CONSTASCII_STRINGPARAM( "." ) ) )
1210 : : {
1211 : 0 : tableName = vec[n];
1212 : 0 : tableName += vec[n+1];
1213 : 0 : tableName += vec[n+2];
1214 : 0 : n +=2;
1215 : : }
1216 : : else
1217 : : {
1218 : 0 : tableName = vec[n];
1219 : : }
1220 : :
1221 : 0 : OStringVector names;
1222 : 0 : n ++;
1223 : 0 : if( equalsIgnoreCase( vec[n], RTL_CONSTASCII_STRINGPARAM( "(" ) ) )
1224 : : {
1225 : : // printf( "2\n" );
1226 : : // extract names
1227 : 0 : n++;
1228 : 0 : while( nSize > n && ! equalsIgnoreCase(vec[n] , RTL_CONSTASCII_STRINGPARAM( ")" ) ) )
1229 : : {
1230 : 0 : names.push_back( vec[n] );
1231 : 0 : if( nSize > n+1 && equalsIgnoreCase( vec[n+1] , RTL_CONSTASCII_STRINGPARAM( "," ) ) )
1232 : : {
1233 : 0 : n ++;
1234 : : }
1235 : 0 : n++;
1236 : : }
1237 : 0 : n++;
1238 : :
1239 : : // now read the values
1240 : 0 : if( nSize > n +1 && equalsIgnoreCase( vec[n], RTL_CONSTASCII_STRINGPARAM("VALUES") ) &&
1241 : 0 : equalsIgnoreCase(vec[n+1], RTL_CONSTASCII_STRINGPARAM( "(" ) ) )
1242 : : {
1243 : 0 : n +=2;
1244 : : // printf( "3\n" );
1245 : 0 : for ( OStringVector::size_type i = 0 ; i < names.size() && nSize > n ; i ++ )
1246 : : {
1247 : 0 : map[names[i]] = vec[n];
1248 : 0 : if( nSize > n+1 && equalsIgnoreCase( vec[n+1] , RTL_CONSTASCII_STRINGPARAM(",") ) )
1249 : : {
1250 : 0 : n ++;
1251 : : }
1252 : 0 : n++;
1253 : : }
1254 : : }
1255 : 0 : }
1256 : 0 : }
1257 : 0 : }
1258 : :
1259 : 0 : rtl::OUString querySingleValue(
1260 : : const com::sun::star::uno::Reference< com::sun::star::sdbc::XConnection > &connection,
1261 : : const rtl::OUString &query )
1262 : : {
1263 : 0 : OUString ret;
1264 : 0 : Reference< XStatement > stmt = connection->createStatement();
1265 : 0 : DisposeGuard guard( stmt );
1266 : 0 : Reference< XResultSet > rs = stmt->executeQuery( query );
1267 : 0 : Reference< XRow > xRow( rs, UNO_QUERY );
1268 : 0 : if( rs->next() )
1269 : 0 : ret = xRow->getString( 1 );
1270 : 0 : return ret;
1271 : : }
1272 : :
1273 : :
1274 : : // copied from connectivity/source/dbtools, can't use the function directly
1275 : 0 : bool implSetObject( const Reference< XParameters >& _rxParameters,
1276 : : const sal_Int32 _nColumnIndex, const Any& _rValue)
1277 : : {
1278 : 0 : sal_Bool bSuccessfullyReRouted = sal_True;
1279 : 0 : switch (_rValue.getValueTypeClass())
1280 : : {
1281 : : case typelib_TypeClass_HYPER:
1282 : : {
1283 : 0 : sal_Int64 nValue = 0;
1284 : 0 : _rxParameters->setLong( _nColumnIndex, nValue );
1285 : : }
1286 : 0 : break;
1287 : :
1288 : : case typelib_TypeClass_VOID:
1289 : 0 : _rxParameters->setNull(_nColumnIndex,com::sun::star::sdbc::DataType::VARCHAR);
1290 : 0 : break;
1291 : :
1292 : : case typelib_TypeClass_STRING:
1293 : 0 : _rxParameters->setString(_nColumnIndex, *(rtl::OUString*)_rValue.getValue());
1294 : 0 : break;
1295 : :
1296 : : case typelib_TypeClass_BOOLEAN:
1297 : 0 : _rxParameters->setBoolean(_nColumnIndex, *(sal_Bool *)_rValue.getValue());
1298 : 0 : break;
1299 : :
1300 : : case typelib_TypeClass_BYTE:
1301 : 0 : _rxParameters->setByte(_nColumnIndex, *(sal_Int8 *)_rValue.getValue());
1302 : 0 : break;
1303 : :
1304 : : case typelib_TypeClass_UNSIGNED_SHORT:
1305 : : case typelib_TypeClass_SHORT:
1306 : 0 : _rxParameters->setShort(_nColumnIndex, *(sal_Int16*)_rValue.getValue());
1307 : 0 : break;
1308 : :
1309 : : case typelib_TypeClass_CHAR:
1310 : 0 : _rxParameters->setString(_nColumnIndex, ::rtl::OUString((sal_Unicode *)_rValue.getValue(),1));
1311 : 0 : break;
1312 : :
1313 : : case typelib_TypeClass_UNSIGNED_LONG:
1314 : : case typelib_TypeClass_LONG:
1315 : 0 : _rxParameters->setInt(_nColumnIndex, *(sal_Int32*)_rValue.getValue());
1316 : 0 : break;
1317 : :
1318 : : case typelib_TypeClass_FLOAT:
1319 : 0 : _rxParameters->setFloat(_nColumnIndex, *(float*)_rValue.getValue());
1320 : 0 : break;
1321 : :
1322 : : case typelib_TypeClass_DOUBLE:
1323 : 0 : _rxParameters->setDouble(_nColumnIndex, *(double*)_rValue.getValue());
1324 : 0 : break;
1325 : :
1326 : : case typelib_TypeClass_SEQUENCE:
1327 : 0 : if (_rValue.getValueType() == ::getCppuType((const Sequence< sal_Int8 > *)0))
1328 : : {
1329 : 0 : _rxParameters->setBytes(_nColumnIndex, *(Sequence<sal_Int8>*)_rValue.getValue());
1330 : : }
1331 : : else
1332 : 0 : bSuccessfullyReRouted = sal_False;
1333 : 0 : break;
1334 : : case typelib_TypeClass_STRUCT:
1335 : 0 : if (_rValue.getValueType() == ::getCppuType((const com::sun::star::util::DateTime*)0))
1336 : 0 : _rxParameters->setTimestamp(_nColumnIndex, *(com::sun::star::util::DateTime*)_rValue.getValue());
1337 : 0 : else if (_rValue.getValueType() == ::getCppuType((const com::sun::star::util::Date*)0))
1338 : 0 : _rxParameters->setDate(_nColumnIndex, *(com::sun::star::util::Date*)_rValue.getValue());
1339 : 0 : else if (_rValue.getValueType() == ::getCppuType((const com::sun::star::util::Time*)0))
1340 : 0 : _rxParameters->setTime(_nColumnIndex, *(com::sun::star::util::Time*)_rValue.getValue());
1341 : : else
1342 : 0 : bSuccessfullyReRouted = sal_False;
1343 : 0 : break;
1344 : :
1345 : : case typelib_TypeClass_INTERFACE:
1346 : : {
1347 : 0 : Reference< com::sun::star::io::XInputStream > xStream;
1348 : 0 : if (_rValue >>= xStream)
1349 : : {
1350 : 0 : _rValue >>= xStream;
1351 : 0 : _rxParameters->setBinaryStream(_nColumnIndex, xStream, xStream->available());
1352 : : break;
1353 : 0 : }
1354 : : }
1355 : : // run through
1356 : : default:
1357 : 0 : bSuccessfullyReRouted = sal_False;
1358 : :
1359 : : }
1360 : :
1361 : 0 : return bSuccessfullyReRouted;
1362 : : }
1363 : :
1364 : : }
|
