Debian Codegraph @

ogr/ogrsf_frmts/hana/ogrhanadatasource.cpp

raw
1 /******************************************************************************
2 *
3 * Project: SAP HANA Spatial Driver
4 * Purpose: OGRHanaDataSource class implementation
5 * Author: Maxim Rylov
6 *
7 ******************************************************************************
8 * Copyright (c) 2020, SAP SE
9 *
10 * SPDX-License-Identifier: MIT
11 ****************************************************************************/
12
13 #include "ogr_hana.h"
14 #include "ogrhanautils.h"
15 #include "ogrhanadrivercore.h"
16
17 #include "odbc/Connection.h"
18 #include "odbc/Environment.h"
19 #include "odbc/Exception.h"
20 #include "odbc/DatabaseMetaData.h"
21 #include "odbc/PreparedStatement.h"
22 #include "odbc/ResultSet.h"
23 #include "odbc/ResultSetMetaData.h"
24 #include "odbc/Statement.h"
25 #include "odbc/StringConverter.h"
26
27 #include <algorithm>
28 #include <iterator>
29 #include <memory>
30 #include <sstream>
31 #include <vector>
32
33 using namespace OGRHANA;
34
35 namespace
36 {
37
38 CPLString BuildConnectionString(char **openOptions)
39 {
40 // See notes for constructing connection string for HANA
41 // https://help.sap.com/docs/SAP_HANA_CLIENT/f1b440ded6144a54ada97ff95dac7adf/7cab593774474f2f8db335710b2f5c50.html
42
43 std::vector<CPLString> params;
44 bool isValid = true;
45 const CPLString specialChars("[]{}(),;?*=!@");
46
47 auto getOptValue = [&](const char *optionName, bool mandatory = false)
48 {
49 const char *paramValue =
50 CSLFetchNameValueDef(openOptions, optionName, nullptr);
51 if (mandatory && paramValue == nullptr)
52 {
53 isValid = false;
54 CPLError(CE_Failure, CPLE_AppDefined,
55 "Mandatory connection parameter '%s' is missing.",
56 optionName);
57 }
58 return paramValue;
59 };
60
61 auto addParameter = [&](const char *paramName, const char *paramValue)
62 {
63 if (paramValue == nullptr)
64 return;
65
66 CPLString value(paramValue);
67 if (value.find_first_of(specialChars) != std::string::npos)
68 {
69 value.replaceAll("}", "}}");
70 params.push_back(CPLString(paramName) + "={" + value + "}");
71 }
72 else
73 {
74 params.push_back(CPLString(paramName) + "=" + value);
75 }
76 };
77
78 auto addOptParameter = [&](const char *optionName, const char *paramName,
79 bool mandatory = false)
80 {
81 const char *paramValue = getOptValue(optionName, mandatory);
82 addParameter(paramName, paramValue);
83 };
84
85 auto checkIgnoredOptParameter = [&](const char *optionName)
86 {
87 if (getOptValue(optionName))
88 CPLError(CE_Failure, CPLE_AppDefined,
89 "Connection parameter '%s' is ignored in the current "
90 "combination.",
91 optionName);
92 };
93
94 if (const char *paramUserStoreKey =
95 getOptValue(OGRHanaOpenOptionsConstants::USER_STORE_KEY))
96 {
97 addOptParameter(OGRHanaOpenOptionsConstants::DRIVER, "DRIVER", true);
98 CPLString node = CPLString().Printf("@%s", paramUserStoreKey);
99 addParameter("SERVERNODE", node.c_str());
100
101 checkIgnoredOptParameter(OGRHanaOpenOptionsConstants::DSN);
102 checkIgnoredOptParameter(OGRHanaOpenOptionsConstants::HOST);
103 checkIgnoredOptParameter(OGRHanaOpenOptionsConstants::PORT);
104 checkIgnoredOptParameter(OGRHanaOpenOptionsConstants::DATABASE);
105 checkIgnoredOptParameter(OGRHanaOpenOptionsConstants::USER);
106 checkIgnoredOptParameter(OGRHanaOpenOptionsConstants::PASSWORD);
107 }
108 else if (const char *paramDSN =
109 getOptValue(OGRHanaOpenOptionsConstants::DSN))
110 {
111 addParameter(OGRHanaOpenOptionsConstants::DSN, paramDSN);
112 addOptParameter(OGRHanaOpenOptionsConstants::USER, "UID", true);
113 addOptParameter(OGRHanaOpenOptionsConstants::PASSWORD, "PWD", true);
114
115 checkIgnoredOptParameter(OGRHanaOpenOptionsConstants::DRIVER);
116 checkIgnoredOptParameter(OGRHanaOpenOptionsConstants::HOST);
117 checkIgnoredOptParameter(OGRHanaOpenOptionsConstants::PORT);
118 checkIgnoredOptParameter(OGRHanaOpenOptionsConstants::DATABASE);
119 }
120 else
121 {
122 addOptParameter(OGRHanaOpenOptionsConstants::DRIVER, "DRIVER", true);
123 const char *paramHost =
124 getOptValue(OGRHanaOpenOptionsConstants::HOST, true);
125 const char *paramPort =
126 getOptValue(OGRHanaOpenOptionsConstants::PORT, true);
127 if (paramHost != nullptr && paramPort != nullptr)
128 {
129 CPLString node = CPLString().Printf("%s:%s", paramHost, paramPort);
130 addParameter("SERVERNODE", node.c_str());
131 }
132 addOptParameter(OGRHanaOpenOptionsConstants::USER, "UID", true);
133 addOptParameter(OGRHanaOpenOptionsConstants::PASSWORD, "PWD", true);
134 addOptParameter(OGRHanaOpenOptionsConstants::DATABASE, "DATABASENAME");
135 }
136
137 if (const char *paramSchema =
138 getOptValue(OGRHanaOpenOptionsConstants::SCHEMA, true))
139 {
140 CPLString schema = CPLString().Printf("\"%s\"", paramSchema);
141 addParameter("CURRENTSCHEMA", schema.c_str());
142 }
143
144 if (CPLFetchBool(openOptions, OGRHanaOpenOptionsConstants::ENCRYPT, false))
145 {
146 addOptParameter(OGRHanaOpenOptionsConstants::ENCRYPT, "ENCRYPT");
147 addOptParameter(OGRHanaOpenOptionsConstants::SSL_CRYPTO_PROVIDER,
148 "sslCryptoProvider");
149 addOptParameter(OGRHanaOpenOptionsConstants::SSL_KEY_STORE,
150 "sslKeyStore");
151 addOptParameter(OGRHanaOpenOptionsConstants::SSL_TRUST_STORE,
152 "sslTrustStore");
153 addOptParameter(OGRHanaOpenOptionsConstants::SSL_VALIDATE_CERTIFICATE,
154 "sslValidateCertificate");
155 addOptParameter(OGRHanaOpenOptionsConstants::SSL_HOST_NAME_CERTIFICATE,
156 "sslHostNameInCertificate");
157 }
158
159 addOptParameter(OGRHanaOpenOptionsConstants::PACKET_SIZE, "PACKETSIZE");
160 addOptParameter(OGRHanaOpenOptionsConstants::SPLIT_BATCH_COMMANDS,
161 "SPLITBATCHCOMMANDS");
162 addParameter("CHAR_AS_UTF8", "1");
163
164 CPLString appName;
165 appName.Printf("GDAL %s", GDALVersionInfo("RELEASE_NAME"));
166 addParameter("sessionVariable:APPLICATION", appName.c_str());
167
168 return isValid ? JoinStrings(params, ";") : "";
169 }
170
171 int CPLFetchInt(CSLConstList papszStrList, const char *pszKey, int defaultValue)
172 {
173 const char *const pszValue = CSLFetchNameValue(papszStrList, pszKey);
174 if (pszValue == nullptr)
175 return defaultValue;
176 return atoi(pszValue);
177 }
178
179 int GetSrid(odbc::ResultSet &resultSet)
180 {
181 int srid = UNDETERMINED_SRID;
182 while (resultSet.next())
183 {
184 odbc::Int val = resultSet.getInt(1);
185 if (!val.isNull())
186 {
187 srid = *val;
188 break;
189 }
190 }
191 resultSet.close();
192 return srid;
193 }
194
195 int GetColumnSrid(odbc::Connection &conn, const CPLString &schemaName,
196 const CPLString &tableName, const CPLString &columnName)
197 {
198 CPLString sql =
199 "SELECT SRS_ID FROM SYS.ST_GEOMETRY_COLUMNS WHERE SCHEMA_NAME = ?"
200 " AND TABLE_NAME = ? AND COLUMN_NAME = ?";
201 odbc::PreparedStatementRef stmt = conn.prepareStatement(sql.c_str());
202 stmt->setString(1, odbc::String(schemaName));
203 stmt->setString(2, odbc::String(tableName));
204 if (columnName != nullptr)
205 stmt->setString(3, odbc::String(columnName));
206 return GetSrid(*stmt->executeQuery());
207 }
208
209 int GetColumnSrid(odbc::Connection &conn, const CPLString &query,
210 const CPLString &columnName)
211 {
212 CPLString clmName = QuotedIdentifier(columnName);
213
214 CPLString sql =
215 CPLString().Printf("SELECT %s.ST_SRID() FROM (%s) WHERE %s IS NOT NULL",
216 clmName.c_str(), query.c_str(), clmName.c_str());
217
218 odbc::StatementRef stmt = conn.createStatement();
219 return GetSrid(*stmt->executeQuery(sql.c_str()));
220 }
221
222 int GetSridWithFilter(odbc::Connection &conn, const CPLString &whereCondition)
223 {
224 CPLAssert(whereCondition != nullptr);
225
226 int ret = UNDETERMINED_SRID;
227
228 odbc::StatementRef stmt = conn.createStatement();
229 CPLString sql = CPLString().Printf(
230 "SELECT SRS_ID FROM SYS.ST_SPATIAL_REFERENCE_SYSTEMS WHERE %s",
231 whereCondition.c_str());
232 odbc::ResultSetRef rsSrs = stmt->executeQuery(sql.c_str());
233 while (rsSrs->next())
234 {
235 odbc::Int val = rsSrs->getInt(1);
236 if (!val.isNull())
237 {
238 ret = *val;
239 break;
240 }
241 }
242 rsSrs->close();
243
244 return ret;
245 }
246
247 CPLString GetSrsWktById(odbc::Connection &conn, int srid)
248 {
249 CPLString ret;
250 const char *sql = "SELECT DEFINITION FROM "
251 "SYS.ST_SPATIAL_REFERENCE_SYSTEMS WHERE SRS_ID = ?";
252 odbc::PreparedStatementRef stmt = conn.prepareStatement(sql);
253 stmt->setInt(1, odbc::Int(srid));
254 odbc::ResultSetRef rs = stmt->executeQuery();
255 while (rs->next())
256 {
257 odbc::String wkt = rs->getString(1);
258 if (!wkt.isNull())
259 {
260 ret = *wkt;
261 if (!ret.empty())
262 break;
263 }
264 }
265 rs->close();
266
267 return ret;
268 }
269
270 OGRwkbGeometryType GetGeometryType(odbc::Connection &conn,
271 const CPLString &query,
272 const CPLString &columnName)
273 {
274 CPLString clmName = QuotedIdentifier(columnName);
275
276 CPLString sql = CPLString().Printf(
277 "SELECT DISTINCT UPPER(%s.ST_GeometryType()), %s.ST_Is3D(), "
278 "%s.ST_IsMeasured() FROM %s WHERE %s IS NOT NULL",
279 clmName.c_str(), clmName.c_str(), clmName.c_str(), query.c_str(),
280 clmName.c_str());
281
282 odbc::StatementRef stmt = conn.createStatement();
283 odbc::ResultSetRef rsGeomInfo = stmt->executeQuery(sql.c_str());
284 OGRwkbGeometryType ret = wkbUnknown;
285 std::size_t i = 0;
286 while (rsGeomInfo->next())
287 {
288 ++i;
289 auto typeName = rsGeomInfo->getString(1);
290 auto hasZ = rsGeomInfo->getInt(2);
291 auto hasM = rsGeomInfo->getInt(3);
292 OGRwkbGeometryType geomType =
293 ToWkbType(typeName->c_str(), *hasZ == 1, *hasM == 1);
294 if (geomType == OGRwkbGeometryType::wkbUnknown)
295 continue;
296 if (ret == OGRwkbGeometryType::wkbUnknown)
297 ret = geomType;
298 else if (ret != geomType)
299 {
300 ret = OGRwkbGeometryType::wkbUnknown;
301 break;
302 }
303 }
304 rsGeomInfo->close();
305
306 if (i == 0)
307 ret = OGRwkbGeometryType::wkbUnknown;
308 return ret;
309 }
310
311 GeometryColumnDescription GetGeometryColumnDescription(
312 odbc::Connection &conn, const CPLString &schemaName,
313 const CPLString &tableName, const CPLString &columnName,
314 bool detectGeometryType)
315 {
316 OGRwkbGeometryType type =
317 detectGeometryType
318 ? GetGeometryType(conn,
319 GetFullTableNameQuoted(schemaName, tableName),
320 columnName)
321 : OGRwkbGeometryType::wkbUnknown;
322 int srid = GetColumnSrid(conn, schemaName, tableName, columnName);
323
324 return {columnName, type, srid, false};
325 }
326
327 GeometryColumnDescription
328 GetGeometryColumnDescription(odbc::Connection &conn, const CPLString &query,
329 const CPLString &columnName,
330 bool detectGeometryType)
331 {
332 // For some queries like this SELECT ST_GeomFROMWKT('POINT(0 0)') FROM DUMMY
333 // we need to have a proper column name.
334 bool needColumnName = false;
335 std::vector<char> specialChars = {'(', ')', '\'', ' '};
336 for (const char c : specialChars)
337 {
338 if (columnName.find(c) != CPLString::npos)
339 {
340 needColumnName = true;
341 break;
342 }
343 }
344
345 CPLString preparedQuery = query;
346 CPLString clmName = columnName;
347 if (needColumnName)
348 {
349 auto it = std::search(
350 preparedQuery.begin(), preparedQuery.end(), columnName.begin(),
351 columnName.end(),
352 [](char ch1, char ch2)
353 {
354 return CPLToupper(static_cast<unsigned char>(ch1)) ==
355 CPLToupper(static_cast<unsigned char>(ch2));
356 });
357
358 if (it != preparedQuery.end())
359 {
360 auto pos = it - preparedQuery.begin();
361 CPLString newName = columnName + " AS \"tmp_geom_field\"";
362 preparedQuery.replace(static_cast<std::size_t>(pos),
363 columnName.length(), newName, 0,
364 newName.length());
365 clmName = "tmp_geom_field";
366 }
367 }
368
369 OGRwkbGeometryType type =
370 detectGeometryType
371 ? GetGeometryType(conn, "(" + preparedQuery + ")", clmName)
372 : OGRwkbGeometryType::wkbUnknown;
373 int srid = GetColumnSrid(conn, preparedQuery, clmName);
374
375 return {columnName, type, srid, false};
376 }
377
378 CPLString FormatDefaultValue(const char *value, short dataType)
379 {
380 /*
381 The values that can be set as default values are :
382 - literal string values enclosed in single-quote characters and properly
383 escaped like: 'Nice weather. Isn''t it ?'
384 - numeric values (unquoted)
385 - reserved keywords (unquoted): CURRENT_TIMESTAMP, CURRENT_DATE,
386 CURRENT_TIME, NULL
387 - datetime literal values enclosed in single-quote characters with the
388 following defined format: ‘YYYY/MM/DD HH:MM:SS[.sss]’
389 - any other driver specific expression. e.g. for SQLite:
390 (strftime(‘%Y-%m-%dT%H:%M:%fZ’,’now’))
391 */
392
393 if (EQUAL(value, "NULL"))
394 return value;
395
396 switch (dataType)
397 {
398 case QGRHanaDataTypes::Bit:
399 case QGRHanaDataTypes::Boolean:
400 return value;
401 case QGRHanaDataTypes::TinyInt:
402 case QGRHanaDataTypes::SmallInt:
403 case QGRHanaDataTypes::Integer:
404 case QGRHanaDataTypes::BigInt:
405 case QGRHanaDataTypes::Real:
406 case QGRHanaDataTypes::Float:
407 case QGRHanaDataTypes::Double:
408 case QGRHanaDataTypes::Decimal:
409 case QGRHanaDataTypes::Numeric:
410 return value;
411 case QGRHanaDataTypes::Char:
412 case QGRHanaDataTypes::VarChar:
413 case QGRHanaDataTypes::LongVarChar:
414 case QGRHanaDataTypes::WChar:
415 case QGRHanaDataTypes::WVarChar:
416 case QGRHanaDataTypes::WLongVarChar:
417 return Literal(value);
418 case QGRHanaDataTypes::Binary:
419 case QGRHanaDataTypes::VarBinary:
420 case QGRHanaDataTypes::LongVarBinary:
421 case QGRHanaDataTypes::RealVector:
422 return value;
423 case QGRHanaDataTypes::Date:
424 case QGRHanaDataTypes::TypeDate:
425 if (EQUAL(value, "CURRENT_DATE"))
426 return value;
427 return Literal(value);
428 case QGRHanaDataTypes::Time:
429 case QGRHanaDataTypes::TypeTime:
430 if (EQUAL(value, "CURRENT_TIME"))
431 return value;
432 return Literal(value);
433 case QGRHanaDataTypes::Timestamp:
434 case QGRHanaDataTypes::TypeTimestamp:
435 if (EQUAL(value, "CURRENT_TIMESTAMP"))
436 return value;
437 return Literal(value);
438 default:
439 return value;
440 }
441 }
442
443 short GetArrayDataType(const CPLString &typeName)
444 {
445 if (typeName == "BOOLEAN ARRAY")
446 return QGRHanaDataTypes::Boolean;
447 else if (typeName == "TINYINT ARRAY")
448 return QGRHanaDataTypes::TinyInt;
449 else if (typeName == "SMALLINT ARRAY")
450 return QGRHanaDataTypes::SmallInt;
451 else if (typeName == "INTEGER ARRAY")
452 return QGRHanaDataTypes::Integer;
453 else if (typeName == "BIGINT ARRAY")
454 return QGRHanaDataTypes::BigInt;
455 else if (typeName == "DOUBLE ARRAY")
456 return QGRHanaDataTypes::Double;
457 else if (typeName == "REAL ARRAY")
458 return QGRHanaDataTypes::Float;
459 else if (typeName == "DECIMAL ARRAY" || typeName == "SMALLDECIMAL ARRAY")
460 return QGRHanaDataTypes::Decimal;
461 else if (typeName == "CHAR ARRAY")
462 return QGRHanaDataTypes::Char;
463 else if (typeName == "VARCHAR ARRAY")
464 return QGRHanaDataTypes::VarChar;
465 else if (typeName == "NCHAR ARRAY")
466 return QGRHanaDataTypes::WChar;
467 else if (typeName == "NVARCHAR ARRAY")
468 return QGRHanaDataTypes::WVarChar;
469 else if (typeName == "DATE ARRAY")
470 return QGRHanaDataTypes::Date;
471 else if (typeName == "TIME ARRAY")
472 return QGRHanaDataTypes::Time;
473 else if (typeName == "TIMESTAMP ARRAY" || typeName == "SECONDDATE ARRAY")
474 return QGRHanaDataTypes::Timestamp;
475
476 return QGRHanaDataTypes::Unknown;
477 }
478
479 std::vector<CPLString> GetSupportedArrayTypes()
480 {
481 return {"TINYINT", "SMALLINT", "INT", "BIGINT", "REAL", "DOUBLE", "STRING"};
482 }
483
484 bool IsKnownDataType(short dataType)
485 {
486 return dataType == QGRHanaDataTypes::Bit ||
487 dataType == QGRHanaDataTypes::Boolean ||
488 dataType == QGRHanaDataTypes::TinyInt ||
489 dataType == QGRHanaDataTypes::SmallInt ||
490 dataType == QGRHanaDataTypes::Integer ||
491 dataType == QGRHanaDataTypes::BigInt ||
492 dataType == QGRHanaDataTypes::Double ||
493 dataType == QGRHanaDataTypes::Real ||
494 dataType == QGRHanaDataTypes::Float ||
495 dataType == QGRHanaDataTypes::Decimal ||
496 dataType == QGRHanaDataTypes::Numeric ||
497 dataType == QGRHanaDataTypes::Char ||
498 dataType == QGRHanaDataTypes::VarChar ||
499 dataType == QGRHanaDataTypes::LongVarChar ||
500 dataType == QGRHanaDataTypes::WChar ||
501 dataType == QGRHanaDataTypes::WVarChar ||
502 dataType == QGRHanaDataTypes::WLongVarChar ||
503 dataType == QGRHanaDataTypes::Date ||
504 dataType == QGRHanaDataTypes::TypeDate ||
505 dataType == QGRHanaDataTypes::Time ||
506 dataType == QGRHanaDataTypes::TypeTime ||
507 dataType == QGRHanaDataTypes::Timestamp ||
508 dataType == QGRHanaDataTypes::TypeTimestamp ||
509 dataType == QGRHanaDataTypes::Binary ||
510 dataType == QGRHanaDataTypes::VarBinary ||
511 dataType == QGRHanaDataTypes::LongVarBinary ||
512 dataType == QGRHanaDataTypes::Geometry ||
513 dataType == QGRHanaDataTypes::RealVector;
514 }
515
516 } // anonymous namespace
517
518 /************************************************************************/
519 /* GetPrefix() */
520 /************************************************************************/
521
522 const char *OGRHanaDataSource::GetPrefix()
523 {
524 return HANA_PREFIX;
525 }
526
527 /************************************************************************/
528 /* OGRHanaDataSource() */
529 /************************************************************************/
530
531 OGRHanaDataSource::OGRHanaDataSource()
532 {
533 }
534
535 /************************************************************************/
536 /* ~OGRHanaDataSource() */
537 /************************************************************************/
538
539 OGRHanaDataSource::~OGRHanaDataSource()
540 {
541 layers_.clear();
542
543 for (const auto &kv : srsCache_)
544 {
545 OGRSpatialReference *srs = kv.second;
546 if (srs != nullptr)
547 srs->Release();
548 }
549 srsCache_.clear();
550 }
551
552 /************************************************************************/
553 /* Open() */
554 /************************************************************************/
555
556 int OGRHanaDataSource::Open(const char *newName, CSLConstList openOptions,
557 int update)
558 {
559 CPLAssert(layers_.size() == 0);
560
561 if (!STARTS_WITH_CI(newName, GetPrefix()))
562 {
563 CPLError(CE_Failure, CPLE_AppDefined,
564 "%s does not conform to HANA driver naming convention,"
565 " %s*\n",
566 newName, GetPrefix());
567 return FALSE;
568 }
569
570 updateMode_ = update;
571 detectGeometryType_ = CPLFetchBool(
572 openOptions, OGRHanaOpenOptionsConstants::DETECT_GEOMETRY_TYPE, true);
573
574 std::size_t prefixLength = strlen(GetPrefix());
575 char **connOptions =
576 CSLTokenizeStringComplex(newName + prefixLength, ";", TRUE, FALSE);
577
578 const char *paramSchema = CSLFetchNameValueDef(
579 connOptions, OGRHanaOpenOptionsConstants::SCHEMA, nullptr);
580 if (paramSchema != nullptr)
581 schemaName_ = paramSchema;
582
583 int ret = FALSE;
584
585 CPLString connectionStr = BuildConnectionString(connOptions);
586
587 if (!connectionStr.empty())
588 {
589 connEnv_ = odbc::Environment::create();
590 conn_ = connEnv_->createConnection();
591 conn_->setAutoCommit(false);
592
593 const char *paramConnTimeout = CSLFetchNameValueDef(
594 connOptions, OGRHanaOpenOptionsConstants::CONNECTION_TIMEOUT,
595 nullptr);
596 if (paramConnTimeout != nullptr)
597 conn_->setConnectionTimeout(
598 static_cast<unsigned long>(atoi(paramConnTimeout)));
599
600 try
601 {
602 conn_->connect(connectionStr.c_str());
603 }
604 catch (const odbc::Exception &ex)
605 {
606 CPLError(CE_Failure, CPLE_AppDefined,
607 "HANA connection failed: %s\n", ex.what());
608 }
609
610 if (conn_->connected())
611 {
612 DetermineVersions();
613
614 const char *paramTables = CSLFetchNameValueDef(
615 connOptions, OGRHanaOpenOptionsConstants::TABLES, "");
616 InitializeLayers(paramSchema, paramTables);
617 ret = TRUE;
618 }
619 }
620
621 CSLDestroy(connOptions);
622
623 return ret;
624 }
625
626 /************************************************************************/
627 /* DeleteLayer() */
628 /************************************************************************/
629
630 OGRErr OGRHanaDataSource::DeleteLayer(int index)
631 {
632 if (index < 0 || static_cast<std::size_t>(index) >= layers_.size())
633 return OGRERR_FAILURE;
634
635 const std::unique_ptr<OGRLayer> &layer =
636 layers_[static_cast<std::size_t>(index)];
637 CPLDebug("HANA", "DeleteLayer(%s)", layer->GetName());
638
639 if (auto tableLayer = dynamic_cast<OGRHanaTableLayer *>(layer.get()))
640 {
641 OGRErr err = tableLayer->DropTable();
642 if (OGRERR_NONE == err)
643 return err;
644 }
645
646 layers_.erase(layers_.begin() + index);
647
648 return OGRERR_NONE;
649 }
650
651 void OGRHanaDataSource::CreateTable(
652 const CPLString &tableName, const CPLString &fidName,
653 const CPLString &fidType, const CPLString &geomColumnName,
654 OGRwkbGeometryType geomType, bool geomColumnNullable,
655 const CPLString &geomColumnIndexType, int geomSrid)
656 {
657 CPLString sql;
658 if (geomType == OGRwkbGeometryType::wkbNone ||
659 !(!geomColumnName.empty() && geomSrid >= 0))
660 {
661 sql = "CREATE COLUMN TABLE " +
662 GetFullTableNameQuoted(schemaName_, tableName) + " (" +
663 QuotedIdentifier(fidName) + " " + fidType +
664 " GENERATED BY DEFAULT AS IDENTITY, PRIMARY KEY ( " +
665 QuotedIdentifier(fidName) + "));";
666 }
667 else
668 {
669 sql = "CREATE COLUMN TABLE " +
670 GetFullTableNameQuoted(schemaName_, tableName) + " (" +
671 QuotedIdentifier(fidName) + " " + fidType +
672 " GENERATED BY DEFAULT AS IDENTITY, " +
673 QuotedIdentifier(geomColumnName) + " ST_GEOMETRY (" +
674 std::to_string(geomSrid) + ")" +
675 (geomColumnNullable ? "" : " NOT NULL") +
676 " SPATIAL INDEX PREFERENCE " + geomColumnIndexType +
677 ", PRIMARY KEY ( " + QuotedIdentifier(fidName) + "));";
678 }
679
680 ExecuteSQL(sql);
681 }
682
683 void OGRHanaDataSource::DetermineVersions()
684 {
685 odbc::DatabaseMetaDataRef dbmd = conn_->getDatabaseMetaData();
686 CPLString dbVersion(dbmd->getDBMSVersion());
687 hanaVersion_ = HanaVersion::fromString(dbVersion);
688
689 if (hanaVersion_.major() < 4)
690 {
691 cloudVersion_ = HanaVersion(0, 0, 0);
692 return;
693 }
694
695 odbc::StatementRef stmt = conn_->createStatement();
696 const char *sql = "SELECT CLOUD_VERSION FROM SYS.M_DATABASE;";
697
698 odbc::ResultSetRef rsVersion = stmt->executeQuery(sql);
699 if (rsVersion->next())
700 cloudVersion_ =
701 HanaVersion::fromString(rsVersion->getString(1)->c_str());
702
703 rsVersion->close();
704 }
705
706 /************************************************************************/
707 /* FindSchemaAndTableNames() */
708 /************************************************************************/
709
710 std::pair<CPLString, CPLString>
711 OGRHanaDataSource::FindSchemaAndTableNames(const char *query)
712 {
713 odbc::PreparedStatementRef stmt = PrepareStatement(query);
714 if (stmt.get() == nullptr)
715 return {"", ""};
716
717 odbc::ResultSetMetaDataRef rsmd = stmt->getMetaData();
718
719 // Note, getTableName returns correct table name also in the case
720 // when the original sql query uses a view
721 CPLString tableName = rsmd->getTableName(1);
722 if (tableName == "M_DATABASE_")
723 tableName = "M_DATABASE";
724 CPLString schemaName = rsmd->getSchemaName(1);
725 if (schemaName.empty() && !tableName.empty())
726 schemaName = FindSchemaName(tableName.c_str());
727 return {schemaName, tableName};
728 }
729
730 /************************************************************************/
731 /* FindLayerByName() */
732 /************************************************************************/
733
734 int OGRHanaDataSource::FindLayerByName(const char *name)
735 {
736 for (size_t i = 0; i < layers_.size(); ++i)
737 {
738 if (EQUAL(name, layers_[i]->GetName()))
739 return static_cast<int>(i);
740 }
741 return -1;
742 }
743
744 /************************************************************************/
745 /* FindSchemaName() */
746 /************************************************************************/
747
748 CPLString OGRHanaDataSource::FindSchemaName(const char *objectName)
749 {
750 auto getSchemaName = [&](const char *sql)
751 {
752 odbc::PreparedStatementRef stmt = PrepareStatement(sql);
753 stmt->setString(1, odbc::String(objectName));
754 odbc::ResultSetRef rsEntries = stmt->executeQuery();
755 CPLString ret;
756 while (rsEntries->next())
757 {
758 // return empty string if there is more than one schema.
759 if (!ret.empty())
760 {
761 ret.clear();
762 break;
763 }
764 ret = *rsEntries->getString(1);
765 }
766 rsEntries->close();
767
768 return ret;
769 };
770
771 CPLString ret = getSchemaName(
772 "SELECT SCHEMA_NAME FROM SYS.TABLES WHERE TABLE_NAME = ?");
773 if (ret.empty())
774 ret = getSchemaName(
775 "SELECT SCHEMA_NAME FROM SYS.VIEWS WHERE VIEW_NAME = ?");
776
777 return ret;
778 }
779
780 /************************************************************************/
781 /* CreateStatement() */
782 /************************************************************************/
783
784 odbc::StatementRef OGRHanaDataSource::CreateStatement()
785 {
786 return conn_->createStatement();
787 }
788
789 /************************************************************************/
790 /* PrepareStatement() */
791 /************************************************************************/
792
793 odbc::PreparedStatementRef OGRHanaDataSource::PrepareStatement(const char *sql)
794 {
795 CPLAssert(sql != nullptr);
796
797 try
798 {
799 CPLDebug("HANA", "Prepare statement %s.", sql);
800
801 std::u16string sqlUtf16 = odbc::StringConverter::utf8ToUtf16(sql);
802 return conn_->prepareStatement(sqlUtf16.c_str());
803 }
804 catch (const odbc::Exception &ex)
805 {
806 CPLError(CE_Failure, CPLE_AppDefined, "Failed to prepare statement: %s",
807 ex.what());
808 }
809 return nullptr;
810 }
811
812 /************************************************************************/
813 /* Commit() */
814 /************************************************************************/
815
816 void OGRHanaDataSource::Commit()
817 {
818 conn_->commit();
819 }
820
821 /************************************************************************/
822 /* ExecuteSQL() */
823 /************************************************************************/
824
825 void OGRHanaDataSource::ExecuteSQL(const CPLString &sql)
826 {
827 std::u16string sqlUtf16 =
828 odbc::StringConverter::utf8ToUtf16(sql.c_str(), sql.length());
829 odbc::StatementRef stmt = conn_->createStatement();
830 stmt->execute(sqlUtf16.c_str());
831 if (!IsTransactionStarted())
832 conn_->commit();
833 }
834
835 /************************************************************************/
836 /* GetSrsById() */
837 /* */
838 /* Return a SRS corresponding to a particular id. The returned */
839 /* object has its reference counter incremented. Consequently */
840 /* the caller should call Release() on it (if not null) once done */
841 /* with it. */
842 /************************************************************************/
843
844 OGRSpatialReference *OGRHanaDataSource::GetSrsById(int srid)
845 {
846 if (srid < 0)
847 return nullptr;
848
849 auto it = srsCache_.find(srid);
850 if (it != srsCache_.end())
851 {
852 it->second->Reference();
853 return it->second;
854 }
855
856 OGRSpatialReference *srs = nullptr;
857
858 CPLString wkt = GetSrsWktById(*conn_, srid);
859 if (!wkt.empty())
860 {
861 srs = new OGRSpatialReference();
862 OGRErr err = srs->importFromWkt(wkt.c_str());
863 if (OGRERR_NONE != err)
864 {
865 delete srs;
866 srs = nullptr;
867 }
868 }
869
870 srsCache_.insert({srid, srs});
871
872 if (srs)
873 srs->Reference();
874 return srs;
875 }
876
877 /************************************************************************/
878 /* GetSrsId() */
879 /************************************************************************/
880
881 int OGRHanaDataSource::GetSrsId(const OGRSpatialReference *srs)
882 {
883 if (srs == nullptr)
884 return UNDETERMINED_SRID;
885
886 /* -------------------------------------------------------------------- */
887 /* Try to find srs id using authority name and code (EPSG:3857). */
888 /* -------------------------------------------------------------------- */
889 OGRSpatialReference srsLocal(*srs);
890
891 const char *authorityName = srsLocal.GetAuthorityName();
892 if (authorityName == nullptr || strlen(authorityName) == 0)
893 {
894 srsLocal.AutoIdentifyEPSG();
895 authorityName = srsLocal.GetAuthorityName();
896 if (authorityName != nullptr && EQUAL(authorityName, "EPSG"))
897 {
898 const char *authorityCode = srsLocal.GetAuthorityCode();
899 if (authorityCode != nullptr && strlen(authorityCode) > 0)
900 {
901 srsLocal.importFromEPSG(atoi(authorityCode));
902 authorityName = srsLocal.GetAuthorityName();
903 }
904 }
905 }
906
907 int authorityCode = 0;
908 if (authorityName != nullptr)
909 {
910 authorityCode = atoi(srsLocal.GetAuthorityCode());
911 if (authorityCode > 0)
912 {
913 int ret = GetSridWithFilter(
914 *conn_,
915 CPLString().Printf("SRS_ID = %d AND ORGANIZATION = '%s'",
916 authorityCode, authorityName));
917 if (ret != UNDETERMINED_SRID)
918 return ret;
919 }
920 }
921
922 /* -------------------------------------------------------------------- */
923 /* Try to find srs id using wkt content. */
924 /* -------------------------------------------------------------------- */
925
926 char *wkt = nullptr;
927 OGRErr err = srsLocal.exportToWkt(&wkt);
928 CPLString strWkt(wkt);
929 CPLFree(wkt);
930
931 if (OGRERR_NONE != err)
932 return UNDETERMINED_SRID;
933
934 int srid = GetSridWithFilter(
935 *conn_, CPLString().Printf("DEFINITION = '%s'", strWkt.c_str()));
936 if (srid != UNDETERMINED_SRID)
937 return srid;
938
939 /* -------------------------------------------------------------------- */
940 /* Try to add a new spatial reference system to the database */
941 /* -------------------------------------------------------------------- */
942
943 char *proj4 = nullptr;
944 err = srsLocal.exportToProj4(&proj4);
945 CPLString strProj4(proj4);
946 CPLFree(proj4);
947
948 if (OGRERR_NONE != err)
949 return srid;
950
951 if (authorityName != nullptr && authorityCode > 0)
952 {
953 srid = authorityCode;
954 }
955 else
956 {
957 odbc::StatementRef stmt = conn_->createStatement();
958 const char *sql =
959 "SELECT MAX(SRS_ID) FROM SYS.ST_SPATIAL_REFERENCE_SYSTEMS WHERE "
960 "SRS_ID >= 10000000 AND SRS_ID < 20000000";
961 odbc::ResultSetRef rsSrid = stmt->executeQuery(sql);
962 while (rsSrid->next())
963 {
964 odbc::Int val = rsSrid->getInt(1);
965 srid = val.isNull() ? 10000000 : *val + 1;
966 }
967 rsSrid->close();
968 }
969
970 try
971 {
972 CreateSpatialReferenceSystem(srsLocal, srid, authorityName,
973 authorityCode, strWkt, strProj4);
974 return srid;
975 }
976 catch (const odbc::Exception &ex)
977 {
978 CPLError(CE_Failure, CPLE_AppDefined,
979 "Unable to create an SRS in the database: %s.\n", ex.what());
980 }
981
982 return UNDETERMINED_SRID;
983 }
984
985 /************************************************************************/
986 /* IsSrsRoundEarth() */
987 /************************************************************************/
988
989 bool OGRHanaDataSource::IsSrsRoundEarth(int srid)
990 {
991 const char *sql =
992 "SELECT ROUND_EARTH FROM SYS.ST_SPATIAL_REFERENCE_SYSTEMS "
993 "WHERE SRS_ID = ?";
994 odbc::PreparedStatementRef stmt = PrepareStatement(sql);
995 stmt->setInt(1, odbc::Int(srid));
996 odbc::ResultSetRef rs = stmt->executeQuery();
997 bool ret = false;
998 if (rs->next())
999 ret = (*rs->getString(1) == "TRUE");
1000 rs->close();
1001 return ret;
1002 }
1003
1004 /************************************************************************/
1005 /* HasSrsPlanarEquivalent() */
1006 /************************************************************************/
1007
1008 bool OGRHanaDataSource::HasSrsPlanarEquivalent(int srid)
1009 {
1010 const char *sql = "SELECT COUNT(*) FROM SYS.ST_SPATIAL_REFERENCE_SYSTEMS "
1011 "WHERE SRS_ID = ?";
1012 odbc::PreparedStatementRef stmt = PrepareStatement(sql);
1013 stmt->setInt(1, ToPlanarSRID(srid));
1014 odbc::ResultSetRef rs = stmt->executeQuery();
1015 std::int64_t count = 0;
1016 if (rs->next())
1017 count = *rs->getLong(1);
1018 rs->close();
1019 return count > 0;
1020 }
1021
1022 /************************************************************************/
1023 /* GetQueryColumns() */
1024 /************************************************************************/
1025
1026 OGRErr OGRHanaDataSource::GetQueryColumns(
1027 const CPLString &schemaName, const CPLString &query,
1028 std::vector<ColumnDescription> &columnDescriptions)
1029 {
1030 columnDescriptions.clear();
1031
1032 odbc::PreparedStatementRef stmtQuery = PrepareStatement(query);
1033
1034 if (stmtQuery.isNull())
1035 return OGRERR_FAILURE;
1036
1037 odbc::ResultSetMetaDataRef rsmd = stmtQuery->getMetaData();
1038 std::size_t numColumns = rsmd->getColumnCount();
1039 if (numColumns == 0)
1040 return OGRERR_NONE;
1041
1042 columnDescriptions.reserve(numColumns);
1043
1044 odbc::DatabaseMetaDataRef dmd = conn_->getDatabaseMetaData();
1045 odbc::PreparedStatementRef stmtArrayTypeInfo =
1046 PrepareStatement("SELECT DATA_TYPE_NAME FROM "
1047 "SYS.TABLE_COLUMNS_ODBC WHERE SCHEMA_NAME = ? "
1048 "AND TABLE_NAME = ? AND COLUMN_NAME = ? AND "
1049 "DATA_TYPE_NAME LIKE '% ARRAY'");
1050
1051 for (unsigned short clmIndex = 1; clmIndex <= numColumns; ++clmIndex)
1052 {
1053 CPLString typeName = rsmd->getColumnTypeName(clmIndex);
1054
1055 if (typeName.empty())
1056 continue;
1057
1058 bool isArray = false;
1059 CPLString tableName = rsmd->getTableName(clmIndex);
1060 CPLString columnName = rsmd->getColumnName(clmIndex);
1061 CPLString defaultValue;
1062 short dataType = rsmd->getColumnType(clmIndex);
1063
1064 if (!schemaName.empty() && !tableName.empty())
1065 {
1066 // Retrieve information about default value in column
1067 odbc::ResultSetRef rsColumns =
1068 dmd->getColumns(nullptr, schemaName.c_str(), tableName.c_str(),
1069 columnName.c_str());
1070 if (rsColumns->next())
1071 {
1072 odbc::String defaultValueStr =
1073 rsColumns->getString(13 /*COLUMN_DEF*/);
1074 if (!defaultValueStr.isNull())
1075 defaultValue =
1076 FormatDefaultValue(defaultValueStr->c_str(), dataType);
1077 }
1078 rsColumns->close();
1079
1080 // Retrieve information about array type
1081 stmtArrayTypeInfo->setString(1, schemaName);
1082 stmtArrayTypeInfo->setString(2, tableName);
1083 stmtArrayTypeInfo->setString(3, columnName);
1084 odbc::ResultSetRef rsArrayTypes = stmtArrayTypeInfo->executeQuery();
1085 if (rsArrayTypes->next())
1086 {
1087 typeName = *rsArrayTypes->getString(1);
1088 dataType = GetArrayDataType(typeName);
1089
1090 if (dataType == QGRHanaDataTypes::Unknown)
1091 {
1092 CPLError(
1093 CE_Failure, CPLE_AppDefined,
1094 "GetQueryColumns(): Unsupported type of array (%s)",
1095 typeName.c_str());
1096 return OGRERR_FAILURE;
1097 }
1098
1099 isArray = true;
1100 }
1101 rsArrayTypes->close();
1102 }
1103
1104 if (!isArray && !IsKnownDataType(dataType))
1105 {
1106 odbc::ResultSetRef rsTypeInfo = dmd->getTypeInfo(dataType);
1107 if (rsTypeInfo->next())
1108 {
1109 odbc::String name = rsTypeInfo->getString(1);
1110 if (name.isNull())
1111 continue;
1112 if (name->compare("SHORTTEXT") == 0 ||
1113 name->compare("ALPHANUM") == 0)
1114 {
1115 dataType = QGRHanaDataTypes::WVarChar;
1116 }
1117 }
1118 rsTypeInfo->close();
1119 }
1120
1121 if (dataType == QGRHanaDataTypes::Geometry)
1122 {
1123 GeometryColumnDescription geometryColumnDesc;
1124 if (schemaName.empty() || tableName.empty())
1125 geometryColumnDesc = GetGeometryColumnDescription(
1126 *conn_, query, columnName, detectGeometryType_);
1127 else
1128 geometryColumnDesc = GetGeometryColumnDescription(
1129 *conn_, schemaName, tableName, columnName,
1130 detectGeometryType_);
1131 geometryColumnDesc.isNullable = rsmd->isNullable(clmIndex);
1132
1133 columnDescriptions.push_back({true, AttributeColumnDescription(),
1134 std::move(geometryColumnDesc)});
1135 }
1136 else
1137 {
1138 AttributeColumnDescription attributeColumnDesc;
1139 attributeColumnDesc.name = std::move(columnName);
1140 attributeColumnDesc.type = dataType;
1141 attributeColumnDesc.typeName = std::move(typeName);
1142 attributeColumnDesc.isArray = isArray;
1143 attributeColumnDesc.isNullable = rsmd->isNullable(clmIndex);
1144 attributeColumnDesc.isAutoIncrement =
1145 rsmd->isAutoIncrement(clmIndex);
1146 attributeColumnDesc.length =
1147 static_cast<int>(rsmd->getColumnLength(clmIndex));
1148 attributeColumnDesc.precision = rsmd->getPrecision(clmIndex);
1149 attributeColumnDesc.scale = rsmd->getScale(clmIndex);
1150 attributeColumnDesc.defaultValue = std::move(defaultValue);
1151
1152 columnDescriptions.push_back({false, std::move(attributeColumnDesc),
1153 GeometryColumnDescription()});
1154 }
1155 }
1156
1157 return OGRERR_NONE;
1158 }
1159
1160 /************************************************************************/
1161 /* GetTablePrimaryKeys() */
1162 /************************************************************************/
1163
1164 std::vector<CPLString>
1165 OGRHanaDataSource::GetTablePrimaryKeys(const char *schemaName,
1166 const char *tableName)
1167 {
1168 std::vector<CPLString> ret;
1169
1170 odbc::DatabaseMetaDataRef dmd = conn_->getDatabaseMetaData();
1171 odbc::ResultSetRef rsPrimaryKeys =
1172 dmd->getPrimaryKeys(nullptr, schemaName, tableName);
1173 while (rsPrimaryKeys->next())
1174 {
1175 ret.push_back(*rsPrimaryKeys->getString(4));
1176 }
1177 rsPrimaryKeys->close();
1178
1179 return ret;
1180 }
1181
1182 /************************************************************************/
1183 /* InitializeLayers() */
1184 /************************************************************************/
1185
1186 void OGRHanaDataSource::InitializeLayers(const char *schemaName,
1187 const char *tableNames)
1188 {
1189 std::vector<CPLString> tablesToFind = SplitStrings(tableNames, ",");
1190 const bool hasTablesToFind = !tablesToFind.empty();
1191
1192 auto addLayersFromQuery = [&](const char *query, bool updatable)
1193 {
1194 odbc::PreparedStatementRef stmt = PrepareStatement(query);
1195 stmt->setString(1, odbc::String(schemaName));
1196 odbc::ResultSetRef rsTables = stmt->executeQuery();
1197 while (rsTables->next())
1198 {
1199 odbc::String tableName = rsTables->getString(1);
1200 if (tableName.isNull())
1201 continue;
1202 auto pos =
1203 std::find(tablesToFind.begin(), tablesToFind.end(), *tableName);
1204 if (pos != tablesToFind.end())
1205 tablesToFind.erase(pos);
1206
1207 auto layer = std::make_unique<OGRHanaTableLayer>(
1208 this, schemaName_.c_str(), tableName->c_str(), updatable);
1209 layers_.push_back(std::move(layer));
1210 }
1211 rsTables->close();
1212 };
1213
1214 // Look for layers in Tables
1215 std::ostringstream osTables;
1216 osTables << "SELECT TABLE_NAME FROM SYS.TABLES WHERE SCHEMA_NAME = ?";
1217 if (!tablesToFind.empty())
1218 osTables << " AND TABLE_NAME IN ("
1219 << JoinStrings(tablesToFind, ",", Literal) << ")";
1220
1221 addLayersFromQuery(osTables.str().c_str(), updateMode_);
1222
1223 if (!(hasTablesToFind && tablesToFind.empty()))
1224 {
1225 // Look for layers in Views
1226 std::ostringstream osViews;
1227 osViews << "SELECT VIEW_NAME FROM SYS.VIEWS WHERE SCHEMA_NAME = ?";
1228 // cppcheck-suppress knownConditionTrueFalse
1229 if (!tablesToFind.empty())
1230 osViews << " AND VIEW_NAME IN ("
1231 << JoinStrings(tablesToFind, ",", Literal) << ")";
1232
1233 addLayersFromQuery(osViews.str().c_str(), false);
1234 }
1235
1236 // Report about tables that could not be found
1237 for (const auto &tableName : tablesToFind)
1238 {
1239 const char *layerName = tableName.c_str();
1240 if (GetLayerByName(layerName) == nullptr)
1241 CPLDebug("HANA",
1242 "Table '%s' not found or does not "
1243 "have any geometry column.",
1244 layerName);
1245 }
1246 }
1247
1248 /************************************************************************/
1249 /* LaunderName() */
1250 /************************************************************************/
1251
1252 std::pair<OGRErr, CPLString> OGRHanaDataSource::LaunderName(const char *name)
1253 {
1254 CPLAssert(name != nullptr);
1255
1256 if (!CPLIsUTF8(name, -1))
1257 {
1258 CPLError(CE_Failure, CPLE_AppDefined, "%s is not a valid UTF-8 string.",
1259 name);
1260 return {OGRERR_FAILURE, ""};
1261 }
1262
1263 auto getUTF8SequenceLength = [](char c)
1264 {
1265 if ((c & 0x80) == 0x00)
1266 return 1;
1267 if ((c & 0xE0) == 0xC0)
1268 return 2;
1269 if ((c & 0xF0) == 0xE0)
1270 return 3;
1271 if ((c & 0xF8) == 0xF0)
1272 return 4;
1273
1274 throw std::runtime_error("Invalid UTF-8 sequence");
1275 };
1276
1277 CPLString newName(name);
1278 bool hasNonASCII = false;
1279 size_t i = 0;
1280
1281 while (name[i] != '\0')
1282 {
1283 char c = name[i];
1284 int len = getUTF8SequenceLength(c);
1285 if (len == 1)
1286 {
1287 if (c == '-' || c == '#')
1288 newName[i] = '_';
1289 else
1290 newName[i] = static_cast<char>(
1291 CPLToupper(static_cast<unsigned char>(c)));
1292 }
1293 else
1294 {
1295 hasNonASCII = true;
1296 }
1297
1298 i += len;
1299 }
1300
1301 if (!hasNonASCII)
1302 return {OGRERR_NONE, newName};
1303
1304 const char *sql = "SELECT UPPER(?) FROM DUMMY";
1305 odbc::PreparedStatementRef stmt = PrepareStatement(sql);
1306 stmt->setString(1, odbc::String(newName.c_str()));
1307 odbc::ResultSetRef rsName = stmt->executeQuery();
1308 OGRErr err = OGRERR_NONE;
1309 if (rsName->next())
1310 {
1311 newName.swap(*rsName->getString(1));
1312 }
1313 else
1314 {
1315 err = OGRERR_FAILURE;
1316 newName.clear();
1317 }
1318 rsName->close();
1319 return {err, newName};
1320 }
1321
1322 /************************************************************************/
1323 /* CreateSpatialReference() */
1324 /************************************************************************/
1325
1326 void OGRHanaDataSource::CreateSpatialReferenceSystem(
1327 const OGRSpatialReference &srs, int srid, const char *authorityName,
1328 int authorityCode, const CPLString &wkt, const CPLString &proj4)
1329 {
1330 CPLString refName((srs.IsProjected()) ? srs.GetAttrValue("PROJCS")
1331 : srs.GetAttrValue("GEOGCS"));
1332 if (refName.empty() || EQUAL(refName.c_str(), "UNKNOWN"))
1333 refName = "OGR_PROJECTION_" + std::to_string(srid);
1334
1335 OGRErr err = OGRERR_NONE;
1336 CPLString ellipsoidParams;
1337 const double semiMajor = srs.GetSemiMajor(&err);
1338 if (OGRERR_NONE == err)
1339 ellipsoidParams += " SEMI MAJOR AXIS " + std::to_string(semiMajor);
1340 const double semiMinor = srs.GetSemiMinor(&err);
1341 const double invFlattening = srs.GetInvFlattening(&err);
1342 if (OGRERR_NONE == err)
1343 ellipsoidParams +=
1344 " INVERSE FLATTENING " + std::to_string(invFlattening);
1345 else
1346 ellipsoidParams += " SEMI MINOR AXIS " + std::to_string(semiMinor);
1347
1348 const char *linearUnits = nullptr;
1349 srs.GetLinearUnits(&linearUnits);
1350 const char *angularUnits = nullptr;
1351 srs.GetAngularUnits(&angularUnits);
1352
1353 CPLString xRange, yRange;
1354 double dfWestLongitudeDeg, dfSouthLatitudeDeg, dfEastLongitudeDeg,
1355 dfNorthLatitudeDeg;
1356 if (srs.GetAreaOfUse(&dfWestLongitudeDeg, &dfSouthLatitudeDeg,
1357 &dfEastLongitudeDeg, &dfNorthLatitudeDeg, nullptr))
1358 {
1359 xRange = CPLString().Printf("%s BETWEEN %f AND %f",
1360 srs.IsGeographic() ? "LONGITUDE" : "X",
1361 dfWestLongitudeDeg, dfEastLongitudeDeg);
1362 yRange = CPLString().Printf("%s BETWEEN %f AND %f",
1363 srs.IsGeographic() ? "LATITUDE" : "Y",
1364 dfSouthLatitudeDeg, dfNorthLatitudeDeg);
1365 }
1366 else
1367 {
1368 xRange = CPLString().Printf("%s UNBOUNDED",
1369 srs.IsGeographic() ? "LONGITUDE" : "X");
1370 yRange = CPLString().Printf("%s UNBOUNDED ",
1371 srs.IsGeographic() ? "LATITUDE" : "Y");
1372 }
1373
1374 CPLString organization;
1375 if (authorityName != nullptr && authorityCode > 0)
1376 {
1377 organization = CPLString().Printf(
1378 "ORGANIZATION %s IDENTIFIED BY %d",
1379 QuotedIdentifier(authorityName).c_str(), authorityCode);
1380 }
1381
1382 CPLString sql = CPLString().Printf(
1383 "CREATE SPATIAL REFERENCE SYSTEM %s "
1384 "IDENTIFIED BY %d "
1385 "TYPE %s "
1386 "LINEAR UNIT OF MEASURE %s "
1387 "ANGULAR UNIT OF MEASURE %s "
1388 "%s " // ELLIPSOID
1389 "COORDINATE %s "
1390 "COORDINATE %s "
1391 "%s " // ORGANIZATION
1392 "DEFINITION %s "
1393 "TRANSFORM DEFINITION %s",
1394 QuotedIdentifier(refName).c_str(), srid,
1395 srs.IsGeographic() ? "ROUND EARTH" : "PLANAR",
1396 QuotedIdentifier(
1397 (linearUnits == nullptr || EQUAL(linearUnits, "unknown"))
1398 ? "metre"
1399 : linearUnits)
1400 .tolower()
1401 .c_str(),
1402 QuotedIdentifier(
1403 (angularUnits == nullptr || EQUAL(angularUnits, "unknown"))
1404 ? "degree"
1405 : angularUnits)
1406 .tolower()
1407 .c_str(),
1408 (ellipsoidParams.empty() ? ""
1409 : ("ELLIPSOID" + ellipsoidParams).c_str()),
1410 xRange.c_str(), yRange.c_str(), organization.c_str(),
1411 Literal(wkt).c_str(), Literal(proj4).c_str());
1412
1413 ExecuteSQL(sql);
1414 }
1415
1416 /************************************************************************/
1417 /* CreateParseArrayFunctions() */
1418 /************************************************************************/
1419
1420 void OGRHanaDataSource::CreateParseArrayFunctions(const char *schemaName)
1421 {
1422 auto replaceAll = [](const CPLString &str, const CPLString &before,
1423 const CPLString &after) -> CPLString
1424 {
1425 CPLString res = str;
1426 return res.replaceAll(before, after);
1427 };
1428
1429 // clang-format off
1430 const CPLString parseStringArrayFunc =
1431 "CREATE OR REPLACE FUNCTION {SCHEMA}.OGR_PARSE_STRING_ARRAY(IN str NCLOB, IN delimiter NVARCHAR(10))\n"
1432 "RETURNS TABLE(VALUE NVARCHAR(512))\n"
1433 "LANGUAGE SQLSCRIPT\n"
1434 "SQL SECURITY INVOKER AS\n"
1435 "BEGIN\n"
1436 "DECLARE arrValues NVARCHAR(512) ARRAY;\n"
1437 "DECLARE idx INTEGER = 1;\n"
1438 "DECLARE curPos INTEGER = 1;\n"
1439 "DECLARE lastPos INTEGER = 1;\n"
1440 "DECLARE delimiterLength INTEGER = LENGTH(delimiter);\n"
1441
1442 "IF(NOT(:str IS NULL)) THEN\n"
1443 "WHILE(:curPos > 0) DO\n"
1444 "curPos = LOCATE(:str, :delimiter, :lastPos);\n"
1445 "IF :curPos = 0 THEN\n"
1446 "BREAK;\n"
1447 "END IF;\n"
1448
1449 "arrValues[:idx] = SUBSTRING(:str, :lastPos, :curPos - :lastPos);\n"
1450 "lastPos = :curPos + :delimiterLength;\n"
1451 "idx = :idx + 1;\n"
1452 "END WHILE;\n"
1453
1454 "arrValues[:idx] = SUBSTRING(:str, :lastPos, LENGTH(:str));\n"
1455 "END IF;\n"
1456
1457 "ret = UNNEST(:arrValues) AS(\"VALUE\");\n"
1458 "RETURN SELECT * FROM :ret;\n"
1459 "END;\n";
1460 // clang-format on
1461
1462 CPLString sql = replaceAll(parseStringArrayFunc, "{SCHEMA}",
1463 QuotedIdentifier(schemaName));
1464 ExecuteSQL(sql);
1465
1466 // clang-format off
1467 const CPLString parseTypeArrayFunc =
1468 "CREATE OR REPLACE FUNCTION {SCHEMA}.OGR_PARSE_{TYPE}_ARRAY(IN str NCLOB, IN delimiter NVARCHAR(10))\n"
1469 "RETURNS TABLE(VALUE {TYPE})\n"
1470 "LANGUAGE SQLSCRIPT\n"
1471 "SQL SECURITY INVOKER AS\n"
1472 "BEGIN\n"
1473 "DECLARE arrValues {TYPE} ARRAY;\n"
1474 "DECLARE elemValue STRING;\n"
1475 "DECLARE idx INTEGER = 1;\n"
1476 "DECLARE CURSOR cursor_values FOR\n"
1477 "SELECT * FROM OGR_PARSE_STRING_ARRAY(:str, :delimiter);\n"
1478
1479 "FOR row_value AS cursor_values DO\n"
1480 "elemValue = TRIM(row_value.VALUE);\n"
1481 "IF(UPPER(elemValue) = 'NULL') THEN\n"
1482 "arrValues[:idx] = CAST(NULL AS {TYPE});\n"
1483 "ELSE\n"
1484 "arrValues[:idx] = CAST(:elemValue AS {TYPE});\n"
1485 "END IF;\n"
1486 "idx = :idx + 1;\n"
1487 "END FOR;\n"
1488
1489 "ret = UNNEST(:arrValues) AS(\"VALUE\");\n"
1490 "RETURN SELECT * FROM :ret;\n"
1491 "END;\n";
1492 // clang-format on
1493
1494 sql = replaceAll(parseTypeArrayFunc, "{SCHEMA}",
1495 QuotedIdentifier(schemaName));
1496
1497 for (const CPLString &type : GetSupportedArrayTypes())
1498 {
1499 if (type == "STRING")
1500 continue;
1501 ExecuteSQL(replaceAll(sql, "{TYPE}", type));
1502 }
1503 }
1504
1505 /************************************************************************/
1506 /* ParseArrayFunctionsExist() */
1507 /************************************************************************/
1508
1509 bool OGRHanaDataSource::ParseArrayFunctionsExist(const char *schemaName)
1510 {
1511 const char *sql =
1512 "SELECT COUNT(*) FROM FUNCTIONS WHERE SCHEMA_NAME = ? AND "
1513 "FUNCTION_NAME LIKE 'OGR_PARSE_%_ARRAY'";
1514 odbc::PreparedStatementRef stmt = PrepareStatement(sql);
1515 stmt->setString(1, odbc::String(schemaName));
1516 odbc::ResultSetRef rsFunctions = stmt->executeQuery();
1517 auto numFunctions = rsFunctions->next() ? *rsFunctions->getLong(1) : 0;
1518 rsFunctions->close();
1519 return (static_cast<std::size_t>(numFunctions) ==
1520 GetSupportedArrayTypes().size());
1521 }
1522
1523 /************************************************************************/
1524 /* GetLayer() */
1525 /************************************************************************/
1526
1527 const OGRLayer *OGRHanaDataSource::GetLayer(int index) const
1528 {
1529 if (index < 0 || static_cast<std::size_t>(index) >= layers_.size())
1530 return nullptr;
1531 return layers_[static_cast<std::size_t>(index)].get();
1532 }
1533
1534 /************************************************************************/
1535 /* GetLayerByName() */
1536 /************************************************************************/
1537
1538 OGRLayer *OGRHanaDataSource::GetLayerByName(const char *name)
1539 {
1540 return GetLayer(FindLayerByName(name));
1541 }
1542
1543 /************************************************************************/
1544 /* ICreateLayer() */
1545 /************************************************************************/
1546
1547 OGRLayer *
1548 OGRHanaDataSource::ICreateLayer(const char *layerNameIn,
1549 const OGRGeomFieldDefn *poGeomFieldDefn,
1550 CSLConstList options)
1551 {
1552 if (layerNameIn == nullptr)
1553 return nullptr;
1554
1555 const auto geomType =
1556 poGeomFieldDefn ? poGeomFieldDefn->GetType() : wkbNone;
1557 const auto srs =
1558 poGeomFieldDefn ? poGeomFieldDefn->GetSpatialRef() : nullptr;
1559
1560 // Check if we are allowed to create new objects in the database
1561 odbc::DatabaseMetaDataRef dmd = conn_->getDatabaseMetaData();
1562 if (dmd->isReadOnly())
1563 {
1564 CPLError(CE_Failure, CPLE_AppDefined,
1565 "Unable to create Layer %s.\n"
1566 "Database %s is read only.",
1567 layerNameIn, dmd->getDatabaseName().c_str());
1568 return nullptr;
1569 }
1570
1571 bool launderNames = CPLFetchBool(
1572 options, OGRHanaLayerCreationOptionsConstants::LAUNDER, true);
1573 CPLString layerName(layerNameIn);
1574 if (launderNames)
1575 {
1576 auto nameRes = LaunderName(layerNameIn);
1577 if (nameRes.first != OGRERR_NONE)
1578 return nullptr;
1579 layerName.swap(nameRes.second);
1580 }
1581
1582 CPLDebug("HANA", "Creating layer %s.", layerName.c_str());
1583
1584 int layerIndex = FindLayerByName(layerName.c_str());
1585 if (layerIndex >= 0)
1586 {
1587 bool overwriteLayer = CPLFetchBool(
1588 options, OGRHanaLayerCreationOptionsConstants::OVERWRITE, false);
1589 if (!overwriteLayer)
1590 {
1591 CPLError(CE_Failure, CPLE_AppDefined,
1592 "Layer %s already exists, CreateLayer failed.\n"
1593 "Use the layer creation option OVERWRITE=YES to "
1594 "replace it.",
1595 layerName.c_str());
1596 return nullptr;
1597 }
1598
1599 DeleteLayer(layerIndex);
1600 }
1601
1602 int batchSize =
1603 CPLFetchInt(options, OGRHanaLayerCreationOptionsConstants::BATCH_SIZE,
1604 DEFAULT_BATCH_SIZE);
1605 if (batchSize <= 0)
1606 {
1607 CPLError(CE_Failure, CPLE_AppDefined,
1608 "Unable to create layer %s. The value of %s parameter must be "
1609 "greater than 0.",
1610 layerName.c_str(),
1611 OGRHanaLayerCreationOptionsConstants::BATCH_SIZE);
1612 return nullptr;
1613 }
1614
1615 int defaultStringSize = CPLFetchInt(
1616 options, OGRHanaLayerCreationOptionsConstants::DEFAULT_STRING_SIZE,
1617 DEFAULT_STRING_SIZE);
1618 if (defaultStringSize <= 0)
1619 {
1620 CPLError(CE_Failure, CPLE_AppDefined,
1621 "Unable to create layer %s. The value of %s parameter must be "
1622 "greater than 0.",
1623 layerName.c_str(),
1624 OGRHanaLayerCreationOptionsConstants::DEFAULT_STRING_SIZE);
1625 return nullptr;
1626 }
1627
1628 CPLString geomColumnName(CSLFetchNameValueDef(
1629 options, OGRHanaLayerCreationOptionsConstants::GEOMETRY_NAME,
1630 "OGR_GEOMETRY"));
1631 if (launderNames)
1632 {
1633 auto nameRes = LaunderName(geomColumnName.c_str());
1634 if (nameRes.first != OGRERR_NONE)
1635 return nullptr;
1636 geomColumnName.swap(nameRes.second);
1637 }
1638
1639 const bool geomColumnNullable = CPLFetchBool(
1640 options, OGRHanaLayerCreationOptionsConstants::GEOMETRY_NULLABLE, true);
1641 CPLString geomColumnIndexType(CSLFetchNameValueDef(
1642 options, OGRHanaLayerCreationOptionsConstants::GEOMETRY_INDEX,
1643 "DEFAULT"));
1644
1645 const char *paramFidName = CSLFetchNameValueDef(
1646 options, OGRHanaLayerCreationOptionsConstants::FID, "OGR_FID");
1647 CPLString fidName(paramFidName);
1648 if (launderNames)
1649 {
1650 auto nameRes = LaunderName(paramFidName);
1651 if (nameRes.first != OGRERR_NONE)
1652 return nullptr;
1653 fidName.swap(nameRes.second);
1654 }
1655
1656 CPLString fidType =
1657 CPLFetchBool(options, OGRHanaLayerCreationOptionsConstants::FID64,
1658 false)
1659 ? "BIGINT"
1660 : "INTEGER";
1661
1662 CPLDebug("HANA", "Geometry Column Name %s.", geomColumnName.c_str());
1663 CPLDebug("HANA", "FID Column Name %s, Type %s.", fidName.c_str(),
1664 fidType.c_str());
1665
1666 int srid = CPLFetchInt(options, OGRHanaLayerCreationOptionsConstants::SRID,
1667 UNDETERMINED_SRID);
1668 if (srid < 0 && srs != nullptr)
1669 srid = GetSrsId(srs);
1670
1671 try
1672 {
1673 CreateTable(layerName, fidName, fidType, geomColumnName, geomType,
1674 geomColumnNullable, geomColumnIndexType, srid);
1675 }
1676 catch (const odbc::Exception &ex)
1677 {
1678 CPLError(CE_Failure, CPLE_AppDefined,
1679 "Unable to create layer %s. CreateLayer failed:%s\n",
1680 layerName.c_str(), ex.what());
1681 return nullptr;
1682 }
1683
1684 // Create new layer object
1685 auto layer = std::make_unique<OGRHanaTableLayer>(this, schemaName_.c_str(),
1686 layerName.c_str(), true);
1687 if (geomType != wkbNone && layer->GetLayerDefn()->GetGeomFieldCount() > 0)
1688 layer->GetLayerDefn()->GetGeomFieldDefn(0)->SetNullable(FALSE);
1689 if (batchSize > 0)
1690 layer->SetBatchSize(static_cast<std::size_t>(batchSize));
1691 if (defaultStringSize > 0)
1692 layer->SetDefaultStringSize(
1693 static_cast<std::size_t>(defaultStringSize));
1694 layer->SetLaunderFlag(launderNames);
1695 layer->SetPrecisionFlag(CPLFetchBool(
1696 options, OGRHanaLayerCreationOptionsConstants::PRECISION, true));
1697 layer->SetCustomColumnTypes(CSLFetchNameValue(
1698 options, OGRHanaLayerCreationOptionsConstants::COLUMN_TYPES));
1699
1700 layers_.push_back(std::move(layer));
1701
1702 return layers_.back().get();
1703 }
1704
1705 /************************************************************************/
1706 /* TestCapability() */
1707 /************************************************************************/
1708
1709 int OGRHanaDataSource::TestCapability(const char *capabilities) const
1710 {
1711 if (EQUAL(capabilities, ODsCCreateLayer))
1712 return updateMode_;
1713 else if (EQUAL(capabilities, ODsCDeleteLayer))
1714 return updateMode_;
1715 else if (EQUAL(capabilities, ODsCCreateGeomFieldAfterCreateLayer))
1716 return updateMode_;
1717 else if (EQUAL(capabilities, ODsCMeasuredGeometries))
1718 return TRUE;
1719 else if (EQUAL(capabilities, ODsCRandomLayerWrite))
1720 return updateMode_;
1721 else if (EQUAL(capabilities, ODsCTransactions))
1722 return TRUE;
1723 else
1724 return FALSE;
1725 }
1726
1727 /************************************************************************/
1728 /* ExecuteSQL() */
1729 /************************************************************************/
1730
1731 OGRLayer *OGRHanaDataSource::ExecuteSQL(const char *sqlCommand,
1732 OGRGeometry *spatialFilter,
1733 const char *dialect)
1734 {
1735 sqlCommand = SkipLeadingSpaces(sqlCommand);
1736
1737 if (IsGenericSQLDialect(dialect))
1738 return GDALDataset::ExecuteSQL(sqlCommand, spatialFilter, dialect);
1739
1740 if (STARTS_WITH_CI(sqlCommand, "DELLAYER:"))
1741 {
1742 const char *layerName = SkipLeadingSpaces(sqlCommand + 9);
1743 int layerIndex = FindLayerByName(layerName);
1744 if (layerIndex >= 0)
1745 DeleteLayer(layerIndex);
1746 return nullptr;
1747 }
1748 if (STARTS_WITH_CI(sqlCommand, "SELECT"))
1749 {
1750 auto stmt = PrepareStatement(sqlCommand);
1751 if (stmt.isNull())
1752 return nullptr;
1753
1754 auto layer = std::make_unique<OGRHanaResultLayer>(this, sqlCommand);
1755 if (spatialFilter != nullptr)
1756 layer->SetSpatialFilter(spatialFilter);
1757 return layer.release();
1758 }
1759
1760 try
1761 {
1762 ExecuteSQL(sqlCommand);
1763 }
1764 catch (const odbc::Exception &ex)
1765 {
1766 CPLError(CE_Failure, CPLE_AppDefined,
1767 "Failed to execute SQL statement '%s': %s", sqlCommand,
1768 ex.what());
1769 }
1770
1771 return nullptr;
1772 }
1773
1774 /************************************************************************/
1775 /* StartTransaction() */
1776 /************************************************************************/
1777
1778 OGRErr OGRHanaDataSource::StartTransaction(CPL_UNUSED int bForce)
1779 {
1780 if (isTransactionStarted_)
1781 {
1782 CPLError(CE_Failure, CPLE_AppDefined,
1783 "Transaction already established");
1784 return OGRERR_FAILURE;
1785 }
1786
1787 isTransactionStarted_ = true;
1788 return OGRERR_NONE;
1789 }
1790
1791 /************************************************************************/
1792 /* CommitTransaction() */
1793 /************************************************************************/
1794
1795 OGRErr OGRHanaDataSource::CommitTransaction()
1796 {
1797 if (!isTransactionStarted_)
1798 {
1799 CPLError(CE_Failure, CPLE_AppDefined, "Transaction not established");
1800 return OGRERR_FAILURE;
1801 }
1802
1803 isTransactionStarted_ = false;
1804
1805 try
1806 {
1807 for (size_t i = 0; i < layers_.size(); ++i)
1808 {
1809 OGRHanaLayer *layer = static_cast<OGRHanaLayer *>(layers_[i].get());
1810 if (layer->IsTableLayer())
1811 {
1812 OGRHanaTableLayer *tableLayer =
1813 static_cast<OGRHanaTableLayer *>(layer);
1814 tableLayer->FlushPendingBatches(false);
1815 }
1816 }
1817
1818 conn_->commit();
1819 }
1820 catch (const odbc::Exception &ex)
1821 {
1822 CPLError(CE_Failure, CPLE_AppDefined,
1823 "Failed to commit transaction: %s", ex.what());
1824 return OGRERR_FAILURE;
1825 }
1826 return OGRERR_NONE;
1827 }
1828
1829 /************************************************************************/
1830 /* RollbackTransaction() */
1831 /************************************************************************/
1832
1833 OGRErr OGRHanaDataSource::RollbackTransaction()
1834 {
1835 if (!isTransactionStarted_)
1836 {
1837 CPLError(CE_Failure, CPLE_AppDefined, "Transaction not established");
1838 return OGRERR_FAILURE;
1839 }
1840
1841 isTransactionStarted_ = false;
1842
1843 try
1844 {
1845 conn_->rollback();
1846 }
1847 catch (const odbc::Exception &ex)
1848 {
1849 CPLError(CE_Failure, CPLE_AppDefined,
1850 "Failed to roll back transaction: %s", ex.what());
1851 return OGRERR_FAILURE;
1852 }
1853 return OGRERR_NONE;
1854 }