connectivity/source/inc/file/FStringFunctions.hxx

   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 #pragma once
  21
  22 #include <file/fcode.hxx>
  23
  24 namespace connectivity::file
  25     {
  26         /** UCASE(str)
  27             UPPER(str)
  28                 Returns the string str with all characters changed to uppercase according to the current character set mapping (the default is ISO-8859-1 Latin1):
  29
  30             > SELECT UCASE('Hej');
  31                     -> 'HEJ'
  32
  33         */
  34         class OOp_Upper : public OUnaryOperator
  35         {
  36         protected:
  37             virtual ORowSetValue operate(const ORowSetValue& lhs) const override;
  38         };
  39
  40         /** LCASE(str)
  41             LOWER(str)
  42                 Returns the string str with all characters changed to lowercase according to the current character set mapping (the default is ISO-8859-1 Latin1):
  43
  44             > SELECT LCASE('QUADRATICALLY');
  45                     -> 'quadratically'
  46
  47         */
  48         class OOp_Lower : public OUnaryOperator
  49         {
  50         protected:
  51             virtual ORowSetValue operate(const ORowSetValue& lhs) const override;
  52         };
  53
  54         /** ASCII(str)
  55             Returns the ASCII code value of the leftmost character of the string str. Returns 0 if str is the empty string. Returns NULL if str is NULL:
  56
  57             > SELECT ASCII('2');
  58                 -> 50
  59             > SELECT ASCII(2);
  60                 -> 50
  61             > SELECT ASCII('dx');
  62                 -> 100
  63
  64         */
  65         class OOp_Ascii : public OUnaryOperator
  66         {
  67         protected:
  68             virtual ORowSetValue operate(const ORowSetValue& lhs) const override;
  69         };
  70
  71         /** LENGTH(str)
  72             OCTET_LENGTH(str)
  73             CHAR_LENGTH(str)
  74             CHARACTER_LENGTH(str)
  75                 Returns the length of the string str:
  76
  77             > SELECT LENGTH('text');
  78                     -> 4
  79             > SELECT OCTET_LENGTH('text');
  80                     -> 4
  81
  82         */
  83         class OOp_CharLength : public OUnaryOperator
  84         {
  85         protected:
  86             virtual ORowSetValue operate(const ORowSetValue& lhs) const override;
  87         };
  88
  89         /** CHAR(N,...)
  90             CHAR() interprets the arguments as integers and returns a string consisting of the characters given by the ASCII code values of those integers. NULL values are skipped:
  91
  92             > SELECT CHAR(ascii('t'),ascii('e'),ascii('s'),ascii('t'));
  93                 -> 'test'
  94             > SELECT CHAR(77,77.3,'77.3');
  95                 -> 'MMM'
  96
  97         */
  98         class OOp_Char : public ONthOperator
  99         {
 100         protected:
 101             virtual ORowSetValue operate(const std::vector<ORowSetValue>& lhs) const override;
 102         };
 103
 104         /** CONCAT(str1,str2,...)
 105             Returns the string that results from concatenating the arguments. Returns NULL if any argument is NULL. May have more than 2 arguments. A numeric argument is converted to the equivalent string form:
 106
 107             > SELECT CONCAT('OO', 'o', 'OO');
 108                 -> 'OOoOO'
 109             > SELECT CONCAT('OO', NULL, 'OO');
 110                 -> NULL
 111             > SELECT CONCAT(14.3);
 112                 -> '14.3'
 113
 114         */
 115         class OOp_Concat : public ONthOperator
 116         {
 117         protected:
 118             virtual ORowSetValue operate(const std::vector<ORowSetValue>& lhs) const override;
 119         };
 120
 121         /** LOCATE(substr,str)
 122             POSITION(substr IN str)
 123             Returns the position of the first occurrence of substring substr in string str. Returns 0 if substr is not in str:
 124
 125             > SELECT LOCATE('bar', 'foobarbar');
 126                     -> 4
 127             > SELECT LOCATE('xbar', 'foobar');
 128                     -> 0
 129             LOCATE(substr,str,pos)
 130             Returns the position of the first occurrence of substring substr in string str, starting at position pos. Returns 0 if substr is not in str:
 131
 132             > SELECT LOCATE('bar', 'foobarbar',5);
 133                 -> 7
 134
 135         */
 136         class OOp_Locate : public ONthOperator
 137         {
 138         protected:
 139             virtual ORowSetValue operate(const std::vector<ORowSetValue>& lhs) const override;
 140         };
 141
 142         /** SUBSTRING(str,pos)
 143             SUBSTRING(str FROM pos)
 144                 Returns a substring from string str starting at position pos:
 145
 146             > SELECT SUBSTRING('Quadratically',5);
 147                     -> 'ratically'
 148             > SELECT SUBSTRING('foobarbar' FROM 4);
 149                     -> 'barbar'
 150             SUBSTRING(str,pos,len)
 151             SUBSTRING(str FROM pos FOR len)
 152                 Returns a substring len characters long from string str, starting at position pos. The variant form that uses FROM is SQL-92 syntax:
 153
 154             > SELECT SUBSTRING('Quadratically',5,6);
 155                     -> 'ratica'
 156
 157         */
 158         class OOp_SubString : public ONthOperator
 159         {
 160         protected:
 161             virtual ORowSetValue operate(const std::vector<ORowSetValue>& lhs) const override;
 162         };
 163
 164         /** LTRIM(str)
 165             Returns the string str with leading space characters removed:
 166
 167             > SELECT LTRIM('  barbar');
 168                 -> 'barbar'
 169
 170         */
 171         class OOp_LTrim : public OUnaryOperator
 172         {
 173         protected:
 174             virtual ORowSetValue operate(const ORowSetValue& lhs) const override;
 175         };
 176
 177         /** RTRIM(str)
 178             Returns the string str with trailing space characters removed:
 179
 180             > SELECT RTRIM('barbar   ');
 181                 -> 'barbar'
 182
 183         */
 184         class OOp_RTrim : public OUnaryOperator
 185         {
 186         protected:
 187             virtual ORowSetValue operate(const ORowSetValue& lhs) const override;
 188         };
 189
 190         /** SPACE(N)
 191             Returns a string consisting of N space characters:
 192
 193             > SELECT SPACE(6);
 194                 -> '      '
 195
 196         */
 197         class OOp_Space : public OUnaryOperator
 198         {
 199         protected:
 200             virtual ORowSetValue operate(const ORowSetValue& lhs) const override;
 201         };
 202
 203         /** REPLACE(str,from_str,to_str)
 204             Returns the string str with all occurrences of the string from_str replaced by the string to_str:
 205
 206             > SELECT REPLACE('www.OOo.com', 'w', 'Ww');
 207                 -> 'WwWwWw.OOo.com'
 208
 209         */
 210         class OOp_Replace : public ONthOperator
 211         {
 212         protected:
 213             virtual ORowSetValue operate(const std::vector<ORowSetValue>& lhs) const override;
 214         };
 215
 216         /** REPEAT(str,count)
 217             Returns a string consisting of the string str repeated count times. If count <= 0, returns an empty string. Returns NULL if str or count are NULL:
 218
 219             > SELECT REPEAT('OOo', 3);
 220                 -> 'OOoOOoOOo'
 221
 222         */
 223         class OOp_Repeat : public OBinaryOperator
 224         {
 225         protected:
 226             virtual ORowSetValue operate(const ORowSetValue& lhs,const ORowSetValue& rhs) const override;
 227         };
 228
 229         /** INSERT(str,pos,len,newstr)
 230             Returns the string str, with the substring beginning at position pos and len characters long replaced by the string newstr:
 231
 232             > SELECT INSERT('Quadratic', 3, 4, 'What');
 233                 -> 'QuWhattic'
 234
 235         */
 236         class OOp_Insert : public ONthOperator
 237         {
 238         protected:
 239             virtual ORowSetValue operate(const std::vector<ORowSetValue>& lhs) const override;
 240         };
 241
 242         /** LEFT(str,len)
 243             Returns the leftmost len characters from the string str:
 244
 245             > SELECT LEFT('foobarbar', 5);
 246                 -> 'fooba'
 247
 248         */
 249         class OOp_Left : public OBinaryOperator
 250         {
 251         protected:
 252             virtual ORowSetValue operate(const ORowSetValue& lhs,const ORowSetValue& rhs) const override;
 253         };
 254
 255         /** RIGHT(str,len)
 256             Returns the rightmost len characters from the string str:
 257
 258             > SELECT RIGHT('foobarbar', 4);
 259                 -> 'rbar'
 260         */
 261         class OOp_Right : public OBinaryOperator
 262         {
 263         protected:
 264             virtual ORowSetValue operate(const ORowSetValue& lhs,const ORowSetValue& rhs) const override;
 265         };
 266
 267 }
 268
 269 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */