Debian Codegraph @

ogr/ogrsf_frmts/hana/ogrhanatablelayer.cpp

raw
1 /******************************************************************************
2 *
3 * Project: SAP HANA Spatial Driver
4 * Purpose: OGRHanaTableLayer 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 "ogrhanafeaturereader.h"
15 #include "ogrhanautils.h"
16
17 #include <algorithm>
18 #include <cmath>
19 #include <cstdio>
20 #include <cstring>
21 #include <limits>
22 #include <sstream>
23
24 #include "odbc/Exception.h"
25 #include "odbc/PreparedStatement.h"
26 #include "odbc/ResultSet.h"
27 #include "odbc/Statement.h"
28 #include "odbc/Types.h"
29
30 namespace OGRHANA
31 {
32 namespace
33 {
34
35 constexpr const char *UNSUPPORTED_OP_READ_ONLY =
36 "%s : unsupported operation on a read-only datasource.";
37
38 const char *GetColumnDefaultValue(const OGRFieldDefn &field)
39 {
40 const char *defaultValue = field.GetDefault();
41 if (field.GetType() == OFTInteger && field.GetSubType() == OFSTBoolean)
42 return (EQUAL(defaultValue, "1") || EQUAL(defaultValue, "'t'"))
43 ? "TRUE"
44 : "FALSE";
45 return defaultValue;
46 }
47
48 CPLString FindGeomFieldName(const OGRFeatureDefn &featureDefn)
49 {
50 if (featureDefn.GetGeomFieldCount() == 0)
51 return "OGR_GEOMETRY";
52
53 int numGeomFields = featureDefn.GetGeomFieldCount();
54 for (int i = 1; i <= 2 * numGeomFields; ++i)
55 {
56 CPLString name = CPLSPrintf("OGR_GEOMETRY_%d", i);
57 if (featureDefn.GetGeomFieldIndex(name) < 0)
58 return name;
59 }
60
61 return "OGR_GEOMETRY";
62 }
63
64 CPLString GetParameterValue(short type, const CPLString &typeName, bool isArray)
65 {
66 if (isArray)
67 {
68 CPLString arrayType = "STRING";
69 switch (type)
70 {
71 case QGRHanaDataTypes::TinyInt:
72 arrayType = "TINYINT";
73 break;
74 case QGRHanaDataTypes::SmallInt:
75 arrayType = "SMALLINT";
76 break;
77 case QGRHanaDataTypes::Integer:
78 arrayType = "INT";
79 break;
80 case QGRHanaDataTypes::BigInt:
81 arrayType = "BIGINT";
82 break;
83 case QGRHanaDataTypes::Float:
84 case QGRHanaDataTypes::Real:
85 arrayType = "REAL";
86 break;
87 case QGRHanaDataTypes::Double:
88 arrayType = "DOUBLE";
89 break;
90 case QGRHanaDataTypes::WVarChar:
91 arrayType = "STRING";
92 break;
93 }
94 return "ARRAY(SELECT * FROM OGR_PARSE_" + arrayType + "_ARRAY(?, '" +
95 ARRAY_VALUES_DELIMITER + "'))";
96 }
97 else if (typeName.compare("NCLOB") == 0)
98 return "TO_NCLOB(?)";
99 else if (typeName.compare("CLOB") == 0)
100 return "TO_CLOB(?)";
101 else if (typeName.compare("BLOB") == 0)
102 return "TO_BLOB(?)";
103 else
104 return "?";
105 }
106
107 std::vector<int> ParseIntValues(const std::string &str)
108 {
109 std::vector<int> values;
110 try
111 {
112 std::stringstream stream(str);
113 while (stream.good())
114 {
115 std::string value;
116 std::getline(stream, value, ',');
117 values.push_back(std::stoi(value.c_str()));
118 }
119 }
120 catch (...)
121 {
122 values.clear();
123 }
124 return values;
125 }
126
127 ColumnTypeInfo ParseColumnTypeInfo(const CPLString &typeDef)
128 {
129 auto incorrectFormatErr = [&]()
130 {
131 CPLError(CE_Failure, CPLE_NotSupported,
132 "Column type '%s' has incorrect format.", typeDef.c_str());
133 };
134
135 CPLString typeName;
136 std::vector<int> typeSize;
137
138 const size_t posStart = typeDef.find("(");
139 if (posStart == std::string::npos)
140 {
141 typeName = typeDef;
142 }
143 else
144 {
145 const size_t posEnd = typeDef.rfind(")");
146 if (posEnd != std::string::npos && posEnd > posStart)
147 {
148 const size_t posLast = typeDef.find_last_not_of(" \n\r\t");
149 if (posLast == posEnd)
150 {
151 typeName = typeDef.substr(0, posStart);
152 const std::string values =
153 typeDef.substr(posStart + 1, posEnd - posStart - 1);
154 typeSize = ParseIntValues(values);
155 }
156 }
157
158 if (typeSize.empty() || typeSize.size() > 2)
159 {
160 incorrectFormatErr();
161 return {"", QGRHanaDataTypes::Unknown, 0, 0};
162 }
163 }
164
165 typeName.Trim();
166
167 if (EQUAL(typeName.c_str(), "BOOLEAN"))
168 return {std::move(typeName), QGRHanaDataTypes::Boolean, 0, 0};
169 else if (EQUAL(typeName.c_str(), "TINYINT"))
170 return {std::move(typeName), QGRHanaDataTypes::TinyInt, 0, 0};
171 else if (EQUAL(typeName.c_str(), "SMALLINT"))
172 return {std::move(typeName), QGRHanaDataTypes::SmallInt, 0, 0};
173 else if (EQUAL(typeName.c_str(), "INTEGER"))
174 return {std::move(typeName), QGRHanaDataTypes::Integer, 0, 0};
175 else if (EQUAL(typeName.c_str(), "DECIMAL"))
176 {
177 switch (typeSize.size())
178 {
179 case 0:
180 return {std::move(typeName), QGRHanaDataTypes::Decimal, 0, 0};
181 case 1:
182 return {std::move(typeName), QGRHanaDataTypes::Decimal,
183 typeSize[0], 0};
184 case 2:
185 return {std::move(typeName), QGRHanaDataTypes::Decimal,
186 typeSize[0], typeSize[1]};
187 }
188 }
189 else if (EQUAL(typeName.c_str(), "FLOAT"))
190 {
191 switch (typeSize.size())
192 {
193 case 0:
194 return {std::move(typeName), QGRHanaDataTypes::Float, 10, 0};
195 case 1:
196 return {std::move(typeName), QGRHanaDataTypes::Float,
197 typeSize[0], 0};
198 default:
199 incorrectFormatErr();
200 return {"", QGRHanaDataTypes::Unknown, 0, 0};
201 }
202 }
203 else if (EQUAL(typeName.c_str(), "REAL"))
204 return {std::move(typeName), QGRHanaDataTypes::Real, 0, 0};
205 else if (EQUAL(typeName.c_str(), "DOUBLE"))
206 return {std::move(typeName), QGRHanaDataTypes::Double, 0, 0};
207 else if (EQUAL(typeName.c_str(), "VARCHAR"))
208 {
209 switch (typeSize.size())
210 {
211 case 0:
212 return {std::move(typeName), QGRHanaDataTypes::VarChar, 1, 0};
213 case 1:
214 return {std::move(typeName), QGRHanaDataTypes::VarChar,
215 typeSize[0], 0};
216 default:
217 incorrectFormatErr();
218 return {"", QGRHanaDataTypes::Unknown, 0, 0};
219 }
220 }
221 else if (EQUAL(typeName.c_str(), "NVARCHAR"))
222 {
223 switch (typeSize.size())
224 {
225 case 0:
226 return {std::move(typeName), QGRHanaDataTypes::WVarChar, 1, 0};
227 case 1:
228 return {std::move(typeName), QGRHanaDataTypes::WVarChar,
229 typeSize[0], 0};
230 case 2:
231 incorrectFormatErr();
232 return {"", QGRHanaDataTypes::Unknown, 0, 0};
233 }
234 }
235 else if (EQUAL(typeName.c_str(), "NCLOB"))
236 return {std::move(typeName), QGRHanaDataTypes::WLongVarChar, 0, 0};
237 else if (EQUAL(typeName.c_str(), "DATE"))
238 return {std::move(typeName), QGRHanaDataTypes::Date, 0, 0};
239 else if (EQUAL(typeName.c_str(), "TIME"))
240 return {std::move(typeName), QGRHanaDataTypes::Time, 0, 0};
241 else if (EQUAL(typeName.c_str(), "TIMESTAMP"))
242 return {std::move(typeName), QGRHanaDataTypes::Timestamp, 0, 0};
243 else if (EQUAL(typeName.c_str(), "VARBINARY"))
244 {
245 switch (typeSize.size())
246 {
247 case 0:
248 return {std::move(typeName), QGRHanaDataTypes::VarBinary, 1, 0};
249 case 1:
250 return {std::move(typeName), QGRHanaDataTypes::VarBinary,
251 typeSize[0], 0};
252 case 2:
253 incorrectFormatErr();
254 return {"", QGRHanaDataTypes::Unknown, 0, 0};
255 }
256 }
257 else if (EQUAL(typeName.c_str(), "BLOB"))
258 return {std::move(typeName), QGRHanaDataTypes::LongVarBinary, 0, 0};
259 else if (EQUAL(typeName.c_str(), "REAL_VECTOR"))
260 {
261 switch (typeSize.size())
262 {
263 case 0:
264 return {std::move(typeName), QGRHanaDataTypes::RealVector, 1,
265 0};
266 case 1:
267 return {std::move(typeName), QGRHanaDataTypes::RealVector,
268 typeSize[0], 0};
269 case 2:
270 incorrectFormatErr();
271 return {"", QGRHanaDataTypes::Unknown, 0, 0};
272 }
273 }
274
275 CPLError(CE_Failure, CPLE_NotSupported, "Unknown column type '%s'.",
276 typeName.c_str());
277 return {std::move(typeName), QGRHanaDataTypes::Unknown, 0, 0};
278 }
279
280 CPLString GetColumnDefinition(const ColumnTypeInfo &typeInfo)
281 {
282 bool isArray = std::strstr(typeInfo.name, "ARRAY") != nullptr;
283
284 if (isArray)
285 {
286 switch (typeInfo.type)
287 {
288 case QGRHanaDataTypes::SmallInt:
289 return "SMALLINT ARRAY";
290 case QGRHanaDataTypes::Integer:
291 return "INTEGER ARRAY";
292 case QGRHanaDataTypes::BigInt:
293 return "BIGINT ARRAY";
294 case QGRHanaDataTypes::Real:
295 return "REAL ARRAY";
296 case QGRHanaDataTypes::Double:
297 return "DOUBLE ARRAY";
298 case QGRHanaDataTypes::WVarChar:
299 return "NVARCHAR(512) ARRAY";
300 default:
301 return "UNKNOWN";
302 }
303 }
304
305 switch (typeInfo.type)
306 {
307 case QGRHanaDataTypes::Boolean:
308 case QGRHanaDataTypes::TinyInt:
309 case QGRHanaDataTypes::SmallInt:
310 case QGRHanaDataTypes::Integer:
311 case QGRHanaDataTypes::BigInt:
312 case QGRHanaDataTypes::Float:
313 case QGRHanaDataTypes::Real:
314 case QGRHanaDataTypes::Double:
315 case QGRHanaDataTypes::Date:
316 case QGRHanaDataTypes::TypeDate:
317 case QGRHanaDataTypes::Time:
318 case QGRHanaDataTypes::TypeTime:
319 case QGRHanaDataTypes::Timestamp:
320 case QGRHanaDataTypes::TypeTimestamp:
321 case QGRHanaDataTypes::Char:
322 case QGRHanaDataTypes::WChar:
323 case QGRHanaDataTypes::LongVarChar:
324 case QGRHanaDataTypes::LongVarBinary:
325 return typeInfo.name;
326 case QGRHanaDataTypes::Decimal:
327 case QGRHanaDataTypes::Numeric:
328 return CPLString().Printf("DECIMAL(%d,%d)", typeInfo.width,
329 typeInfo.precision);
330 case QGRHanaDataTypes::VarChar:
331 case QGRHanaDataTypes::WVarChar:
332 case QGRHanaDataTypes::Binary:
333 case QGRHanaDataTypes::VarBinary:
334 case QGRHanaDataTypes::WLongVarChar:
335 case QGRHanaDataTypes::RealVector:
336 return (typeInfo.width == 0)
337 ? typeInfo.name
338 : CPLString().Printf("%s(%d)", typeInfo.name.c_str(),
339 typeInfo.width);
340 default:
341 return "UNKNOWN";
342 }
343 }
344
345 void SetFieldDefn(OGRFieldDefn &field, const ColumnTypeInfo &typeInfo)
346 {
347 auto isArray = [&typeInfo]()
348 { return std::strstr(typeInfo.name, "ARRAY") != nullptr; };
349
350 switch (typeInfo.type)
351 {
352 case QGRHanaDataTypes::Bit:
353 case QGRHanaDataTypes::Boolean:
354 field.SetType(OFTInteger);
355 field.SetSubType(OFSTBoolean);
356 break;
357 case QGRHanaDataTypes::TinyInt:
358 case QGRHanaDataTypes::SmallInt:
359 field.SetType(isArray() ? OFTIntegerList : OFTInteger);
360 field.SetSubType(OFSTInt16);
361 break;
362 case QGRHanaDataTypes::Integer:
363 field.SetType(isArray() ? OFTIntegerList : OFTInteger);
364 break;
365 case QGRHanaDataTypes::BigInt:
366 field.SetType(isArray() ? OFTInteger64List : OFTInteger64);
367 break;
368 case QGRHanaDataTypes::Double:
369 case QGRHanaDataTypes::Real:
370 case QGRHanaDataTypes::Float:
371 field.SetType(isArray() ? OFTRealList : OFTReal);
372 if (typeInfo.type != QGRHanaDataTypes::Double)
373 field.SetSubType(OFSTFloat32);
374 break;
375 case QGRHanaDataTypes::Decimal:
376 case QGRHanaDataTypes::Numeric:
377 field.SetType(isArray() ? OFTRealList : OFTReal);
378 break;
379 case QGRHanaDataTypes::Char:
380 case QGRHanaDataTypes::VarChar:
381 case QGRHanaDataTypes::LongVarChar:
382 field.SetType(isArray() ? OFTStringList : OFTString);
383 break;
384 case QGRHanaDataTypes::WChar:
385 case QGRHanaDataTypes::WVarChar:
386 case QGRHanaDataTypes::WLongVarChar:
387 field.SetType(isArray() ? OFTStringList : OFTString);
388 break;
389 case QGRHanaDataTypes::Date:
390 case QGRHanaDataTypes::TypeDate:
391 field.SetType(OFTDate);
392 break;
393 case QGRHanaDataTypes::Time:
394 case QGRHanaDataTypes::TypeTime:
395 field.SetType(OFTTime);
396 break;
397 case QGRHanaDataTypes::Timestamp:
398 case QGRHanaDataTypes::TypeTimestamp:
399 field.SetType(OFTDateTime);
400 break;
401 case QGRHanaDataTypes::Binary:
402 case QGRHanaDataTypes::VarBinary:
403 case QGRHanaDataTypes::LongVarBinary:
404 case QGRHanaDataTypes::RealVector:
405 field.SetType(OFTBinary);
406 break;
407 default:
408 break;
409 }
410
411 field.SetWidth(typeInfo.width);
412 field.SetPrecision(typeInfo.precision);
413 }
414
415 } // anonymous namespace
416
417 /************************************************************************/
418 /* OGRHanaTableLayer() */
419 /************************************************************************/
420
421 OGRHanaTableLayer::OGRHanaTableLayer(OGRHanaDataSource *datasource,
422 const char *schemaName,
423 const char *tableName, int update)
424 : OGRHanaLayer(datasource), schemaName_(schemaName), tableName_(tableName),
425 updateMode_(update)
426 {
427 rawQuery_ =
428 "SELECT * FROM " + GetFullTableNameQuoted(schemaName_, tableName_);
429 SetDescription(tableName_.c_str());
430 }
431
432 /************************************************************************/
433 /* ~OGRHanaTableLayer() */
434 /************************************************************************/
435
436 OGRHanaTableLayer::~OGRHanaTableLayer()
437 {
438 FlushPendingBatches(true);
439 }
440
441 /* -------------------------------------------------------------------- */
442 /* Initialize() */
443 /* -------------------------------------------------------------------- */
444
445 OGRErr OGRHanaTableLayer::Initialize()
446 {
447 if (initialized_)
448 return OGRERR_NONE;
449
450 OGRErr err =
451 InitFeatureDefinition(schemaName_, tableName_, rawQuery_, tableName_);
452 if (err != OGRERR_NONE)
453 return err;
454
455 if (fidFieldIndex_ != OGRNullFID)
456 {
457 CPLDebug("HANA", "table %s has FID column %s.", tableName_.c_str(),
458 fidFieldName_.c_str());
459
460 CPLString sql = CPLString().Printf(
461 "SELECT COUNT(*) FROM %s",
462 GetFullTableNameQuoted(schemaName_, tableName_).c_str());
463 odbc::StatementRef stmt = dataSource_->CreateStatement();
464 odbc::ResultSetRef rs = stmt->executeQuery(sql.c_str());
465 allowAutoFIDOnCreateFeature_ =
466 rs->next() ? (*rs->getLong(1) == 0) : false;
467 rs->close();
468 }
469 else
470 {
471 CPLDebug("HANA",
472 "table %s has no FID column, FIDs will not be reliable!",
473 tableName_.c_str());
474
475 allowAutoFIDOnCreateFeature_ = true;
476 }
477
478 return OGRERR_NONE;
479 }
480
481 /* -------------------------------------------------------------------- */
482 /* ExecuteUpdate() */
483 /* -------------------------------------------------------------------- */
484
485 std::pair<OGRErr, std::size_t>
486 OGRHanaTableLayer::ExecuteUpdate(odbc::PreparedStatement &statement,
487 bool withBatch, const char *functionName)
488 {
489 std::size_t ret = 0;
490
491 try
492 {
493 if (withBatch)
494 {
495 if (statement.getBatchDataSize() >= batchSize_)
496 statement.executeBatch();
497 ret = 1;
498 }
499 else
500 {
501 ret = statement.executeUpdate();
502 }
503
504 if (!dataSource_->IsTransactionStarted())
505 dataSource_->Commit();
506 }
507 catch (odbc::Exception &ex)
508 {
509 CPLError(CE_Failure, CPLE_AppDefined, "Failed to execute %s: %s",
510 functionName, ex.what());
511 return {OGRERR_FAILURE, 0};
512 }
513
514 return {OGRERR_NONE, ret};
515 }
516
517 /* -------------------------------------------------------------------- */
518 /* CreateDeleteFeatureStatement() */
519 /* -------------------------------------------------------------------- */
520
521 odbc::PreparedStatementRef OGRHanaTableLayer::CreateDeleteFeatureStatement()
522 {
523 CPLString sql = CPLString().Printf(
524 "DELETE FROM %s WHERE %s = ?",
525 GetFullTableNameQuoted(schemaName_, tableName_).c_str(),
526 QuotedIdentifier(GetFIDColumn()).c_str());
527 return dataSource_->PrepareStatement(sql.c_str());
528 }
529
530 /* -------------------------------------------------------------------- */
531 /* CreateInsertFeatureStatement() */
532 /* -------------------------------------------------------------------- */
533
534 odbc::PreparedStatementRef
535 OGRHanaTableLayer::CreateInsertFeatureStatement(bool withFID)
536 {
537 std::vector<CPLString> columns;
538 std::vector<CPLString> values;
539 bool hasArray = false;
540 for (const AttributeColumnDescription &clmDesc : attrColumns_)
541 {
542 if (clmDesc.isFeatureID && !withFID)
543 {
544 if (clmDesc.isAutoIncrement)
545 continue;
546 }
547
548 columns.push_back(QuotedIdentifier(clmDesc.name));
549 values.push_back(
550 GetParameterValue(clmDesc.type, clmDesc.typeName, clmDesc.isArray));
551 if (clmDesc.isArray)
552 hasArray = true;
553 }
554
555 for (const GeometryColumnDescription &geomClmDesc : geomColumns_)
556 {
557 columns.push_back(QuotedIdentifier(geomClmDesc.name));
558 values.push_back("ST_GeomFromWKB(? , " +
559 std::to_string(geomClmDesc.srid) + ")");
560 }
561
562 if (hasArray && !parseFunctionsChecked_)
563 {
564 // Create helper functions if needed.
565 if (!dataSource_->ParseArrayFunctionsExist(schemaName_.c_str()))
566 dataSource_->CreateParseArrayFunctions(schemaName_.c_str());
567 parseFunctionsChecked_ = true;
568 }
569
570 const CPLString sql = CPLString().Printf(
571 "INSERT INTO %s (%s) VALUES(%s)",
572 GetFullTableNameQuoted(schemaName_, tableName_).c_str(),
573 JoinStrings(columns, ", ").c_str(), JoinStrings(values, ", ").c_str());
574
575 return dataSource_->PrepareStatement(sql.c_str());
576 }
577
578 /* -------------------------------------------------------------------- */
579 /* CreateUpdateFeatureStatement() */
580 /* -------------------------------------------------------------------- */
581
582 odbc::PreparedStatementRef OGRHanaTableLayer::CreateUpdateFeatureStatement()
583 {
584 std::vector<CPLString> values;
585 values.reserve(attrColumns_.size());
586 bool hasArray = false;
587
588 for (const AttributeColumnDescription &clmDesc : attrColumns_)
589 {
590 if (clmDesc.isFeatureID)
591 {
592 if (clmDesc.isAutoIncrement)
593 continue;
594 }
595 values.push_back(
596 QuotedIdentifier(clmDesc.name) + " = " +
597 GetParameterValue(clmDesc.type, clmDesc.typeName, clmDesc.isArray));
598 if (clmDesc.isArray)
599 hasArray = true;
600 }
601
602 for (const GeometryColumnDescription &geomClmDesc : geomColumns_)
603 {
604 values.push_back(QuotedIdentifier(geomClmDesc.name) + " = " +
605 "ST_GeomFromWKB(?, " +
606 std::to_string(geomClmDesc.srid) + ")");
607 }
608
609 if (hasArray && !parseFunctionsChecked_)
610 {
611 // Create helper functions if needed.
612 if (!dataSource_->ParseArrayFunctionsExist(schemaName_.c_str()))
613 dataSource_->CreateParseArrayFunctions(schemaName_.c_str());
614 parseFunctionsChecked_ = true;
615 }
616
617 const CPLString sql = CPLString().Printf(
618 "UPDATE %s SET %s WHERE %s = ?",
619 GetFullTableNameQuoted(schemaName_, tableName_).c_str(),
620 JoinStrings(values, ", ").c_str(),
621 QuotedIdentifier(GetFIDColumn()).c_str());
622
623 return dataSource_->PrepareStatement(sql.c_str());
624 }
625
626 /* -------------------------------------------------------------------- */
627 /* ResetPreparedStatements() */
628 /* -------------------------------------------------------------------- */
629
630 void OGRHanaTableLayer::ResetPreparedStatements()
631 {
632 if (!currentIdentityValueStmt_.isNull())
633 currentIdentityValueStmt_ = nullptr;
634 if (!insertFeatureStmtWithFID_.isNull())
635 insertFeatureStmtWithFID_ = nullptr;
636 if (!insertFeatureStmtWithoutFID_.isNull())
637 insertFeatureStmtWithoutFID_ = nullptr;
638 if (!deleteFeatureStmt_.isNull())
639 deleteFeatureStmt_ = nullptr;
640 if (!updateFeatureStmt_.isNull())
641 updateFeatureStmt_ = nullptr;
642 }
643
644 /************************************************************************/
645 /* SetStatementParameters() */
646 /************************************************************************/
647
648 OGRErr OGRHanaTableLayer::SetStatementParameters(
649 odbc::PreparedStatement &statement, OGRFeature *feature, bool newFeature,
650 bool withFID, const char *functionName)
651 {
652 OGRHanaFeatureReader featReader(*feature);
653
654 unsigned short paramIndex = 0;
655 int fieldIndex = -1;
656 for (const AttributeColumnDescription &clmDesc : attrColumns_)
657 {
658 if (clmDesc.isFeatureID)
659 {
660 if (!withFID && clmDesc.isAutoIncrement)
661 continue;
662
663 ++paramIndex;
664
665 switch (clmDesc.type)
666 {
667 case QGRHanaDataTypes::Integer:
668 if (feature->GetFID() == OGRNullFID)
669 statement.setInt(paramIndex, odbc::Int());
670 else
671 {
672 if (std::numeric_limits<std::int32_t>::min() >
673 feature->GetFID() ||
674 std::numeric_limits<std::int32_t>::max() <
675 feature->GetFID())
676 {
677 CPLError(CE_Failure, CPLE_AppDefined,
678 "%s: Feature id with value %s cannot "
679 "be stored in a column of type INTEGER",
680 functionName,
681 std::to_string(feature->GetFID()).c_str());
682 return OGRERR_FAILURE;
683 }
684
685 statement.setInt(paramIndex,
686 odbc::Int(static_cast<std::int32_t>(
687 feature->GetFID())));
688 }
689 break;
690 case QGRHanaDataTypes::BigInt:
691 if (feature->GetFID() == OGRNullFID)
692 statement.setLong(paramIndex, odbc::Long());
693 else
694 statement.setLong(paramIndex,
695 odbc::Long(static_cast<std::int64_t>(
696 feature->GetFID())));
697 break;
698 default:
699 CPLError(CE_Failure, CPLE_AppDefined,
700 "%s: Unexpected type ('%s') in the field "
701 "'%s'",
702 functionName, std::to_string(clmDesc.type).c_str(),
703 clmDesc.name.c_str());
704 return OGRERR_FAILURE;
705 }
706 continue;
707 }
708 else
709 ++paramIndex;
710
711 ++fieldIndex;
712
713 switch (clmDesc.type)
714 {
715 case QGRHanaDataTypes::Bit:
716 case QGRHanaDataTypes::Boolean:
717 statement.setBoolean(paramIndex,
718 featReader.GetFieldAsBoolean(fieldIndex));
719 break;
720 case QGRHanaDataTypes::TinyInt:
721 if (clmDesc.isArray)
722 statement.setString(
723 paramIndex, featReader.GetFieldAsIntArray(fieldIndex));
724 else
725 statement.setByte(paramIndex,
726 featReader.GetFieldAsByte(fieldIndex));
727 break;
728 case QGRHanaDataTypes::SmallInt:
729 if (clmDesc.isArray)
730 statement.setString(
731 paramIndex, featReader.GetFieldAsIntArray(fieldIndex));
732 else
733 statement.setShort(paramIndex,
734 featReader.GetFieldAsShort(fieldIndex));
735 break;
736 case QGRHanaDataTypes::Integer:
737 if (clmDesc.isArray)
738 statement.setString(
739 paramIndex, featReader.GetFieldAsIntArray(fieldIndex));
740 else
741 statement.setInt(paramIndex,
742 featReader.GetFieldAsInt(fieldIndex));
743 break;
744 case QGRHanaDataTypes::BigInt:
745 if (clmDesc.isArray)
746 statement.setString(
747 paramIndex,
748 featReader.GetFieldAsBigIntArray(fieldIndex));
749 else
750 statement.setLong(paramIndex,
751 featReader.GetFieldAsLong(fieldIndex));
752 break;
753 case QGRHanaDataTypes::Float:
754 case QGRHanaDataTypes::Real:
755 if (clmDesc.isArray)
756 statement.setString(
757 paramIndex, featReader.GetFieldAsRealArray(fieldIndex));
758 else
759 statement.setFloat(paramIndex,
760 featReader.GetFieldAsFloat(fieldIndex));
761 break;
762 case QGRHanaDataTypes::Double:
763 if (clmDesc.isArray)
764 statement.setString(
765 paramIndex,
766 featReader.GetFieldAsDoubleArray(fieldIndex));
767 else
768 statement.setDouble(
769 paramIndex, featReader.GetFieldAsDouble(fieldIndex));
770 break;
771 case QGRHanaDataTypes::Decimal:
772 case QGRHanaDataTypes::Numeric:
773 if ((!feature->IsFieldSet(fieldIndex) ||
774 feature->IsFieldNull(fieldIndex)) &&
775 feature->GetFieldDefnRef(fieldIndex)->GetDefault() ==
776 nullptr)
777 statement.setDecimal(paramIndex, odbc::Decimal());
778 else
779 statement.setDouble(
780 paramIndex, featReader.GetFieldAsDouble(fieldIndex));
781 break;
782 case QGRHanaDataTypes::Char:
783 case QGRHanaDataTypes::VarChar:
784 case QGRHanaDataTypes::LongVarChar:
785 if (clmDesc.isArray)
786 statement.setString(
787 paramIndex,
788 featReader.GetFieldAsStringArray(fieldIndex));
789 else
790 statement.setString(paramIndex,
791 featReader.GetFieldAsString(
792 fieldIndex, clmDesc.length));
793 break;
794 case QGRHanaDataTypes::WChar:
795 case QGRHanaDataTypes::WVarChar:
796 case QGRHanaDataTypes::WLongVarChar:
797 if (clmDesc.isArray)
798 statement.setString(
799 paramIndex,
800 featReader.GetFieldAsStringArray(fieldIndex));
801 else
802 statement.setString(paramIndex,
803 featReader.GetFieldAsNString(
804 fieldIndex, clmDesc.length));
805 break;
806 case QGRHanaDataTypes::Binary:
807 case QGRHanaDataTypes::VarBinary:
808 case QGRHanaDataTypes::LongVarBinary:
809 case QGRHanaDataTypes::RealVector:
810 {
811 Binary bin = featReader.GetFieldAsBinary(fieldIndex);
812 statement.setBytes(paramIndex, bin.data, bin.size);
813 }
814 break;
815 case QGRHanaDataTypes::DateTime:
816 case QGRHanaDataTypes::TypeDate:
817 statement.setDate(paramIndex,
818 featReader.GetFieldAsDate(fieldIndex));
819 break;
820 case QGRHanaDataTypes::Time:
821 case QGRHanaDataTypes::TypeTime:
822 statement.setTime(paramIndex,
823 featReader.GetFieldAsTime(fieldIndex));
824 break;
825 case QGRHanaDataTypes::Timestamp:
826 case QGRHanaDataTypes::TypeTimestamp:
827 statement.setTimestamp(
828 paramIndex, featReader.GetFieldAsTimestamp(fieldIndex));
829 break;
830 }
831 }
832
833 for (std::size_t i = 0; i < geomColumns_.size(); ++i)
834 {
835 ++paramIndex;
836 Binary wkb{nullptr, 0};
837 OGRErr err = GetGeometryWkb(feature, static_cast<int>(i), wkb);
838 if (OGRERR_NONE != err)
839 return err;
840 statement.setBytes(paramIndex, wkb.data, wkb.size);
841 }
842
843 if (!newFeature)
844 {
845 ++paramIndex;
846
847 statement.setLong(paramIndex, odbc::Long(static_cast<std::int64_t>(
848 feature->GetFID())));
849 }
850
851 return OGRERR_NONE;
852 }
853
854 /* -------------------------------------------------------------------- */
855 /* DropTable() */
856 /* -------------------------------------------------------------------- */
857
858 OGRErr OGRHanaTableLayer::DropTable()
859 {
860 CPLString sql =
861 "DROP TABLE " + GetFullTableNameQuoted(schemaName_, tableName_);
862 try
863 {
864 dataSource_->ExecuteSQL(sql.c_str());
865 CPLDebug("HANA", "Dropped table %s.", GetName());
866 }
867 catch (const odbc::Exception &ex)
868 {
869 CPLError(CE_Failure, CPLE_AppDefined, "Unable to delete layer '%s': %s",
870 tableName_.c_str(), ex.what());
871 return OGRERR_FAILURE;
872 }
873
874 return OGRERR_NONE;
875 }
876
877 /* -------------------------------------------------------------------- */
878 /* ExecutePendingBatches() */
879 /* -------------------------------------------------------------------- */
880
881 OGRErr OGRHanaTableLayer::ExecutePendingBatches(BatchOperation op)
882 {
883 auto hasFlag = [op](BatchOperation flag) { return (op & flag) == flag; };
884
885 try
886 {
887 if (!deleteFeatureStmt_.isNull() &&
888 deleteFeatureStmt_->getBatchDataSize() > 0 &&
889 hasFlag(BatchOperation::DELETE))
890 deleteFeatureStmt_->executeBatch();
891 if (!insertFeatureStmtWithFID_.isNull() &&
892 insertFeatureStmtWithFID_->getBatchDataSize() > 0 &&
893 hasFlag(BatchOperation::INSERT))
894 insertFeatureStmtWithFID_->executeBatch();
895 if (!insertFeatureStmtWithoutFID_.isNull() &&
896 insertFeatureStmtWithoutFID_->getBatchDataSize() > 0 &&
897 hasFlag(BatchOperation::INSERT))
898 insertFeatureStmtWithoutFID_->executeBatch();
899 if (!updateFeatureStmt_.isNull() &&
900 updateFeatureStmt_->getBatchDataSize() > 0 &&
901 hasFlag(BatchOperation::UPDATE))
902 updateFeatureStmt_->executeBatch();
903
904 return OGRERR_NONE;
905 }
906 catch (const odbc::Exception &ex)
907 {
908 ClearBatches();
909
910 CPLError(CE_Failure, CPLE_AppDefined,
911 "Failed to execute batch commands: %s", ex.what());
912 return OGRERR_FAILURE;
913 }
914 }
915
916 /* -------------------------------------------------------------------- */
917 /* FlushPendingBatches() */
918 /* -------------------------------------------------------------------- */
919
920 void OGRHanaTableLayer::FlushPendingBatches(bool commit)
921 {
922 if (!HasPendingBatches())
923 return;
924
925 OGRErr err = ExecutePendingBatches(BatchOperation::ALL);
926 if (OGRERR_NONE == err && commit && !dataSource_->IsTransactionStarted())
927 dataSource_->Commit();
928 }
929
930 /* -------------------------------------------------------------------- */
931 /* HasPendingBatches() */
932 /* -------------------------------------------------------------------- */
933
934 bool OGRHanaTableLayer::HasPendingBatches() const
935 {
936 return (!deleteFeatureStmt_.isNull() &&
937 deleteFeatureStmt_->getBatchDataSize() > 0) ||
938 (!insertFeatureStmtWithFID_.isNull() &&
939 insertFeatureStmtWithFID_->getBatchDataSize() > 0) ||
940 (!insertFeatureStmtWithoutFID_.isNull() &&
941 insertFeatureStmtWithoutFID_->getBatchDataSize() > 0) ||
942 (!updateFeatureStmt_.isNull() &&
943 updateFeatureStmt_->getBatchDataSize() > 0);
944 }
945
946 /* -------------------------------------------------------------------- */
947 /* GetColumnTypeInfo() */
948 /* -------------------------------------------------------------------- */
949
950 ColumnTypeInfo
951 OGRHanaTableLayer::GetColumnTypeInfo(const OGRFieldDefn &field) const
952 {
953 for (const auto &clmType : customColumnDefs_)
954 {
955 if (EQUAL(clmType.name.c_str(), field.GetNameRef()))
956 return ParseColumnTypeInfo(clmType.typeDef);
957 }
958
959 switch (field.GetType())
960 {
961 case OFTInteger:
962 if (preservePrecision_ && field.GetWidth() > 10)
963 {
964 return {"DECIMAL", QGRHanaDataTypes::Decimal, field.GetWidth(),
965 0};
966 }
967 else
968 {
969 if (field.GetSubType() == OFSTBoolean)
970 return {"BOOLEAN", QGRHanaDataTypes::Boolean,
971 field.GetWidth(), 0};
972 else if (field.GetSubType() == OFSTInt16)
973 return {"SMALLINT", QGRHanaDataTypes::SmallInt,
974 field.GetWidth(), 0};
975 }
976 return {"INTEGER", QGRHanaDataTypes::Integer, field.GetWidth(), 0};
977
978 case OFTInteger64:
979 if (preservePrecision_ && field.GetWidth() > 20)
980 {
981 return {"DECIMAL", QGRHanaDataTypes::Decimal, field.GetWidth(),
982 0};
983 }
984 return {"BIGINT", QGRHanaDataTypes::BigInt, field.GetWidth(), 0};
985
986 case OFTReal:
987 if (preservePrecision_ && field.GetWidth() != 0)
988 {
989 return {"DECIMAL", QGRHanaDataTypes::Decimal, field.GetWidth(),
990 field.GetPrecision()};
991 }
992 else
993 {
994 if (field.GetSubType() == OFSTFloat32)
995 return {"REAL", QGRHanaDataTypes::Real, field.GetWidth(),
996 field.GetPrecision()};
997 }
998 return {"DOUBLE", QGRHanaDataTypes::Double, field.GetWidth(),
999 field.GetPrecision()};
1000 case OFTString:
1001 if (field.GetWidth() == 0 || !preservePrecision_)
1002 {
1003 int width = static_cast<int>(defaultStringSize_);
1004 return {"NVARCHAR", QGRHanaDataTypes::WLongVarChar, width, 0};
1005 }
1006 else
1007 {
1008 if (field.GetWidth() >= 1 && field.GetWidth() <= 5000)
1009 return {"NVARCHAR", QGRHanaDataTypes::WLongVarChar,
1010 field.GetWidth(), 0};
1011 }
1012 return {"NCLOB", QGRHanaDataTypes::WLongVarChar, 0, 0};
1013 case OFTBinary:
1014 if (field.GetWidth() >= 1 && field.GetWidth() <= 5000)
1015 return {"VARBINARY", QGRHanaDataTypes::VarBinary,
1016 field.GetWidth(), 0};
1017 return {"BLOB", QGRHanaDataTypes::LongVarBinary, field.GetWidth(),
1018 0};
1019 case OFTDate:
1020 return {"DATE", QGRHanaDataTypes::TypeDate, field.GetWidth(), 0};
1021 case OFTTime:
1022 return {"TIME", QGRHanaDataTypes::TypeTime, field.GetWidth(), 0};
1023 case OFTDateTime:
1024 return {"TIMESTAMP", QGRHanaDataTypes::TypeTimestamp,
1025 field.GetWidth(), 0};
1026 case OFTIntegerList:
1027 if (field.GetSubType() == OGRFieldSubType::OFSTInt16)
1028 return {"ARRAY", QGRHanaDataTypes::SmallInt, field.GetWidth(),
1029 0};
1030 return {"ARRAY", QGRHanaDataTypes::Integer, field.GetWidth(), 0};
1031 case OFTInteger64List:
1032 return {"ARRAY", QGRHanaDataTypes::BigInt, field.GetWidth(), 0};
1033 case OFTRealList:
1034 if (field.GetSubType() == OGRFieldSubType::OFSTFloat32)
1035 return {"ARRAY", QGRHanaDataTypes::Real, field.GetWidth(), 0};
1036 return {"ARRAY", QGRHanaDataTypes::Double, field.GetWidth(), 0};
1037 case OFTStringList:
1038 return {"ARRAY", QGRHanaDataTypes::WVarChar, 512, 0};
1039 default:
1040 break;
1041 }
1042
1043 return {"", QGRHanaDataTypes::Unknown, 0, 0};
1044 }
1045
1046 /* -------------------------------------------------------------------- */
1047 /* GetGeometryWkb() */
1048 /* -------------------------------------------------------------------- */
1049 OGRErr OGRHanaTableLayer::GetGeometryWkb(OGRFeature *feature, int fieldIndex,
1050 Binary &binary)
1051 {
1052 OGRGeometry *geom = feature->GetGeomFieldRef(fieldIndex);
1053 if (geom == nullptr || !IsGeometryTypeSupported(geom->getIsoGeometryType()))
1054 return OGRERR_NONE;
1055
1056 // Rings must be closed, otherwise HANA throws an exception
1057 geom->closeRings();
1058 std::size_t size = static_cast<std::size_t>(geom->WkbSize());
1059 EnsureBufferCapacity(size);
1060 unsigned char *data = reinterpret_cast<unsigned char *>(dataBuffer_.data());
1061 OGRErr err = geom->exportToWkb(OGRwkbByteOrder::wkbNDR, data,
1062 OGRwkbVariant::wkbVariantIso);
1063 if (OGRERR_NONE == err)
1064 {
1065 binary.data = data;
1066 binary.size = size;
1067 }
1068 return err;
1069 }
1070
1071 /************************************************************************/
1072 /* IGetExtent() */
1073 /************************************************************************/
1074
1075 OGRErr OGRHanaTableLayer::IGetExtent(int geomField, OGREnvelope *extent,
1076 bool force)
1077 {
1078 if (geomField >= 0 && geomField < GetLayerDefn()->GetGeomFieldCount())
1079 {
1080 FlushPendingBatches(false);
1081 }
1082
1083 return OGRHanaLayer::IGetExtent(geomField, extent, force);
1084 }
1085
1086 /************************************************************************/
1087 /* GetFeatureCount() */
1088 /************************************************************************/
1089
1090 GIntBig OGRHanaTableLayer::GetFeatureCount(int force)
1091 {
1092 FlushPendingBatches(false);
1093
1094 return OGRHanaLayer::GetFeatureCount(force);
1095 }
1096
1097 /************************************************************************/
1098 /* ResetReading() */
1099 /************************************************************************/
1100
1101 void OGRHanaTableLayer::ResetReading()
1102 {
1103 FlushPendingBatches(false);
1104
1105 if (OGRNullFID != fidFieldIndex_ && nextFeatureId_ > 0)
1106 allowAutoFIDOnCreateFeature_ = false;
1107
1108 OGRHanaLayer::ResetReading();
1109 }
1110
1111 /************************************************************************/
1112 /* TestCapability() */
1113 /************************************************************************/
1114
1115 int OGRHanaTableLayer::TestCapability(const char *capabilities) const
1116 {
1117 if (EQUAL(capabilities, OLCRandomRead))
1118 {
1119 const_cast<OGRHanaTableLayer *>(this)->EnsureInitialized();
1120 return fidFieldIndex_ != OGRNullFID;
1121 }
1122 if (EQUAL(capabilities, OLCFastFeatureCount))
1123 return TRUE;
1124 if (EQUAL(capabilities, OLCFastSpatialFilter))
1125 {
1126 const_cast<OGRHanaTableLayer *>(this)->EnsureInitialized();
1127 return !geomColumns_.empty();
1128 }
1129 if (EQUAL(capabilities, OLCFastGetExtent))
1130 {
1131 const_cast<OGRHanaTableLayer *>(this)->EnsureInitialized();
1132 return IsFastExtentAvailable();
1133 }
1134 if (EQUAL(capabilities, OLCCreateField))
1135 return updateMode_;
1136 if (EQUAL(capabilities, OLCCreateGeomField) ||
1137 EQUAL(capabilities, ODsCCreateGeomFieldAfterCreateLayer))
1138 return updateMode_;
1139 if (EQUAL(capabilities, OLCDeleteField))
1140 return updateMode_;
1141 if (EQUAL(capabilities, OLCDeleteFeature))
1142 {
1143 const_cast<OGRHanaTableLayer *>(this)->EnsureInitialized();
1144 return updateMode_ && fidFieldIndex_ != OGRNullFID;
1145 }
1146 if (EQUAL(capabilities, OLCAlterFieldDefn))
1147 return updateMode_;
1148 if (EQUAL(capabilities, OLCRandomWrite))
1149 return updateMode_;
1150 if (EQUAL(capabilities, OLCMeasuredGeometries))
1151 return TRUE;
1152 if (EQUAL(capabilities, OLCSequentialWrite))
1153 return updateMode_;
1154 if (EQUAL(capabilities, OLCTransactions))
1155 return updateMode_;
1156 if (EQUAL(capabilities, OLCStringsAsUTF8))
1157 return TRUE;
1158
1159 return FALSE;
1160 }
1161
1162 /************************************************************************/
1163 /* ICreateFeature() */
1164 /************************************************************************/
1165
1166 OGRErr OGRHanaTableLayer::ICreateFeature(OGRFeature *feature)
1167 {
1168 if (!updateMode_)
1169 {
1170 CPLError(CE_Failure, CPLE_NotSupported, UNSUPPORTED_OP_READ_ONLY,
1171 "CreateFeature");
1172 return OGRERR_FAILURE;
1173 }
1174
1175 if (nullptr == feature)
1176 {
1177 CPLError(CE_Failure, CPLE_AppDefined,
1178 "NULL pointer to OGRFeature passed to CreateFeature().");
1179 return OGRERR_FAILURE;
1180 }
1181
1182 EnsureInitialized();
1183
1184 OGRErr err =
1185 ExecutePendingBatches(BatchOperation::DELETE | BatchOperation::UPDATE);
1186 if (OGRERR_NONE != err)
1187 return err;
1188
1189 bool hasFID = feature->GetFID() != OGRNullFID;
1190 if (hasFID && OGRNullFID != fidFieldIndex_)
1191 allowAutoFIDOnCreateFeature_ = false;
1192
1193 if (!hasFID && allowAutoFIDOnCreateFeature_)
1194 {
1195 feature->SetFID(nextFeatureId_++);
1196 hasFID = true;
1197 }
1198
1199 bool useBatch = hasFID && dataSource_->IsTransactionStarted();
1200
1201 try
1202 {
1203 odbc::PreparedStatementRef &stmt =
1204 hasFID ? insertFeatureStmtWithFID_ : insertFeatureStmtWithoutFID_;
1205
1206 if (stmt.isNull())
1207 {
1208 stmt = CreateInsertFeatureStatement(hasFID);
1209 if (stmt.isNull())
1210 return OGRERR_FAILURE;
1211 }
1212
1213 err = SetStatementParameters(*stmt, feature, true, hasFID,
1214 "CreateFeature");
1215 if (OGRERR_NONE != err)
1216 return err;
1217
1218 if (useBatch)
1219 stmt->addBatch();
1220
1221 auto ret = ExecuteUpdate(*stmt, useBatch, "CreateFeature");
1222
1223 err = ret.first;
1224 if (OGRERR_NONE != err)
1225 return err;
1226
1227 if (!hasFID && OGRNullFID != fidFieldIndex_)
1228 {
1229 const CPLString sql = CPLString().Printf(
1230 "SELECT CURRENT_IDENTITY_VALUE() \"current identity value\" "
1231 "FROM %s",
1232 GetFullTableNameQuoted(schemaName_, tableName_).c_str());
1233
1234 if (currentIdentityValueStmt_.isNull())
1235 {
1236 currentIdentityValueStmt_ =
1237 dataSource_->PrepareStatement(sql.c_str());
1238 if (currentIdentityValueStmt_.isNull())
1239 return OGRERR_FAILURE;
1240 }
1241
1242 odbc::ResultSetRef rsIdentity =
1243 currentIdentityValueStmt_->executeQuery();
1244 if (rsIdentity->next())
1245 {
1246 odbc::Long id = rsIdentity->getLong(1);
1247 if (!id.isNull())
1248 feature->SetFID(static_cast<GIntBig>(*id));
1249 }
1250 rsIdentity->close();
1251 }
1252
1253 return err;
1254 }
1255 catch (const std::exception &ex)
1256 {
1257 CPLError(CE_Failure, CPLE_NotSupported, "Unable to create feature: %s",
1258 ex.what());
1259 return OGRERR_FAILURE;
1260 }
1261 return OGRERR_NONE;
1262 }
1263
1264 /************************************************************************/
1265 /* DeleteFeature() */
1266 /************************************************************************/
1267
1268 OGRErr OGRHanaTableLayer::DeleteFeature(GIntBig nFID)
1269 {
1270 if (!updateMode_)
1271 {
1272 CPLError(CE_Failure, CPLE_NotSupported, UNSUPPORTED_OP_READ_ONLY,
1273 "DeleteFeature");
1274 return OGRERR_FAILURE;
1275 }
1276
1277 if (nFID == OGRNullFID)
1278 {
1279 CPLError(CE_Failure, CPLE_AppDefined,
1280 "DeleteFeature(" CPL_FRMT_GIB
1281 ") failed. Unable to delete features "
1282 "in tables without\n a recognised FID column.",
1283 nFID);
1284 return OGRERR_FAILURE;
1285 }
1286
1287 if (OGRNullFID == fidFieldIndex_)
1288 {
1289 CPLError(CE_Failure, CPLE_AppDefined,
1290 "DeleteFeature(" CPL_FRMT_GIB
1291 ") failed. Unable to delete features "
1292 "in tables without\n a recognised FID column.",
1293 nFID);
1294 return OGRERR_FAILURE;
1295 }
1296
1297 EnsureInitialized();
1298
1299 if (deleteFeatureStmt_.isNull())
1300 {
1301 deleteFeatureStmt_ = CreateDeleteFeatureStatement();
1302 if (deleteFeatureStmt_.isNull())
1303 return OGRERR_FAILURE;
1304 }
1305
1306 OGRErr err =
1307 ExecutePendingBatches(BatchOperation::INSERT | BatchOperation::UPDATE);
1308 if (OGRERR_NONE != err)
1309 return err;
1310
1311 deleteFeatureStmt_->setLong(1, odbc::Long(static_cast<std::int64_t>(nFID)));
1312 bool withBatch = dataSource_->IsTransactionStarted();
1313 if (withBatch)
1314 deleteFeatureStmt_->addBatch();
1315
1316 auto ret = ExecuteUpdate(*deleteFeatureStmt_, withBatch, "DeleteFeature");
1317 return (OGRERR_NONE == ret.first && ret.second != 1)
1318 ? OGRERR_NON_EXISTING_FEATURE
1319 : ret.first;
1320 }
1321
1322 /************************************************************************/
1323 /* ISetFeature() */
1324 /************************************************************************/
1325
1326 OGRErr OGRHanaTableLayer::ISetFeature(OGRFeature *feature)
1327 {
1328 if (!updateMode_)
1329 {
1330 CPLError(CE_Failure, CPLE_NotSupported, UNSUPPORTED_OP_READ_ONLY,
1331 "SetFeature");
1332 return OGRERR_FAILURE;
1333 }
1334
1335 if (nullptr == feature)
1336 {
1337 CPLError(CE_Failure, CPLE_AppDefined,
1338 "NULL pointer to OGRFeature passed to SetFeature().");
1339 return OGRERR_FAILURE;
1340 }
1341
1342 if (feature->GetFID() == OGRNullFID)
1343 {
1344 CPLError(CE_Failure, CPLE_AppDefined,
1345 "FID required on features given to SetFeature().");
1346 return OGRERR_FAILURE;
1347 }
1348
1349 if (OGRNullFID == fidFieldIndex_)
1350 {
1351 CPLError(CE_Failure, CPLE_AppDefined,
1352 "Unable to update features in tables without\n"
1353 "a recognised FID column.");
1354 return OGRERR_FAILURE;
1355 }
1356
1357 EnsureInitialized();
1358
1359 if (updateFeatureStmt_.isNull())
1360 {
1361 updateFeatureStmt_ = CreateUpdateFeatureStatement();
1362 if (updateFeatureStmt_.isNull())
1363 return OGRERR_FAILURE;
1364 }
1365
1366 if (OGRNullFID != fidFieldIndex_)
1367 allowAutoFIDOnCreateFeature_ = false;
1368
1369 OGRErr err =
1370 ExecutePendingBatches(BatchOperation::DELETE | BatchOperation::INSERT);
1371 if (OGRERR_NONE != err)
1372 return err;
1373
1374 try
1375 {
1376 err = SetStatementParameters(*updateFeatureStmt_, feature, false, false,
1377 "SetFeature");
1378
1379 if (OGRERR_NONE != err)
1380 return err;
1381
1382 bool withBatch = dataSource_->IsTransactionStarted();
1383 if (withBatch)
1384 updateFeatureStmt_->addBatch();
1385
1386 auto ret = ExecuteUpdate(*updateFeatureStmt_, withBatch, "SetFeature");
1387 return (OGRERR_NONE == ret.first && ret.second != 1)
1388 ? OGRERR_NON_EXISTING_FEATURE
1389 : ret.first;
1390 }
1391 catch (const std::exception &ex)
1392 {
1393 CPLError(CE_Failure, CPLE_NotSupported, "Unable to create feature: %s",
1394 ex.what());
1395 return OGRERR_FAILURE;
1396 }
1397 }
1398
1399 /************************************************************************/
1400 /* CreateField() */
1401 /************************************************************************/
1402
1403 OGRErr OGRHanaTableLayer::CreateField(const OGRFieldDefn *srsField,
1404 int approxOK)
1405 {
1406 if (!updateMode_)
1407 {
1408 CPLError(CE_Failure, CPLE_NotSupported, UNSUPPORTED_OP_READ_ONLY,
1409 "CreateField");
1410 return OGRERR_FAILURE;
1411 }
1412
1413 if (srsField->GetNameRef() == nullptr)
1414 {
1415 CPLError(CE_Failure, CPLE_AppDefined, "Field name cannot be NULL");
1416 return OGRERR_FAILURE;
1417 }
1418
1419 EnsureInitialized();
1420
1421 OGRFieldDefn dstField(srsField);
1422
1423 if (launderColumnNames_)
1424 {
1425 auto nameRes = dataSource_->LaunderName(dstField.GetNameRef());
1426 if (nameRes.first != OGRERR_NONE)
1427 return nameRes.first;
1428 dstField.SetName(nameRes.second.c_str());
1429 }
1430
1431 if (fidFieldIndex_ != OGRNullFID &&
1432 EQUAL(dstField.GetNameRef(), GetFIDColumn()) &&
1433 dstField.GetType() != OFTInteger && dstField.GetType() != OFTInteger64)
1434 {
1435 CPLError(CE_Failure, CPLE_AppDefined, "Wrong field type for %s",
1436 dstField.GetNameRef());
1437 return OGRERR_FAILURE;
1438 }
1439
1440 ColumnTypeInfo columnTypeInfo = GetColumnTypeInfo(dstField);
1441 CPLString columnDef = GetColumnDefinition(columnTypeInfo);
1442
1443 if (columnTypeInfo.type == QGRHanaDataTypes::Unknown)
1444 {
1445 if (columnTypeInfo.name.empty())
1446 return OGRERR_FAILURE;
1447
1448 if (approxOK)
1449 {
1450 dstField.SetDefault(nullptr);
1451 CPLError(CE_Warning, CPLE_NotSupported,
1452 "Unable to create field %s with type %s on HANA layers. "
1453 "Creating as VARCHAR.",
1454 dstField.GetNameRef(),
1455 OGRFieldDefn::GetFieldTypeName(dstField.GetType()));
1456 columnTypeInfo.name = "VARCHAR";
1457 columnTypeInfo.width = static_cast<int>(defaultStringSize_);
1458 columnDef = "VARCHAR(" + std::to_string(defaultStringSize_) + ")";
1459 }
1460 else
1461 {
1462 CPLError(CE_Failure, CPLE_NotSupported,
1463 "Unable to create field %s with type %s on HANA layers.",
1464 dstField.GetNameRef(),
1465 OGRFieldDefn::GetFieldTypeName(dstField.GetType()));
1466
1467 return OGRERR_FAILURE;
1468 }
1469 }
1470
1471 CPLString clmClause =
1472 QuotedIdentifier(dstField.GetNameRef()) + " " + columnDef;
1473 if (!dstField.IsNullable())
1474 clmClause += " NOT NULL";
1475 if (dstField.GetDefault() != nullptr && !dstField.IsDefaultDriverSpecific())
1476 {
1477 if (IsArrayField(dstField.GetType()) ||
1478 columnTypeInfo.type == QGRHanaDataTypes::LongVarBinary ||
1479 columnTypeInfo.type == QGRHanaDataTypes::RealVector)
1480 {
1481 CPLError(
1482 CE_Failure, CPLE_NotSupported,
1483 "Default value cannot be created on column of data type %s: "
1484 "%s.",
1485 columnTypeInfo.name.c_str(), dstField.GetNameRef());
1486
1487 return OGRERR_FAILURE;
1488 }
1489
1490 clmClause +=
1491 CPLString().Printf(" DEFAULT %s", GetColumnDefaultValue(dstField));
1492 }
1493
1494 FlushPendingBatches(false);
1495
1496 const CPLString sql = CPLString().Printf(
1497 "ALTER TABLE %s ADD(%s)",
1498 GetFullTableNameQuoted(schemaName_, tableName_).c_str(),
1499 clmClause.c_str());
1500
1501 try
1502 {
1503 dataSource_->ExecuteSQL(sql.c_str());
1504 }
1505 catch (const odbc::Exception &ex)
1506 {
1507 CPLError(CE_Failure, CPLE_AppDefined,
1508 "Failed to execute create attribute field %s: %s",
1509 dstField.GetNameRef(), ex.what());
1510 return OGRERR_FAILURE;
1511 }
1512
1513 // columnTypeInfo might contain a different definition due to custom column
1514 // types
1515 SetFieldDefn(dstField, columnTypeInfo);
1516
1517 AttributeColumnDescription clmDesc;
1518 clmDesc.name = dstField.GetNameRef();
1519 clmDesc.type = columnTypeInfo.type;
1520 clmDesc.typeName = columnTypeInfo.name;
1521 clmDesc.isArray = IsArrayField(dstField.GetType());
1522 clmDesc.length = columnTypeInfo.width;
1523 clmDesc.isNullable = dstField.IsNullable();
1524 clmDesc.isAutoIncrement = false; // TODO
1525 clmDesc.scale = static_cast<unsigned short>(columnTypeInfo.precision);
1526 clmDesc.precision = static_cast<unsigned short>(columnTypeInfo.width);
1527 if (dstField.GetDefault() != nullptr)
1528 clmDesc.defaultValue = dstField.GetDefault();
1529
1530 attrColumns_.push_back(std::move(clmDesc));
1531 featureDefn_->AddFieldDefn(&dstField);
1532
1533 ColumnsChanged();
1534
1535 return OGRERR_NONE;
1536 }
1537
1538 /************************************************************************/
1539 /* CreateGeomField() */
1540 /************************************************************************/
1541
1542 OGRErr OGRHanaTableLayer::CreateGeomField(const OGRGeomFieldDefn *geomField,
1543 int)
1544 {
1545 if (!updateMode_)
1546 {
1547 CPLError(CE_Failure, CPLE_AppDefined, UNSUPPORTED_OP_READ_ONLY,
1548 "CreateGeomField");
1549 return OGRERR_FAILURE;
1550 }
1551
1552 if (!IsGeometryTypeSupported(geomField->GetType()))
1553 {
1554 CPLError(CE_Failure, CPLE_NotSupported,
1555 "Geometry field '%s' in layer '%s' has unsupported type %s",
1556 geomField->GetNameRef(), tableName_.c_str(),
1557 OGRGeometryTypeToName(geomField->GetType()));
1558 return OGRERR_FAILURE;
1559 }
1560
1561 EnsureInitialized();
1562
1563 if (featureDefn_->GetGeomFieldIndex(geomField->GetNameRef()) >= 0)
1564 {
1565 CPLError(
1566 CE_Failure, CPLE_AppDefined,
1567 "CreateGeomField() called with an already existing field name: %s",
1568 geomField->GetNameRef());
1569 return OGRERR_FAILURE;
1570 }
1571
1572 FlushPendingBatches(false);
1573
1574 int srid = dataSource_->GetSrsId(geomField->GetSpatialRef());
1575 if (srid == UNDETERMINED_SRID)
1576 {
1577 CPLError(CE_Failure, CPLE_AppDefined,
1578 "Unable to determine the srs-id for field name: %s",
1579 geomField->GetNameRef());
1580 return OGRERR_FAILURE;
1581 }
1582
1583 CPLString clmName(geomField->GetNameRef());
1584 if (launderColumnNames_)
1585 {
1586 auto nameRes = dataSource_->LaunderName(geomField->GetNameRef());
1587 if (nameRes.first != OGRERR_NONE)
1588 return nameRes.first;
1589 clmName.swap(nameRes.second);
1590 }
1591
1592 if (clmName.empty())
1593 clmName = FindGeomFieldName(*featureDefn_);
1594
1595 CPLString sql = CPLString().Printf(
1596 "ALTER TABLE %s ADD(%s ST_GEOMETRY(%d))",
1597 GetFullTableNameQuoted(schemaName_, tableName_).c_str(),
1598 QuotedIdentifier(clmName).c_str(), srid);
1599
1600 try
1601 {
1602 dataSource_->ExecuteSQL(sql.c_str());
1603 }
1604 catch (const odbc::Exception &ex)
1605 {
1606 CPLError(CE_Failure, CPLE_AppDefined,
1607 "Failed to execute CreateGeomField() with field name '%s': %s",
1608 geomField->GetNameRef(), ex.what());
1609 return OGRERR_FAILURE;
1610 }
1611
1612 auto newGeomField = std::make_unique<OGRGeomFieldDefn>(
1613 clmName.c_str(), geomField->GetType());
1614 newGeomField->SetNullable(geomField->IsNullable());
1615 newGeomField->SetSpatialRef(geomField->GetSpatialRef());
1616 geomColumns_.push_back({newGeomField->GetNameRef(), newGeomField->GetType(),
1617 srid, newGeomField->IsNullable() == TRUE});
1618 featureDefn_->AddGeomFieldDefn(std::move(newGeomField));
1619
1620 ColumnsChanged();
1621
1622 return OGRERR_NONE;
1623 }
1624
1625 /************************************************************************/
1626 /* DeleteField() */
1627 /************************************************************************/
1628
1629 OGRErr OGRHanaTableLayer::DeleteField(int field)
1630 {
1631 if (!updateMode_)
1632 {
1633 CPLError(CE_Failure, CPLE_NotSupported, UNSUPPORTED_OP_READ_ONLY,
1634 "DeleteField");
1635 return OGRERR_FAILURE;
1636 }
1637
1638 if (field < 0 || field >= featureDefn_->GetFieldCount())
1639 {
1640 CPLError(CE_Failure, CPLE_NotSupported, "Field index is out of range");
1641 return OGRERR_FAILURE;
1642 }
1643
1644 EnsureInitialized();
1645
1646 FlushPendingBatches(false);
1647
1648 CPLString clmName = featureDefn_->GetFieldDefn(field)->GetNameRef();
1649 CPLString sql = CPLString().Printf(
1650 "ALTER TABLE %s DROP (%s)",
1651 GetFullTableNameQuoted(schemaName_, tableName_).c_str(),
1652 QuotedIdentifier(clmName).c_str());
1653
1654 try
1655 {
1656 dataSource_->ExecuteSQL(sql.c_str());
1657 }
1658 catch (const odbc::Exception &ex)
1659 {
1660 CPLError(CE_Failure, CPLE_AppDefined, "Failed to drop column %s: %s",
1661 clmName.c_str(), ex.what());
1662 return OGRERR_FAILURE;
1663 }
1664
1665 auto it = std::find_if(attrColumns_.begin(), attrColumns_.end(),
1666 [&](const AttributeColumnDescription &cd)
1667 { return cd.name == clmName; });
1668 attrColumns_.erase(it);
1669 OGRErr ret = featureDefn_->DeleteFieldDefn(field);
1670
1671 ColumnsChanged();
1672
1673 return ret;
1674 }
1675
1676 /************************************************************************/
1677 /* AlterFieldDefn() */
1678 /************************************************************************/
1679
1680 OGRErr OGRHanaTableLayer::AlterFieldDefn(int field, OGRFieldDefn *newFieldDefn,
1681 int flagsIn)
1682 {
1683 if (!updateMode_)
1684 {
1685 CPLError(CE_Failure, CPLE_NotSupported, UNSUPPORTED_OP_READ_ONLY,
1686 "AlterFieldDefn");
1687 return OGRERR_FAILURE;
1688 }
1689
1690 EnsureInitialized();
1691
1692 if (field < 0 || field >= featureDefn_->GetFieldCount())
1693 {
1694 CPLError(CE_Failure, CPLE_NotSupported, "Field index is out of range");
1695 return OGRERR_FAILURE;
1696 }
1697
1698 OGRFieldDefn *fieldDefn = featureDefn_->GetFieldDefn(field);
1699
1700 int columnDescIdx = -1;
1701 for (size_t i = 0; i < attrColumns_.size(); ++i)
1702 {
1703 if (EQUAL(attrColumns_[i].name.c_str(), fieldDefn->GetNameRef()))
1704 {
1705 columnDescIdx = static_cast<int>(i);
1706 break;
1707 }
1708 }
1709
1710 if (columnDescIdx < 0)
1711 {
1712 CPLError(CE_Failure, CPLE_NotSupported,
1713 "Column description cannot be found");
1714 return OGRERR_FAILURE;
1715 }
1716
1717 CPLString clmName(newFieldDefn->GetNameRef());
1718
1719 if (launderColumnNames_)
1720 {
1721 auto nameRes = dataSource_->LaunderName(newFieldDefn->GetNameRef());
1722 if (nameRes.first != OGRERR_NONE)
1723 return nameRes.first;
1724 clmName.swap(nameRes.second);
1725 }
1726
1727 FlushPendingBatches(false);
1728
1729 ColumnTypeInfo columnTypeInfo = GetColumnTypeInfo(*newFieldDefn);
1730
1731 try
1732 {
1733 if ((flagsIn & ALTER_NAME_FLAG) &&
1734 (strcmp(fieldDefn->GetNameRef(), newFieldDefn->GetNameRef()) != 0))
1735 {
1736 CPLString sql = CPLString().Printf(
1737 "RENAME COLUMN %s TO %s",
1738 GetFullColumnNameQuoted(schemaName_, tableName_,
1739 fieldDefn->GetNameRef())
1740 .c_str(),
1741 QuotedIdentifier(clmName).c_str());
1742 dataSource_->ExecuteSQL(sql.c_str());
1743 }
1744
1745 if ((flagsIn & ALTER_TYPE_FLAG) ||
1746 (flagsIn & ALTER_WIDTH_PRECISION_FLAG) ||
1747 (flagsIn & ALTER_NULLABLE_FLAG) || (flagsIn & ALTER_DEFAULT_FLAG))
1748 {
1749 CPLString fieldTypeDef = GetColumnDefinition(columnTypeInfo);
1750 if ((flagsIn & ALTER_NULLABLE_FLAG) &&
1751 fieldDefn->IsNullable() != newFieldDefn->IsNullable())
1752 {
1753 if (fieldDefn->IsNullable())
1754 fieldTypeDef += " NULL";
1755 else
1756 fieldTypeDef += " NOT NULL";
1757 }
1758
1759 if ((flagsIn & ALTER_DEFAULT_FLAG) &&
1760 ((fieldDefn->GetDefault() == nullptr &&
1761 newFieldDefn->GetDefault() != nullptr) ||
1762 (fieldDefn->GetDefault() != nullptr &&
1763 newFieldDefn->GetDefault() == nullptr) ||
1764 (fieldDefn->GetDefault() != nullptr &&
1765 newFieldDefn->GetDefault() != nullptr &&
1766 strcmp(fieldDefn->GetDefault(), newFieldDefn->GetDefault()) !=
1767 0)))
1768 {
1769 fieldTypeDef +=
1770 " DEFAULT " + ((fieldDefn->GetType() == OFTString)
1771 ? Literal(newFieldDefn->GetDefault())
1772 : CPLString(newFieldDefn->GetDefault()));
1773 }
1774
1775 CPLString sql = CPLString().Printf(
1776 "ALTER TABLE %s ALTER(%s %s)",
1777 GetFullTableNameQuoted(schemaName_, tableName_).c_str(),
1778 QuotedIdentifier(clmName).c_str(), fieldTypeDef.c_str());
1779
1780 dataSource_->ExecuteSQL(sql.c_str());
1781 }
1782 }
1783 catch (const odbc::Exception &ex)
1784 {
1785 CPLError(CE_Failure, CPLE_AppDefined, "Failed to alter field %s: %s",
1786 fieldDefn->GetNameRef(), ex.what());
1787 return OGRERR_FAILURE;
1788 }
1789
1790 // Update field definition and column description
1791
1792 AttributeColumnDescription &attrClmDesc = attrColumns_[columnDescIdx];
1793
1794 if (flagsIn & ALTER_NAME_FLAG)
1795 {
1796 fieldDefn->SetName(clmName.c_str());
1797 attrClmDesc.name.assign(clmName.c_str());
1798 }
1799
1800 if (flagsIn & ALTER_TYPE_FLAG)
1801 {
1802 fieldDefn->SetSubType(OFSTNone);
1803 fieldDefn->SetType(newFieldDefn->GetType());
1804 fieldDefn->SetSubType(newFieldDefn->GetSubType());
1805 attrClmDesc.isArray = IsArrayField(newFieldDefn->GetType());
1806 attrClmDesc.type = columnTypeInfo.type;
1807 attrClmDesc.typeName = columnTypeInfo.name;
1808 }
1809
1810 if (flagsIn & ALTER_WIDTH_PRECISION_FLAG)
1811 {
1812 fieldDefn->SetWidth(newFieldDefn->GetWidth());
1813 fieldDefn->SetPrecision(newFieldDefn->GetPrecision());
1814 attrClmDesc.length = newFieldDefn->GetWidth();
1815 attrClmDesc.scale = newFieldDefn->GetWidth();
1816 attrClmDesc.precision = newFieldDefn->GetPrecision();
1817 }
1818
1819 if (flagsIn & ALTER_NULLABLE_FLAG)
1820 {
1821 fieldDefn->SetNullable(newFieldDefn->IsNullable());
1822 attrClmDesc.isNullable = newFieldDefn->IsNullable();
1823 }
1824
1825 if (flagsIn & ALTER_DEFAULT_FLAG)
1826 {
1827 fieldDefn->SetDefault(newFieldDefn->GetDefault());
1828 attrClmDesc.name.assign(newFieldDefn->GetDefault());
1829 }
1830
1831 ColumnsChanged();
1832
1833 return OGRERR_NONE;
1834 }
1835
1836 /************************************************************************/
1837 /* ClearBatches() */
1838 /************************************************************************/
1839
1840 void OGRHanaTableLayer::ClearBatches()
1841 {
1842 if (!insertFeatureStmtWithFID_.isNull())
1843 insertFeatureStmtWithFID_->clearBatch();
1844 if (!insertFeatureStmtWithoutFID_.isNull())
1845 insertFeatureStmtWithoutFID_->clearBatch();
1846 if (!updateFeatureStmt_.isNull())
1847 updateFeatureStmt_->clearBatch();
1848 }
1849
1850 /************************************************************************/
1851 /* ColumnsChanged() */
1852 /************************************************************************/
1853
1854 void OGRHanaTableLayer::ColumnsChanged()
1855 {
1856 ClearQueryStatement();
1857 ResetReading();
1858 ResetPreparedStatements();
1859 }
1860
1861 /************************************************************************/
1862 /* SetCustomColumnTypes() */
1863 /************************************************************************/
1864
1865 void OGRHanaTableLayer::SetCustomColumnTypes(const char *columnTypes)
1866 {
1867 if (columnTypes == nullptr)
1868 return;
1869
1870 const char *ptr = columnTypes;
1871 const char *start = ptr;
1872 while (*ptr != '\0')
1873 {
1874 if (*ptr == '(')
1875 {
1876 // Skip commas inside brackets, for example decimal(20,5)
1877 while (*ptr != '\0' && *ptr != ')')
1878 {
1879 ++ptr;
1880 }
1881 }
1882
1883 ++ptr;
1884
1885 if (*ptr == ',' || *ptr == '\0')
1886 {
1887 std::size_t len = static_cast<std::size_t>(ptr - start);
1888 const char *sep = std::find(start, start + len, '=');
1889 if (sep != nullptr)
1890 {
1891 std::size_t pos = static_cast<std::size_t>(sep - start);
1892 customColumnDefs_.push_back(
1893 {CPLString(start, pos),
1894 CPLString(start + pos + 1, len - pos - 1)});
1895 }
1896
1897 start = ptr + 1;
1898 }
1899 }
1900 }
1901
1902 /************************************************************************/
1903 /* StartTransaction() */
1904 /************************************************************************/
1905
1906 OGRErr OGRHanaTableLayer::StartTransaction()
1907 {
1908 return dataSource_->StartTransaction();
1909 }
1910
1911 /************************************************************************/
1912 /* CommitTransaction() */
1913 /************************************************************************/
1914
1915 OGRErr OGRHanaTableLayer::CommitTransaction()
1916 {
1917 if (HasPendingBatches())
1918 {
1919 OGRErr err = ExecutePendingBatches(BatchOperation::ALL);
1920 if (OGRERR_NONE != err)
1921 return err;
1922 }
1923
1924 return dataSource_->CommitTransaction();
1925 }
1926
1927 /************************************************************************/
1928 /* RollbackTransaction() */
1929 /************************************************************************/
1930
1931 OGRErr OGRHanaTableLayer::RollbackTransaction()
1932 {
1933 ClearBatches();
1934 return dataSource_->RollbackTransaction();
1935 }
1936
1937 } // namespace OGRHANA