dbaccess/source/filter/hsqldb/fbcreateparser.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include "fbcreateparser.hxx"
  21 #include "columndef.hxx"
  22 #include "utils.hxx"
  23
  24 #include <com/sun/star/sdbc/DataType.hpp>
  25
  26 #include <rtl/ustrbuf.hxx>
  27
  28 using namespace css::sdbc;
  29
  30 namespace
  31 {
  32 void lcl_appendWithSpace(OUStringBuffer& sBuff, const OUString& sStr)
  33 {
  34     sBuff.append(" ");
  35     sBuff.append(sStr);
  36 }
  37
  38 OUString lcl_DataTypetoFbTypeName(sal_Int32 eType)
  39 {
  40     switch (eType)
  41     {
  42         case DataType::CHAR:
  43         case DataType::BINARY:
  44             return "CHAR";
  45         case DataType::VARCHAR:
  46         case DataType::VARBINARY:
  47             return "VARCHAR";
  48         case DataType::TINYINT: // no such type in Firebird
  49         case DataType::SMALLINT:
  50             return "SMALLINT";
  51         case DataType::INTEGER:
  52             return "INTEGER";
  53         case DataType::BIGINT:
  54             return "BIGINT";
  55         case DataType::NUMERIC:
  56             return "NUMERIC";
  57         case DataType::DECIMAL:
  58             return "DECIMAL";
  59         case DataType::BOOLEAN:
  60             return "BOOLEAN";
  61         case DataType::LONGVARCHAR:
  62         case DataType::LONGVARBINARY:
  63         case DataType::CLOB:
  64         case DataType::BLOB:
  65         case DataType::OTHER:
  66             return "BLOB";
  67         case DataType::DATE:
  68             return "DATE";
  69         case DataType::TIME:
  70             return "TIME";
  71         case DataType::TIMESTAMP:
  72             return "TIMESTAMP";
  73         case DataType::DOUBLE:
  74         case DataType::REAL:
  75             return "DOUBLE PRECISION";
  76         case DataType::FLOAT:
  77             return "FLOAT";
  78         default:
  79             assert(false);
  80             return OUString();
  81     }
  82 }
  83
  84 OUString lcl_getTypeModifier(sal_Int32 eType)
  85 {
  86     // TODO bind -9546 magic number to a common definition. It also appears
  87     // in the connectivity module.
  88     switch (eType)
  89     {
  90         case DataType::CLOB:
  91         case DataType::LONGVARCHAR:
  92             return "SUB_TYPE 1";
  93         case DataType::LONGVARBINARY:
  94             return "SUB_TYPE -9546";
  95         case DataType::BINARY:
  96         case DataType::VARBINARY:
  97             return "CHARACTER SET OCTETS";
  98         default:
  99             return OUString();
 100     }
 101 }
 102
 103 } // unnamed namespace
 104
 105 namespace dbahsql
 106 {
 107 void FbCreateStmtParser::appendPrimaryKeyPart(OUStringBuffer& rSql) const
 108 {
 109     const std::vector<OUString>& sPrimaryKeys = getPrimaryKeys();
 110     if (sPrimaryKeys.empty())
 111         return; // no primary key specified
 112
 113     rSql.append(",");
 114     rSql.append("PRIMARY KEY(");
 115     auto it = sPrimaryKeys.cbegin();
 116     while (it != sPrimaryKeys.end())
 117     {
 118         rSql.append(*it);
 119         ++it;
 120         if (it != sPrimaryKeys.end())
 121             rSql.append(",");
 122     }
 123
 124     rSql.append(")"); // end of primary key declaration
 125 }
 126
 127 void FbCreateStmtParser::ensureProperTableLengths() const
 128 {
 129     const std::vector<ColumnDefinition>& rColumns = getColumnDef();
 130     for (const auto& col : rColumns)
 131         utils::ensureFirebirdTableLength(col.getName());
 132 }
 133
 134 OUString FbCreateStmtParser::compose() const
 135 {
 136     ensureProperTableLengths();
 137     OUStringBuffer sSql(128);
 138     sSql.append("CREATE TABLE ");
 139     sSql.append(getTableName());
 140
 141     lcl_appendWithSpace(sSql, "("); // column declaration
 142     auto& rColumns = getColumnDef();
 143     auto columnIter = rColumns.cbegin();
 144     while (columnIter != rColumns.end())
 145     {
 146         lcl_appendWithSpace(sSql, columnIter->getName());
 147         lcl_appendWithSpace(sSql, lcl_DataTypetoFbTypeName(columnIter->getDataType()));
 148
 149         std::vector<sal_Int32> params{ columnIter->getParams() };
 150
 151         if (columnIter->getDataType() == DataType::NUMERIC
 152             || columnIter->getDataType() == DataType::DECIMAL)
 153         {
 154             // max precision is 18 here
 155             if (params.at(0) > 18)
 156                 params[0] = 18;
 157         }
 158
 159         // Firebird SQL dialect does not like parameters for TIMESTAMP
 160         if (!params.empty() && columnIter->getDataType() != DataType::TIMESTAMP)
 161         {
 162             sSql.append("(");
 163             auto it = params.cbegin();
 164             while (it != params.end())
 165             {
 166                 sSql.append(OUString::number(*it));
 167                 ++it;
 168                 if (it != params.end())
 169                     sSql.append(",");
 170             }
 171             sSql.append(")"); // end of param declaration
 172         }
 173
 174         // special modifiers here, based on type (e.g. charset, subtype)
 175         OUString sModifier = lcl_getTypeModifier(columnIter->getDataType());
 176         if (!sModifier.isEmpty())
 177             lcl_appendWithSpace(sSql, sModifier);
 178
 179         if (columnIter->isAutoIncremental())
 180         {
 181             lcl_appendWithSpace(sSql, "GENERATED BY DEFAULT AS IDENTITY (START WITH ");
 182
 183             // start with 0:
 184             // HSQLDB: first value will be 0.
 185             // Firebird: first value will be 1.
 186             sSql.append(columnIter->getStartValue() - 1);
 187             sSql.append(")");
 188         }
 189         else if (!columnIter->isNullable())
 190             lcl_appendWithSpace(sSql, "NOT NULL");
 191
 192         if (columnIter->isCaseInsensitive())
 193             lcl_appendWithSpace(sSql, "COLLATE UNICODE_CI");
 194
 195         const OUString& sDefaultVal = columnIter->getDefault();
 196         if (!sDefaultVal.isEmpty())
 197         {
 198             lcl_appendWithSpace(sSql, "DEFAULT");
 199             if (sDefaultVal.equalsIgnoreAsciiCase("NOW"))
 200                 lcl_appendWithSpace(sSql, "\'NOW\'"); // Fb likes it single quoted
 201             else
 202                 lcl_appendWithSpace(sSql, sDefaultVal);
 203         }
 204
 205         ++columnIter;
 206         if (columnIter != rColumns.end())
 207             sSql.append(",");
 208     }
 209
 210     appendPrimaryKeyPart(sSql);
 211
 212     sSql.append(")"); // end of column declaration
 213     return sSql.makeStringAndClear();
 214 }
 215
 216 } // dbahsql
 217
 218 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */