FreeAdhocUDF für InterBase und FireBird in deutschin englishen françaisen españolin italianoa português
homeprevious pagecontentnext pagelast page Seite empfehlen • advice website •Forum Mailing-Liste • mailinglist • liste de diffusionwas ich vermisse • what I missed •eMail Kommentar • eMail commentprintsitemap
 
Funktionen enthalten in der FreeAdhocUDF.dll/.so/.dylib :
String-Funktionen 91 Funktionen und 28 Varianten
Erzeugen 10 Funktionen
Bearbeiten 45 Funktionen und 19 Varianten
Umwandlungen 21 Funktionen und 6 Varianten
Vergleichen 3 Funktion
Suchen / Ermitteln 12 Funktionen und 3 Varianten
Von einigen Funktionen gibt es je nach Bedarf Varianten, z.B. von F_LEFT die Variante F_LEFT4 und F_LEFT8.
Diese Varianten unterscheiden sich nur in der Länge des Input- und Output-Strings, z.B.
F_LEFT   -> Input CSTRING(254), Output CSTRING (254)
F_LEFT4 -> Input CSTRING(4096), Output CSTRING(4096)
F_LEFT8 -> Input CSTRING(8190), Output CSTRING(8190)
Diese Varianten können durchaus gleichzeitig und nebeneinander benutzt werden- nur nicht innerhalb eines SQLs.
abFireBird 2 statt 0, '' (Leerstring) oder '17.11.1858' <null>
ab FireBird Version 1.0 kann diese Funktion ersetzt werden
ab FireBird Version 2.0 kann diese Funktion ersetzt werden
ab FireBird Version 2.1 kann diese Funktion ersetzt werden
Output RETURN Mechanismus wenn nicht anderes angegeben: FREE_IT
Die TestSQLs mit NULL funktionieren nur ab FireBird 2
 
String-Funktionen: Erzeugen
F_CRLF kompatibel zu FreeUDFLib, FreeUDFLibC, FreeUDFLib AvERP
Entrypoint crlf UTF-8 kompatibel
Input ohne
Output CSTRING(3) Zeilenabschluß und Zeilenumbruch. Erzeugt die Zeichen  CHR(13)  +  CHR(10)
TestSQL
SELECT 'erste Zeile' || F_CRLF() || 'zweite Zeile' AS ISCORRECT, 'erste Zeile' || F_CRLF() || 'zweite Zeile' FROM RDB$DATABASE;
nach oben • go top •
F_LF Funktion von adhoc
Entrypoint lf UTF-8 kompatibel
Input ohne
Output CSTRING(2) Zeilenumbruch. Erzeugt das Zeichen CHR(10).
Identisch zu F_CHARACTER(10).
TestSQL
SELECT 'ABC' || F_LF() || '123' AS ISCORRECT, 'ABC' || F_LF() || '123' FROM RDB$DATABASE;
nach oben • go top •
F_SPACE kompatibel zu GrUDF
Entrypoint space UTF-8 kompatibel
Input INTEGER Anzahl der Leerzeichen
Output CSTRING(32760) Leerzeichenkette (CHR(32)) mit bestimmter angegebener Anzahl
TestSQL
SELECT F_SPACE(10) || 'x' AS ISCORRECT, F_SPACE(10) || 'x' FROM RDB$DATABASE;
nach oben • go top •
F_NBSP Funktion von adhoc
Entrypoint nbsp nicht UTF-8 kompatibel - benutze U_NBSP
U_NBSP Funktion von adhoc
Entrypoint u_nbsp UTF-8 kompatibel
Input ohne
Output CSTRING(2) Geschützes Leerzeichen (non-braking-space).
Erzeugt das Zeichen CHR(160) bzw. U+00A0
Identisch zu F_CHARACTER(160).
TestSQL
SELECT 'ABC' || F_NBSP() || '123' AS ISCORRECT, 'ABC' || F_NBSP() || '123' FROM RDB$DATABASE;
SELECT 'ABC 123' AS ISCORRECT, 'ABC' || U_NBSP() || '123' FROM RDB$DATABASE;
nach oben • go top •
U_NNBSP Funktion von adhoc
Entrypoint u_nnbsp nur UTF-8
Input ohne
Output CSTRING(2) schmales geschützes Leerzeichen (narrow-non-braking-space).
Erzeugt das Zeichen U+202F
TestSQL
SELECT 'z. B. 123' AS ISCORRECT, 'z.' || F_NNBSP() || 'B. 123' FROM RDB$DATABASE;
nach oben • go top •
F_DQM Funktion von adhoc
Entrypoint dqm UTF-8 kompatibel
Input ohne
Output CSTRING(2) Doppeltes Anführungszeichen (doube-quote-mark). Erzeugt das Zeichen CHR(34)
Identisch zu F_CHARACTER(34).
TestSQL
SELECT 'ABC"123' AS ISCORRECT, 'ABC' || F_DQM() || '123' FROM RDB$DATABASE;
nach oben • go top •
F_SQM Funktion von adhoc
Entrypoint sqm UTF-8 kompatibel
Input ohne
Output CSTRING(2) Einfaches Anführungszeichen (single-quote-mark). Erzeugt das Zeichen CHR(39)
Identisch zu F_CHARACTER(39).
TestSQL
SELECT 'ABC' || F_SQM() || '123' AS ISCORRECT, 'ABC' || F_SQM() || '123' FROM RDB$DATABASE;
nach oben • go top •
F_DSQM Funktion von adhoc
Entrypoint dsqm UTF-8 kompatibel
Input ohne
Output CSTRING(2) ZWEI Einfaches Anführungszeichen (single-quote-mark). Erzeugt zweimal das das Zeichen CHR(39) hintereinander
TestSQL
SELECT 'ABC' || F_DSQM() || '123' AS ISCORRECT, 'ABC' || F_DSQM() || '123' FROM RDB$DATABASE;
nach oben • go top •
F_TAB Funktion von adhoc
Entrypoint tab UTF-8 kompatibel
Input ohne
Output CSTRING(2) Tabulator. Erzeugt das Zeichen CHR(9)
Identisch zu F_CHARACTER(9).
TestSQL
SELECT 'ABC<TAB>123' AS ISCORRECT, 'ABC' || F_TAB() || '123' FROM RDB$DATABASE;
nach oben • go top •
 
String-Funktionen: Bearbeiten
ab ersetzbar durch LEFT
F_LEFT (F_LEFT4, F_LEFT8)
F_BIGLEFT
kompatibel zu FreeUDFLib, FreeUDFLibC, FreeUDFLib AvERP, GrUDF
Entrypoint left nicht UTF-8 kompatibel - benutze U_LEFT(U_LEFT4, U_LEFT8)
U_LEFT (U_LEFT4, U_LEFT8) Funktion von adhoc
Entrypoint u_left UTF-8 kompatibel
Input CSTRING(254)
INTEGER
String der beschnitten werden soll
Länge des auszugebenden Strings
Output CSTRING(254) String beschnitten auf die Anzahl Zeichen von links von Parameter 2
Zählung beginnt bei 1.
TestSQL
SELECT 'Dies i' AS ISCORRECT, F_LEFT('Dies ist ein Test', 6) FROM RDB$DATABASE;
SELECT NULL AS ISCORRECT, F_LEFT(NULL, NULL) FROM RDB$DATABASE;
SELECT 'abcäöüx' AS ISCORRECT, U_LEFT('abcäöüxyz', 7) FROM RDB$DATABASE
SELECT 'abcäöüxyz' AS ISCORRECT, U_LEFT('abcäöüxyz', 20) FROM RDB$DATABASE
SELECT NULL AS ISCORRECT, U_LEFT(NULL, NULL) FROM RDB$DATABASE;
SELECT 'Czech: Císlicový pocítac je zarízení, které zpracovává data' AS ISCORRECT, U_LEFT('Císlicový pocítac je zarízení, které zpracovává data', 250) FROM RDB$DATABASE;
SELECT 'Polish: poniewaz taka definicje komputera spelniaja tez kalkulatory' AS ISCORRECT, U_LEFT('poniewaz taka definicje komputera spelniaja tez kalkulatory', 250) FROM RDB$DATABASE;
SELECT 'Russian: Выполнение поставленных перед ним задач компьютер может' AS ISCORRECT, U_LEFT('Выполнение поставленных перед ним задач компьютер может', 250) FROM RDB$DATABASE;
SELECT 'Greek: Πρακτικά, η Επιστήμη των Υπολογιστών (επίσης Πληροφορική) σχετίζεται' AS ISCORRECT, U_LEFT('Πρακτικά, η Επιστήμη των Υπολογιστών (επίσης Πληροφορική) σχετίζεται', 250) FROM RDB$DATABASE;
SELECT 'という語は元々は算術計算を行う人' AS ISCORRECT, U_LEFT('という語は元々は算術計算を行う人', 250) FROM RDB$DATABASE;
SELECT 'Japanese: という語は' AS ISCORRECT, U_LEFT('という語は元々は算術計算を行う人', 5) FROM RDB$DATABASE;
Achtung - Schreibrichtung von rechts nach links!
SELECT 'Arabic: اساسا يعبر مصطلح "حاسب" عن الشخص الذي يقوم بالحسابات الرقمية و' AS ISCORRECT, U_LEFT('اساسا يعبر مصطلح "حاسب" عن الشخص الذي يقوم بالحسابات الرقمية و', 250) FROM RDB$DATABASE;
SELECT 'Arabic: اساسا' AS ISCORRECT, U_LEFT('اساسا يعبر مصطلح "حاسب" عن الشخص الذي يقوم بالحسابات الرقمية و', 5) FROM RDB$DATABASE;
nach oben • go top •
ab ersetzbar durch SUBSTRING
F_MID (F_MID4, F_MID8)
F_BIGMID
kompatibel zu FreeUDFLib, FreeUDFLibC, FreeUDFLib AvERP
Entrypoint mid nicht UTF-8 kompatibel - benutze U_MID
U_MID (U_MID4, U_MID8) Funktion von adhoc
Entrypoint u_mid UTF-8 kompatibel
F_COPY
kompatibel zu GrUDF
Entrypoint mid1 nicht UTF-8 kompatibel - benutze U_MID
F_STRCOPY Input/Output-kompatibel zu rFunc (SUBSTR, LONGSUBSTR)
Entrypoint strcopy nicht UTF-8 kompatibel - benutze U_MID
Input CSTRING(254)
INTEGER
INTEGER
String der beschnitten werden soll
Position, an der der auszugebende String beginnt
Länge des auszugebenden Strings
Output CSTRING(254) String beginnende bei Position aus Parameter 2 in der Länge von Parameter 3
Zählung beginnt bei F_MID und F_STRCOPY für Parameter 2 bei 0, bei F_COPY für Parameter 2 bei 1!
TestSQL
SELECT 'tag' AS ISCORRECT, F_MID('Geburtstagsparty', 7, 3) FROM RDB$DATABASE;
SELECT 'tag' AS ISCORRECT, F_COPY('Geburtstagsparty', 8, 3) FROM RDB$DATABASE;
SELECT 'tag' AS ISCORRECT, F_STRCOPY('Geburtstagsparty', 7, 3) FROM RDB$DATABASE;
SELECT NULL AS ISCORRECT, F_MID(NULL, NULL, NULL) FROM RDB$DATABASE;
SELECT 'cäöüx' AS ISCORRECT, U_MID('abcäöüxyz', 2, 5) FROM RDB$DATABASE
SELECT NULL AS ISCORRECT, U_MID(NULL, NULL, NULL) FROM RDB$DATABASE;
nach oben • go top •
ab ersetzbar durch RIGHT
F_RIGHT (F_RIGHT4, F_RIGHT8)
F_BIGRIGHT
kompatibel zu FreeUDFLib, FreeUDFLibC, FreeUDFLib AvERP, GrUDF
Entrypoint right nicht UTF-8 kompatibel - benutze U_RIGHT
U_RIGHT (U_RIGHT4, U_RIGHT8) Funktion von adhoc
Entrypoint u_right UTF-8 kompatibel
Input CSTRING(254)
INTEGER
String der beschnitten werden soll
Länge des auszugebenden Strings
Output CSTRING(254) String beschnitten auf die Anzahl Zeichen von rechts von Parameter 2
Zählung beginnt bei 1
TestSQL
SELECT 'n Test' AS ISCORRECT, F_RIGHT('Dies ist ein Test', 6) FROM RDB$DATABASE;
SELECT NULL AS ISCORRECT, F_RIGHT(NULL, NULL) FROM RDB$DATABASE;
SELECT 'cäöüxyz' AS ISCORRECT, U_RIGHT('abcäöüxyz', 7) FROM RDB$DATABASE
SELECT 'abcäöüxyz' AS ISCORRECT, U_RIGHT('abcäöüxyz', 20) FROM RDB$DATABASE
SELECT NULL AS ISCORRECT, U_RIGHT(NULL, NULL) FROM RDB$DATABASE;
nach oben • go top •
ab ersetzbar durch POSITION
F_SUBSTR (F_SUBSTR4, F_SUBSTR8)
F_BIGSUBSTR
kompatibel zu FreeUDFLibC

Entrypoint substr nicht UTF-8 kompatibel - benutze U_SUBSTR
Input CSTRING(8190)
CSTRING(1024)
String 1 in dem die Position von Parameter 2 ermittelt werden soll
String 2 dessen Position in Parameter 1 ermittelt werden soll
Output INTEGER erste Position im String 1 aus, bei der der String 2 beginnt.
F_STRSUB
kompatibel zu FreeUDFLib, FreeUDFLib AvERP, GrUDF
Entrypoint strsub nicht UTF-8 kompatibel - benutze U_SUBSTR
F_STRPOS Input/Output-kompatibel zu rFunc (STRPOS)
Entrypoint strpos nicht UTF-8 kompatibel - benutze U_SUBSTR
Input CSTRING(1024)
CSTRING(8190)
String 1 dessen Position in Parameter 2 ermittelt werden soll
String 2 in dem die Position von Parameter 1 ermittelt werden soll
Output INTEGER erste Position im String 2 aus, bei der der String 1 beginnt.
F_SUBSTR, F_STRSUB etc.: Zählung beginnt bei 0, bei Nichtgefunden -1.
F_STRPOS: Zählung beginnt bei 1, bei Nichtgefunden 0.
Anmerkung:
In der originalen FreeUDFLib (1998 by Gregory Deatz) ist die Reihenfolge der Eingabe-Parameter vertauscht gegenüber den anderen String-Funktionen und vor allem wie in der C-Portierung (1999 by Gregory Deatz) der FreeUDFLibC.
Um nun Kompatibilität für beide Varianten herzustellen, gibt es verschiedene “Entrypoints”, die in dem DECLARE-Script von F_SUBSTR verwendet werden können:
- Für eine Kompatibilität zur (Delphi-)FreeUDFLib, zur FreeUDFLib AvERP und zur GrUDF (die wiederum ihrerseits Kompatible zur Delphi-FreeUDFLib ist) verwendet man den Entrypoint "strsub"
- für eine Kompatibilität zur FreeUDFLibC den Entrypoint "substr".
TestSQL (Version FreeUDFLibC mit Entrypoint substr)
SELECT 9 AS ISCORRECT, F_SUBSTR('Pauline fährt in Urlaub', 'ähr') FROM RDB$DATABASE;
SELECT -1 AS ISCORRECT, F_SUBSTR('Pauline fährt in Urlaub', 'chr') FROM RDB$DATABASE;
SELECT NULL AS ISCORRECT, F_SUBSTR(NULL, NULL) FROM RDB$DATABASE;
SELECT 10 AS ISCORRECT, F_STRPOS('ähr', 'Pauline fährt in Urlaub') FROM RDB$DATABASE;
SELECT 0 AS ISCORRECT, F_STRPOS('chr', 'Pauline fährt in Urlaub') FROM RDB$DATABASE;
TestSQL (Version FreeUDFLib, GrUDF mit Entrypoint strsub)
SELECT 9 AS ISCORRECT, F_SUBSTR('ähr', 'Pauline fährt in Urlaub') FROM RDB$DATABASE;
nach oben • go top •
ab ersetzbar durch POSITION
F_SUBSTRN (F_SUBSTR) Funktion von adhoc
Entrypoint substrnull nicht UTF-8 kompatibel - benutze U_SUBSTR
U_SUBSTR Funktion von adhoc
Entrypoint u_substr UTF-8 kompatibel
Input CSTRING(8190)
CSTRING(1024)
String 1 in dem die Position von Parameter 2 ermittelt werden soll
String 2 dessen Position in Parameter 1 ermittelt werden soll
Output INTEGER erste Position im String 1 aus, bei der der String 2 beginnt.
F_STRSUBN Funktion von adhoc
Entrypoint strsubnull nicht UTF-8 kompatibel - benutze U_SUBSTR
Input CSTRING(1024)
CSTRING(8190)
String 1 dessen Position in Parameter 2 ermittelt werden soll
String 2 in dem die Position von Parameter 1 ermittelt werden soll
Output INTEGER erste Position im String 2 aus, bei der der String 1 beginnt.
Die beiden vorigen Varianten (F_SUBSTR und F_STRSUB) liefern bei Nichtvorkommen des Suchstrings -1. Um nun auch in diesem Fall korrekt ein <null> zu bekommen (und die alte Variante beibehalten zu können), verwendet man den Entrypoint "strsubnull" bzw. "substrnull".
TestSQL (Version FreeUDFLibC mit Entrypoint substrnull)
SELECT NULL AS ISCORRECT, F_SUBSTR('Pauline fährt in Urlaub', 'chr') FROM RDB$DATABASE;
SELECT 9 AS ISCORRECT, U_SUBSTR('Pauline fährt in Urlaub', 'ähr') FROM RDB$DATABASE;
SELECT NULL AS ISCORRECT, U_SUBSTR('Pauline fährt in Urlaub', 'chr') FROM RDB$DATABASE;
SELECT NULL AS ISCORRECT, U_SUBSTR(NULL, NULL) FROM RDB$DATABASE;
SELECT 5 AS ISCORRECT, U_SUBSTR('Выполнение поставленных перед', 'нен') FROM RDB$DATABASE;
nach oben • go top •
F_STRRM            kompatibel zu 
Entrypoint strrm nicht UTF-8 kompatibel - benutze U_STRRM
U_STRRM            Funktion von adhoc
Entrypoint u_strrm UTF-8 kompatibel
Input CSTRING(8190)
INTEGER
String, aus dem eine Stelle entfernt werden soll
Stelle im String, die entfernt werden soll
Output CSTRING(8190) String aus dem ein Zeichen entfernt wurde
Zählung beginnt für Parameter 2 bei 0
TestSQL
SELECT 'ies ist ein Test' AS ISCORRECT, F_STRRM('Dies ist ein Test', 0) FROM RDB$DATABASE;
SELECT NULL AS ISCORRECT, F_STRRM(NULL, NULL) FROM RDB$DATABASE;
SELECT 'ies ist ein Test' AS ISCORRECT, U_STRRM('Dies ist ein Test', 0) FROM RDB$DATABASE;
SELECT 'Выолнение' AS ISCORRECT, U_STRRM('Выполнение', 2) FROM RDB$DATABASE;
nach oben • go top •
F_LTRIM (F_LTRIM4, F_LTRIM8)
F_BIGLTRIM
kompatibel zu FreeUDFLib, FreeUDFLibC, FreeUDFLib AvERP, GrUDF
Input/Output-kompatibel zu rFunc (LTRIM, LONGLTRIM)
Entrypoint ltrim UTF-8 kompatibel
Input CSTRING(8190) String, dessen Leerzeichen zu Beginn entfernt werden sollen
Output CSTRING(8190) String ohne alle einfachen Leerzeichen zu Beginn des Strings
Entfernt nicht die geschützten Leerzeichen (mit <ALT> <255> eingegebene)
TestSQL
SELECT 'Dies ist ein Test' AS ISCORRECT, F_LTRIM('   Dies ist ein Test') FROM RDB$DATABASE;
SELECT NULL AS ISCORRECT, F_LTRIM(NULL) FROM RDB$DATABASE;
nach oben • go top •
ab ersetzbar durch TRIM
F_RTRIM (F_RTRIM4, F_RTRIM8)
F_BIGRTRIM
kompatibel zu FreeUDFLib, FreeUDFLibC, FreeUDFLib AvERP, GrUDF
Input/Output-kompatibel zu rFunc (RTRIM, LONGRTRIM)
Entrypoint rtrim UTF-8 kompatibel
Input CSTRING(8190) String, dessen Leerzeichen am Ende entfernt werden sollen
Output CSTRING(8190) String ohne alle einfachen Leerzeichen am Ende des Strings
Entfernt nicht die geschützten Leerzeichen (mit <ALT> <255> eingegebene)
TestSQL
SELECT 'Dies ist ein Test' AS ISCORRECT, F_STRINGLENGTH(F_RTRIM('Dies ist ein Test   ')) AS ANZ_ZEICHEN, F_RTRIM('Dies ist ein Test   ') FROM RDB$DATABASE;
SELECT NULL AS ISCORRECT, F_STRINGLENGTH(F_RTRIM(NULL)) AS ANZ_ZEICHEN, F_RTRIM(NULL) FROM RDB$DATABASE;
nach oben • go top •
F_LRTRIM (F_LRTRIM4, F_LRTRIM8)
F_BIGLRTRIM  
kompatibel zu FreeUDFLib, FreeUDFLibC, FreeUDFLib AvERP, GrUDF
Input/Output-kompatibel zu rFunc (TRIM, LONGTRIM)
Entrypoint lrtrim UTF-8 kompatibel
Input CSTRING(8190) String, dessen Leerzeichen zu Beginn und am Ende entfernt werden sollen
Output CSTRING(8190) String ohne alle einfachen Leerzeichen zu Beginn und am Ende des Strings.
Entfernt nicht die geschützten Leerzeichen (mit <ALT> <255> eingegebene)
TestSQL
SELECT 'Dies ist ein Test' AS ISCORRECT, F_STRINGLENGTH(F_LRTRIM('  Dies ist ein Test   ')) AS ANZ_ZEICHEN, F_LRTRIM('  Dies ist ein Test   ') FROM RDB$DATABASE;
SELECT NULL AS ISCORRECT, F_STRINGLENGTH(F_LRTRIM(NULL)) AS ANZ_ZEICHEN, F_LRTRIM(NULL) FROM RDB$DATABASE;
nach oben • go top •
ab ersetzbar durch LPAD
F_PADLEFT kompatibel zu FreeUDFLib, FreeUDFLibC, FreeUDFLib AvERP, GrUDF
Entrypoint padleft nicht UTF-8 kompatibel - benutze U_PADLEFT
U_PADLEFT Funktion von adhoc
Entrypoint u_padleft UTF-8 kompatibel
Input CSTRING(4095)
CSTRING(16)
INTEGER
String 1 der mit den Zeichen links aufgefüllt werden soll
String 2 mit dem String 1 aufgefüllt werden soll
Länge des Strings, bis auf die aufgefüllt werden soll
Output CSTRING(4095) String der links mit dem/den Zeichen aus String 2 auf die Gesamtlänge von Zeichen von Parameter 3 aufgefüllt wurde
F_RPADLEFT Input/Output-kompatibel zu rFunc (PADLEFT, LOGPADLEFT)
Entrypoint r_padleft nicht UTF-8 kompatibel - benutze U_PADLEFT
Input CSTRING(4095)
INTEGER
CSTRING(16)
String 1 der mit den Zeichen links aufgefüllt werden soll
Länge des Strings, bis auf die aufgefüllt werden soll
String 2 mit dem String 1 aufgefüllt werden soll
Output CSTRING(4095) String der links mit dem/den Zeichen aus String 3 auf die Gesamtlänge von Zeichen von Parameter 2 aufgefüllt wurde
Werden in String 2 mehr als ein Zeichen eingegeben, beginnt die Auffüllung mit den Zeichen aus String 2 von rechts und bricht ab, wenn die geforderte Anzahl von Gesamtzeichen erreicht ist (s. 2. TestSQL)
TestSQL
SELECT 'XXXDies ist ein Test' AS ISCORRECT, F_PADLEFT('Dies ist ein Test', 'X', 20) FROM RDB$DATABASE;
SELECT 'xXxDies ist ein Test' AS ISCORRECT, F_PADLEFT('Dies ist ein Test', 'Xx', 20) FROM RDB$DATABASE;
SELECT NULL AS ISCORRECT, F_PADLEFT(NULL, NULL, NULL) FROM RDB$DATABASE;
SELECT 'XXXDies ist ein Test' AS ISCORRECT, F_RPADLEFT('Dies ist ein Test', 20, 'X') FROM RDB$DATABASE;
SELECT 'xXxDies ist ein Test' AS ISCORRECT, F_RPADLEFT('Dies ist ein Test', 20, 'Xx') FROM RDB$DATABASE;
SELECT NULL AS ISCORRECT, F_PADLEFT(NULL, NULL, NULL) FROM RDB$DATABASE;
SELECT 'XXXabcäöüxyz' AS ISCORRECT, U_PADLEFT('abcäöüxyz', 'X', 12) FROM RDB$DATABASE;
SELECT 'XxXabcäöüxyz' AS ISCORRECT, U_PADLEFT('abcäöüxyz', 'Xx', 12) FROM RDB$DATABASE;
SELECT NULL AS ISCORRECT, U_PADLEFT(NULL, NULL, NULL) FROM RDB$DATABASE;
nach oben • go top •
ab ersetzbar durch RPAD
F_PADRIGHT kompatibel zu FreeUDFLib, FreeUDFLibC, FreeUDFLib AvERP, GrUDF
Entrypoint padright nicht UTF-8 kompatibel - benutze U_PADRIGHT
U_PADRIGHT Funktion von adhoc
Entrypoint u_padright UTF-8 kompatibel
Input CSTRING(4095)
CSTRING(16)
INTEGER
String 1 der mit den Zeichen rechts aufgefüllt werden soll
String 2 mit dem String 1 aufgefüllt werden soll
Länge des Strings, bis auf die aufgefüllt werden soll
Output CSTRING(4095) String der rechts mit dem/den Zeichen aus String 2 auf die Gesamtlänge von Zeichen von Parameter 3 aufgefüllt wurde
F_RPADRIGHT Input/Output-kompatibel zu rFunc (PADRIGHT, LONGPADRIGHT)
Entrypoint r_padright nicht UTF-8 kompatibel - benutze U_PADRIGHT
Input CSTRING(4095)
INTEGER
CSTRING(16)
String 1 der mit den Zeichen rechts aufgefüllt werden soll
Länge des Strings, bis auf die aufgefüllt werden soll
String 2 mit dem String 1 aufgefüllt werden soll
Output CSTRING(4095) String der rechts mit dem/den Zeichen aus String 3 auf die Gesamtlänge von Zeichen von Parameter 2 aufgefüllt wurde
Werden in String 2 mehr als ein Zeichen eingegeben, beginnt die Auffüllung mit den Zeichen aus String 2 von links und bricht ab, wenn die geforderte Anzahl von Gesamtzeichen erreicht ist (s. 2. TestSQL)
TestSQL
SELECT 'Dies ist ein TestXXX' AS ISCORRECT, F_PADRIGHT('Dies ist ein Test', 'X', 20) FROM RDB$DATABASE;
SELECT 'Dies ist ein TestXxX' AS ISCORRECT, F_PADRIGHT('Dies ist ein Test', 'Xx', 20) FROM RDB$DATABASE;
SELECT NULL AS ISCORRECT, F_PADRIGHT(NULL, NULL, NULL) FROM RDB$DATABASE;
SELECT 'Dies ist ein TestXXX' AS ISCORRECT, F_RPADRIGHT('Dies ist ein Test', 20, 'X') FROM RDB$DATABASE;
SELECT 'Dies ist ein TestXxX' AS ISCORRECT, F_RPADRIGHT('Dies ist ein Test', 20, 'Xx') FROM RDB$DATABASE;
SELECT NULL AS ISCORRECT, F_PADRIGHT(NULL, NULL, NULL) FROM RDB$DATABASE;
SELECT 'abcäöüxyzXXX' AS ISCORRECT, U_PADRIGHT('abcäöüxyz', 'X', 12) FROM RDB$DATABASE;
SELECT 'abcäöüxyzXxX' AS ISCORRECT, U_PADRIGHT('abcäöüxyz', 'Xx', 12) FROM RDB$DATABASE;
SELECT NULL AS ISCORRECT, U_PADRIGHT(NULL, NULL, NULL) FROM RDB$DATABASE;
nach oben • go top •
F_PADCENTER Funktion von adhoc
Entrypoint padcenter nicht UTF-8 kompatibel - benutze U_PADCENTER
U_PADCENTER Funktion von adhoc
Entrypoint u_padcenter UTF-8 kompatibel
Input CSTRING(4095)
CSTRING(16)
INTEGER
String 1 der mit den Zeichen links und rechts aufgefüllt werden soll
String 2 mit dem String 1 aufgefüllt werden soll
Länge des Strings, bis auf die aufgefüllt werden soll
Output CSTRING(4095) String der links und rechts mit dem/den Zeichen aus String 2 auf die Gesamtlänge von Zeichen von Parameter 3 aufgefüllt wurde
Bei “ungeradem” Auffüllen wird immer links ein Zeichen mehr aufgefüllt.
TestSQL
SELECT 'XXDies ist ein TestXX' AS ISCORRECT, F_PADCENTER('Dies ist ein Test', 'X', 21) FROM RDB$DATABASE;
SELECT 'XXDies ist ein TestX' AS ISCORRECT, F_PADCENTER('Dies ist ein Test', 'X', 20) FROM RDB$DATABASE;
SELECT 'XxDies ist ein TestXx' AS ISCORRECT, F_PADCENTER('Dies ist ein Test', 'Xx', 21) FROM RDB$DATABASE;
SELECT 'XxDies ist ein TestX' AS ISCORRECT, F_PADCENTER('Dies ist ein Test', 'Xx', 20) FROM RDB$DATABASE;
SELECT NULL AS ISCORRECT, F_PADCENTER(NULL, NULL, NULL) FROM RDB$DATABASE;
SELECT 'XXabcäöüxyzXX' AS ISCORRECT, U_PADCENTER('abcäöüxyz', 'X', 13) FROM RDB$DATABASE;
SELECT 'XXXabcäöüxyzXX' AS ISCORRECT, U_PADCENTER('abcäöüxyz', 'X', 14) FROM RDB$DATABASE;
SELECT 'XxabcäöüxyzXx' AS ISCORRECT, U_PADCENTER('abcäöüxyz', 'Xx', 13) FROM RDB$DATABASE;
SELECT 'XxXabcäöüxyzXx' AS ISCORRECT, U_PADCENTER('abcäöüxyz', 'Xx', 14) FROM RDB$DATABASE;
SELECT NULL AS ISCORRECT, U_PADCENTER(NULL, NULL, NULL) FROM RDB$DATABASE;
nach oben • go top •
F_LINEWRAP          kompatibel zu FreeUDFLib, FreeUDFLibC, FreeUDFLib AvERP, GrUDF
Entrypoint linewrap nicht UTF-8 kompatibel - benutze U_LINEWRAP
U_LINEWRAP          Funktion von adhoc
Entrypoint u_linewrap UTF-8 kompatibel
Input CSTRING(32760)
INTEGER
INTEGER
String
Startposition
Spaltenbreite
Output CSTRING(32760) alle Wörter des Strings aus, beginnen bei der Startposition, der zusammen nicht länger als die Spaltenbreite sind
Zählung beginnt bei 0.
TestSQL
SELECT  'alle zu einer Geburtstagsparty' AS ISCORRECT, F_LINEWRAP('Wir gehen alle zu einer Geburtstagsparty', 10, 30) FROM RDB$DATABASE;
SELECT  'alle zu einer' AS ISCORRECT, F_LINEWRAP('Wir gehen alle zu einer Geburtstagsparty', 10, 29) FROM RDB$DATABASE;
SELECT  NULL AS ISCORRECT, F_LINEWRAP(NULL, NULL, NULL) FROM RDB$DATABASE;
SELECT  'älle zu einer Gebürtstagspörty' AS ISCORRECT, U_LINEWRAP('Wir gehen älle zu einer Geburtstagsparty', 10, 31) FROM RDB$DATABASE;
SELECT  'alle zu einer Geburtstagsparty' AS ISCORRECT, U_LINEWRAP('Wir gehen alle zu einer Geburtstagsparty', 10, 30) FROM RDB$DATABASE;
SELECT  'alle zu einer' AS ISCORRECT, U_LINEWRAP('Wir gehen alle zu einer Geburtstagsparty', 10, 29) FROM RDB$DATABASE;
SELECT  NULL AS ISCORRECT, U_LINEWRAP(NULL, NULL, NULL) FROM RDB$DATABASE;
nach oben • go top •
ab ersetzbar durch REPLACE
F_REPLACE (F_REPLACE4, ...8)
F_BIGREPLACE
kompatibel zu FreeUDFLibC
Input/Output-kompatibel zu rFunc (STRREPLACE, LONGSTRREPLACE)
Entrypoint replace UTF-8 kompatibel
Input CSTRING(32760)
CSTRING(254)
CSTRING(254)
String, in dem eine Zeichenkette ausgetauscht werden soll
der auszutauschende String
der String der neu gesetzt werden soll
Output CSTRING(32760) String indem Zeichenkette aus Parameter 2 durch Parameter 3 ersetzt wurden
Einfache Version der Funktion F_REPLACESTRING ohne Möglichkeit nur einmal zu ersetzen sowie unabhängig von Groß-/Kleinschreibung auszutauschen.
TestSQL           
SELECT 'Dies ist ein Versuch zwei Versuch drei Versuch vier TEST' AS ISCORRECT, F_REPLACE('Dies ist ein Test zwei Test drei Test vier TEST', 'Test', 'Versuch') FROM RDB$DATABASE;
SELECT 'test' AS ISCORRECT, F_REPLACE('test','','t') FROM RDB$DATABASE;
SELECT NULL AS ISCORRECT, F_REPLACE(NULL, NULL, NULL) FROM RDB$DATABASE;
nach oben • go top •
F_REPLACESTRING (..4, ..8)
F_BIGREPLACESTRING
kompatibel zu FreeUDFLib AvERP, GrUDF
Entrypoint replacestring nicht UTF-8 kompatibel - benutze U_REPLACESTRING
U_REPLACESTRING (..4, ..8)
Funktion von adhoc
Entrypoint u_replacestring UTF-8 kompatibel
Input CSTRING(32760)
CSTRING(254)
CSTRING(254)
INTEGER
INTEGER
String, in dem eine Zeichenkette ausgetauscht werden soll
der auszutauschende String
der String der neu gesetzt werden soll
0 = nur das erste Vorkommen austauschen, 1 = alle Vorkommen austauschen
0 = Groß-/Kleinschreibung berücksichtigen, 1 = nicht berücksichtigen
Output CSTRING(32760) String indem Zeichenkette/n aus Parameter 2 durch Parameter 3 ersetzt wurden
TestSQL           
SELECT 'Dies ist ein Versuch zwei Test drei Test vier TEST' AS ISCORRECT, F_REPLACESTRING('Dies ist ein Test zwei Test drei Test vier TEST', 'Test', 'Versuch', 0, 0) FROM RDB$DATABASE;
SELECT 'Dies ist ein Versuch zwei Test drei Test vier TEST' AS ISCORRECT, F_REPLACESTRING('Dies ist ein Test zwei Test drei Test vier TEST', 'Test', 'Versuch', 0, 1) FROM RDB$DATABASE;
SELECT 'Dies ist ein Versuch zwei Versuch drei Versuch vier TEST' AS ISCORRECT, F_REPLACESTRING('Dies ist ein Test zwei Test drei Test vier TEST', 'Test', 'Versuch', 1, 0) FROM RDB$DATABASE;
SELECT 'Dies ist ein Versuch zwei Versuch drei Versuch vier Versuch' AS ISCORRECT, F_REPLACESTRING('Dies ist ein Test zwei Test drei Test vier TEST', 'Test', 'Versuch', 1, 1) FROM RDB$DATABASE;
SELECT NULL AS ISCORRECT, F_REPLACESTRING(NULL, NULL, NULL, NULL, NULL) FROM RDB$DATABASE;
SELECT 'x123x456' AS ISCORRECT, F_REPLACESTRING('Ä123ä456', 'ä', 'x', 1, 1) FROM RDB$DATABASE;
SELECT 'x123x456' AS ISCORRECT, F_REPLACESTRING('Ä123ä456', 'Ä', 'x', 1, 1) FROM RDB$DATABASE;
SELECT 'x123x456' AS ISCORRECT, U_REPLACESTRING('Ä123ä456', 'ä', 'x', 1, 1) FROM RDB$DATABASE;
SELECT 'x123x456' AS ISCORRECT, U_REPLACESTRING('Ä123ä456', 'Ä', 'x', 1, 1) FROM RDB$DATABASE;
nach oben • go top •
F_CONVERTSYMBOLS Input/Output-kompatibel zu rFunc (CONVERTSYMBOLS, LONGCONVERTSYMBOLS)
Entrypoint convertsymbols nicht UTF-8 kompatibel - benutze U_CONVERTSYMBOLS
U_CONVERTSYMBOLS Funktion von adhoc
Entrypoint u_convertsymbols UTF-8 kompatibel
Input CSTRING(32760)
CSTRING(254)
CSTRING(254)
String in dem Zeichen ausgetauscht werden soll
String 2 mit den einzelnen Zeichen, die ausgetauscht werden sollen
String 3 mit den Zeichen, die die Zeichen an der gleichen Stelle aus String 2 ersetzten sollen
Output CSTRING(32760) String in dem alle einzelnen Zeichen aus String 2 ersetzt wurden
TestSQL           
SELECT '(a+ab)-abc*a+b=c' AS ISCORRECT, F_CONVERTSYMBOLS('(1+12)-123*1+2=3', '123', 'abc') FROM RDB$DATABASE;
SELECT NULL AS ISCORRECT, F_CONVERTSYMBOLS(NULL, NULL, NULL) FROM RDB$DATABASE;
SELECT '(a+ab)-abc*a+b=c' AS ISCORRECT, U_CONVERTSYMBOLS('(1+12)-123*1+2=3', '123', 'abc') FROM RDB$DATABASE;
SELECT NULL AS ISCORRECT, U_CONVERTSYMBOLS(NULL, NULL, NULL) FROM RDB$DATABASE;
nach oben • go top •
ab ersetzbar durch REVERSE
F_REVERSE Funktion von adhoc
Entrypoint reverse nicht UTF-8 kompatibel - benutze U_REVERSE
U_REVERSE Funktion von adhoc
Entrypoint u_reverse UTF-8 kompatibel
Input CSTRING(254) String der rückwärts ausgegeben werden soll
Output CSTRING(254) String rückwärts
Groß-/Kleinbuchstaben bleiben dabei so wie sie waren.
TestSQL
SELECT 'ynamreG' AS ISCORRECT, F_REVERSE('Germany') FROM RDB$DATABASE;
SELECT NULL AS ISCORRECT, F_REVERSE(NULL) FROM RDB$DATABASE;
SELECT 'ynamreG' AS ISCORRECT, U_REVERSE('Germany') FROM RDB$DATABASE;
SELECT 'ývocilsíČ' AS ISCORRECT, U_REVERSE('Číslicový') FROM RDB$DATABASE;
nach oben • go top •
F_STRIPSTRING
F_BIGSTRIPSTRING          
kompatibel zu FreeUDFLib, FreeUDFLibC, FreeUDFLib AvERP, GrUDF
Entrypoint stripstring nicht UTF-8 kompatibel - benutze U_STRIPSTRING
U_STRIPSTRING    Funktion von adhoc
Entrypoint u_stripstring UTF-8 kompatibel
Input CSTRING(32760)
CSTRING(254)
String 1 (aus dem alle Zeichen von String 2 entfernt werden sollen)
String 2 (Zeichen die entfernt werden sollen)
Output CSTRING(32760) String aus dem alle die Zeichen, die im String 2 sind, entfernt wurden
Gegenstück zu F_STRIPSTRINGHOLD und F_HOLDSTRING
TestSQL
SELECT 'Ds s n Ts Tx' AS ISCORRECT, F_STRIPSTRING('Dies ist ein Test Text', 'iet') FROM RDB$DATABASE;
SELECT 'Ds s n Ts Tx' AS ISCORRECT, F_STRIPSTRING('Dies ist ein Test Text', 'tei') FROM RDB$DATABASE;
SELECT NULL AS ISCORRECT, F_STRIPSTRING(NULL, NULL) FROM RDB$DATABASE;
SELECT 'Ds s n Ts Tx' AS ISCORRECT, U_STRIPSTRING('Dies ist ein Test Text', 'iet') FROM RDB$DATABASE;
SELECT 'Dies ist ein Test öüß' AS ISCORRECT, U_STRIPSTRING('Diesä istä einä Test äöüß', 'ä') FROM RDB$DATABASE;
nach oben • go top •
F_STRIPSTRINGHOLD
F_HOLDSTRING
F_BIGSTRIPSTRINGHOLD
kompatibel zu FreeUDFLib, FreeUDFLib AvERP, GrUDF
kompatibel zu 
Entrypoint stripstringhold nicht UTF-8 kompatibel - benutze U_STRIPSTRINGHOLD
U_STRIPSTRINGHOLD   Funktion von adhoc
Entrypoint u_stripstringhold UTF-8 kompatibel
Input CSTRING(32760)
CSTRING(254)
String 1 aus dem Zeichen entfernt werden soll
String 2 Aufflistung aller Zeichen, die nicht entfernt werden sollen
Output CSTRING(32760) String aus dem alle die Zeichen, die nicht im String 2 sind, entfernt wurden
Die Reihenfolge der Zeichen im String 2 spielt keine Rolle.
Gegenstück zu F_STRIPSTRING
TestSQL
SELECT 'ieiteietet' AS ISCORRECT, F_HOLDSTRING('Dies ist ein Test Text', 'iet') FROM RDB$DATABASE;
SELECT 'ieiteietet' AS ISCORRECT, F_HOLDSTRING('Dies ist ein Test Text', 'tei') FROM RDB$DATABASE;
SELECT 'ieiteietet' AS ISCORRECT, F_HOLDSTRING('Dies ist ein Test Text', 'iet') FROM RDB$DATABASE;
SELECT 'ieiteietet' AS ISCORRECT, F_HOLDSTRING('Dies ist ein Test Text', 'tei') FROM RDB$DATABASE;
SELECT NULL AS ISCORRECT, F_STRIPSTRINGHOLD(NULL, NULL) FROM RDB$DATABASE;
SELECT 'ieiteietet' AS ISCORRECT, U_STRIPSTRINGHOLD('Dies ist ein Test Text', 'iet') FROM RDB$DATABASE;
SELECT 'ääääö' AS ISCORRECT, U_STRIPSTRINGHOLD('Diesä istä einä Test äöüß', 'äö') FROM RDB$DATABASE;
nach oben • go top •
F_REPEATTRIM Input/Output-kompatibel zu rFunc (REPEATTRIM, LONGREPEATTRIM)
Entrypoint repeattrim nicht UTF-8 kompatibel - benutze U_REPEATTRIM
U_REPEATTRIM Funktion von adhoc
Entrypoint u_repeattrim UTF-8 kompatibel
Input CSTRING(8190)
CSTRING(1)
String 1 aus dem Zeichen entfernt werden soll
Zeichen das entfernt werden soll
Output CSTRING(8190) String aus dem alle Wiederholungen von String 2 entfernt wurden
TestSQL
SELECT '123' AS ISCORRECT, F_REPEATTRIM('12223', '2') FROM RDB$DATABASE;
SELECT NULL AS ISCORRECT, F_REPEATTRIM(NULL, NULL) FROM RDB$DATABASE;
SELECT 'abcäöuxyz' AS ISCORRECT, U_REPEATTRIM('abcäääöüxyz', 'ä') FROM RDB$DATABASE;
SELECT NULL AS ISCORRECT, U_REPEATTRIM(NULL, NULL) FROM RDB$DATABASE;
nach oben • go top •
F_STRREPEAT Input/Output-kompatibel zu rFunc (STRREPEAT, LONGSTRREPEAT)
Entrypoint strrepeat UTF-8 kompatibel
Input CSTRING(254)
SMALLINT
String der wiederholt werden soll
Anzahl des gewünschten Vorkommens von String 1
Output CSTRING(8190) String 1 Parameter 2 mal vorkommend
Es ist darauf zu achten, daß der Output die definierte Länge nicht übersteigt!
TestSQL
SELECT 'TestTestTest' AS ISCORRECT, F_STRREPEAT('Test', 3) FROM RDB$DATABASE;
SELECT '' AS ISCORRECT, F_STRREPEAT('Test', 0) FROM RDB$DATABASE;
SELECT NULL AS ISCORRECT, F_STRREPEAT(NULL, NULL) FROM RDB$DATABASE;
nach oben • go top •
F_STROFCHAR kompatibel zu GrUDF
Entrypoint strofchar nicht UTF-8 kompatibel - benutze F_STRREPEAT
Input CSTRING(1)
INTEGER
String, der wiederholt werden soll
Anzahl der Wiederholungen
Output CSTRING(32760) String mit der angegebenen Anzahl wiederholter Zeichen zurück
TestSQL
SELECT F_STRINGLENGTH(F_STROFCHAR('A', 10)) || ' mal A' AS ISCORRECT, F_STROFCHAR('A', 10) FROM RDB$DATABASE;
SELECT NULL AS ISCORRECT, F_STROFCHAR(NULL, NULL) FROM RDB$DATABASE;
nach oben • go top •
ab ersetzbar durch OVERLAY
F_STRSTUFF Input/Output-kompatibel zu rFunc (STRSTUFF, LONGSTRSTUFF)
Entrypoint strstuff nicht UTF-8 kompatibel - benutze U_STRSTUFF
U_STRSTUFF Funktion von adhoc
Entrypoint u_strstuff UTF-8 kompatibel
Input CSTRING(8190)
SMALLINT
SMALLINT
CSTRING(254)
String 1 in dem Zeichen ausgetauscht werden sollen
Anfangsposition
Anzahl der Zeichen, die ausgetauscht werden sollen
Zeichen die gesetzt werden sollen
Output CSTRING(81900) String in dem ab Anfangsposition Parameter 3 Zeichen mit den Zeichen aus Parameter 4 ersetzt wurden
Die Zählung der Anfangsposition beginnt bei 1.
Die Anzahl der Zeichen die entfernt und die Anzahl der Zeichen, die dafür eingesetzt werden müssen nicht identisch sein.
TestSQL
SELECT '12abcd567890' AS ISCORRECT, F_STRSTUFF('1234567890', 3, 2, 'abcd') FROM RDB$DATABASE;
SELECT NULL AS ISCORRECT, F_STRSTUFF(NULL, NULL, NULL, NULL) FROM RDB$DATABASE;
SELECT '12äöü567890' AS ISCORRECT, U_STRSTUFF('1234567890', 3, 2, 'äöü') FROM RDB$DATABASE;
SELECT NULL AS ISCORRECT, U_STRSTUFF(NULL, NULL, NULL, NULL) FROM RDB$DATABASE;
nach oben • go top •
F_COLLATEBR kompatibel zu GrUDF
Entrypoint collatebr nicht UTF-8 kompatibel - wenn benötigt bitte nachfragen
Input CSTRING(32760) String, indem die Sonderzeichen umgewandelt werden sollen
Output CSTRING(32760) umgewandelter String
Wandelt bestimmte „Umlaute“ zu einen vorgegebenen Zeichen
á, â, ã, à, ä, å, Á, Â, Ã, À, Ä, Å      => A
é, ê, è, ë, É, Ê, È, Ë                         => E
í, î, ì, ï, Í, Î, Ì, Ï                                 => I
ó, ô, õ, ò, ö, Ó, Ô, Õ, Ò, Ö            => O
ú, û, ù, ü,Ú, Û, Ù, Ü                        => U
ç, Ç                                                => C
ñ, Ñ                                                => N
ý, ÿ, Ý                                            => Y
TestSQL
SELECT 'AAAAAAAAAAAA' AS ISCORRECT, F_COLLATEBR('áâãàäåÁÂÃÀÄÅ')
FROM RDB$DATABASE;
SELECT 'EEEEEEEE' AS ISCORRECT, F_COLLATEBR('éêèëÉÊÈË') FROM RDB$DATABASE;
SELECT 'IIIIIIII' AS ISCORRECT, F_COLLATEBR('íîìïÍÎÌÏ') FROM RDB$DATABASE;
SELECT 'OOOOOOOOOO' AS ISCORRECT, F_COLLATEBR('óôõòöÓÔÕÒÖ') FROM RDB$DATABASE;
SELECT 'UUUUUUUU' AS ISCORRECT, F_COLLATEBR('úûùüÚÛÙÜ') FROM RDB$DATABASE;
SELECT 'CC' AS ISCORRECT, F_COLLATEBR('çÇ') FROM RDB$DATABASE;
SELECT 'NN' AS ISCORRECT, F_COLLATEBR('ñÑ') FROM RDB$DATABASE;
SELECT NULL AS ISCORRECT, F_COLLATEBR(NULL) FROM RDB$DATABASE;
nach oben • go top •
F_KEYUP Funktion von adhoc
Entrypoint keyup nicht UTF-8 kompatibel - wenn benötigt bitte nachfragen
Input CSTRING(32760)
SMALLINT
String der aufbereitet werden soll
Länge des Output-Strings
Output CSTRING(32760) umgewandelter String
Wandelt einen String um
- alles nach Großbuchstaben
- nimmt nur alphanumerische Zeichen incl. untenstehende Umlaut-Zeichen
- wandelt untenstehende Umlaut-Zeichen zu "normal" Zeichen um
     Á, Â, Ã, À, Ä, Å      => A
     É, Ê, È, Ë                 => E
     Í, Î, Ì, Ï                     => I
     Ó, Ô, Õ, Ò, Ö         => O
     Ú, Û, Ù, Ü               => U
     Ç                             => C
     Æ                            => AE
     Ø                            => OE
     ß                             => SS
     Đ                            => D
     Ñ                            => N
     Ý                            => Y
- kürzt den String auf die angegebene Länge
TestSQL
SELECT '7A 5E 5I 6O 5U 2C 2AE 2OE 4S 2D 2N 2Y 1234567' AS ISCORRECT, F_KEYUP('AáâãàäåEéêèëIíîìïOóôõòöUúûùüCçAEæOEøSSßDd.NñYý1234567890', 55) FROM RDB$DATABASE;
SELECT NULL AS ISCORRECT, F_KEYUP(NULL, NULL) FROM RDB$DATABASE;
nach oben • go top •
F_PRED            Funktion von adhoc
Entrypoint predecessor nicht UTF-8 kompatibel - benutze U_PRED
U_PRED            Funktion von adhoc
Entrypoint u_predecessor UTF-8 kompatibel
Input CSTRING(1)
INTEGER
Zeichen, zu dem ein Vorgänger gesucht werden soll
Anzahl der Zeichen im Zeichensatz, um das der Vorgänger von Parameter 1 (rückwärts im Zeichensatz) abweichen soll
Output CSTRING(1)
n-Vorgänger des Zeichens aus Parameter 1
Bei Parameter 2 gleich 512 (oder einem Vielfachen von 512) ist das Ergebnis gleich dem Input.
Test SQL
SELECT 'b' AS ISCORRECT, F_PRED('a', -1) FROM RDB$DATABASE;
SELECT 'a' AS ISCORRECT, F_PRED('b', 1) FROM RDB$DATABASE;
SELECT 'a' AS ISCORRECT, F_PRED('a', 512) FROM RDB$DATABASE;
SELECT NULL AS ISCORRECT, F_PRED(NULL, NULL) FROM RDB$DATABASE;
SELECT '¢' AS ISCORRECT, U_PRED('£', 1) FROM RDB$DATABASE;
SELECT '¡' AS ISCORRECT, U_PRED('£', 2) FROM RDB$DATABASE;
SELECT 'あ' AS ISCORRECT, U_PRED('え', 6) FROM RDB$DATABASE;
SELECT NULL AS ISCORRECT, U_PRED(NULL, NULL) FROM RDB$DATABASE;
nach oben • go top •
F_SUCC Funktion von adhoc
Entrypoint successor nicht UTF-8 kompatibel - benutze U_SUCC
U_SUCC Funktion von adhoc
Entrypoint u_successor UTF-8 kompatibel
Input CSTRING(1)
INTEGER
Zeichen, zu dem ein Nachfolger gesucht werden soll
Anzahl der Zeichen im Zeichensatz, um das der Nachfolger von Parameter 1 (fortlaufend im Zeichensatz) abweichen soll
Output CSTRING(1) n-Nachfolger des Zeichens aus Parameter 1
Bei Parameter 2 gleich 512 (oder einem Vielfachen von 512) ist das Ergebnis gleich dem Input.
Test SQL
SELECT 'a' AS ISCORRECT, F_SUCC('b', -1) FROM RDB$DATABASE;
SELECT 'c' AS ISCORRECT, F_SUCC('b', 1) FROM RDB$DATABASE;
SELECT 'b' AS ISCORRECT, F_SUCC('b', 512) FROM RDB$DATABASE;
SELECT NULL AS ISCORRECT, F_SUCC(NULL, NULL) FROM RDB$DATABASE;
SELECT '¤' AS ISCORRECT, U_SUCC('£', 1) FROM RDB$DATABASE;
SELECT '×' AS ISCORRECT, U_SUCC('Ö', 1) FROM RDB$DATABASE;
SELECT 'Γ' AS ISCORRECT, U_SUCC('Ώ', 4) FROM RDB$DATABASE;
SELECT 'ぎ' AS ISCORRECT, U_SUCC('え', 6) FROM RDB$DATABASE;
SELECT NULL AS ISCORRECT, U_SUCC(NULL, NULL) FROM RDB$DATABASE;
nach oben • go top •
 
String-Funktionen: Umwandeln
ab ersetzbar durch LOWER
F_LOWER
F_ANSILOWERCASE
Funktion von adhoc
kompatibel zu FreeUDFLib AvERP, GrUDF
Entrypoint lower nicht UTF-8 kompatibel - benutze U_LOWER
U_LOWER
Funktion von adhoc
Entrypoint u_lower UTF-8 kompatibel
Input CSTRING(32760) String, der umgewandelt werden soll
Output CSTRING(32760) alle Zeichen in Kleinbuchstaben, incl. Sonderzeichen
Diese Funktion ist unter FireBird 2 nicht mehr notwendig, da es nun auch in LOWER(..) die Sonderzeichen korrekt behandelt werden.
TestSQL
SELECT 'schöner tag' AS ISCORRECT, F_LOWER('SchÖner TAG') FROM RDB$DATABASE;
SELECT 'schöner tag' AS ISCORRECT, F_ANSILOWERCASE('SchÖner TAG') FROM RDB$DATABASE;
SELECT NULL AS ISCORRECT,  F_LOWER(NULL) FROM RDB$DATABASE;
SELECT 'schöner tag' AS ISCORRECT, U_LOWER('SchÖner TAG') FROM RDB$DATABASE;
SELECT NULL AS ISCORRECT,  U_LOWER(NULL) FROM RDB$DATABASE;
nach oben • go top •
ab ersetzbar durch UPPER
F_UPPER
F_ANSIUPPERCASE
Funktion von adhoc
kompatibel zu FreeUDFLib AvERP, GrUDF
Entrypoint upper nicht UTF-8 kompatibel - benutze U_UPPER
U_UPPER
Funktion von adhoc
Entrypoint u_upper UTF-8 kompatibel
Input CSTRING(32760) String, der umgewandelt werden soll
Output CSTRING(32760) alle Zeichen in Großbuchstaben, incl. Sonderzeichen 
Diese Funktion ist unter FireBird 2 nicht mehr notwendig, da es nun auch in UPPER(..) die Sonderzeichen korrekt behandelt werden.
TestSQL
SELECT 'SCHÖNER TAG' AS ISCORRECT, F_UPPER('Schöner Tag') FROM RDB$DATABASE;
SELECT 'SCHÖNER TAG' AS ISCORRECT, F_ANSIUPPERCASE('Schöner Tag') FROM RDB$DATABASE;
SELECT NULL AS ISCORRECT, F_UPPER(NULL) FROM RDB$DATABASE;
SELECT 'SCHÖNER TAG' AS ISCORRECT, U_UPPER('Schöner Tag') FROM RDB$DATABASE;
SELECT NULL AS ISCORRECT, U_UPPER(NULL) FROM RDB$DATABASE;
nach oben • go top •
ab ersetzbar durch LOWER
F_RLOWER kompatibel zu rFunc (RLOWER, LONGRLOWER)
nur für Charset Win1251
Entrypoint rlower nicht UTF-8 kompatibel - benutze U_LOWER
Input CSTRING(32760) String, der umgewandelt werden soll
Output CSTRING(32760) alle Zeichen in Kleinbuchstaben, incl. Sonderzeichen
Wandelt kyrillische Zeichen von Großbuchstaben in Kleinbuchstaben um
nach oben • go top •
ab ersetzbar durch UPPER
F_RUPPER kompatibel zu rFunc (RUPPER, LONGRUPPER)
nur für Charset Win1251
Entrypoint rupper nicht UTF-8 kompatibel - benutze U_UPPER
Input CSTRING(32760) String, der umgewandelt werden soll
Output CSTRING(32760) alle Zeichen in Großbuchstaben, incl. Sonderzeichen
Wandelt kyrillische Zeichen von Kleinbuchstaben in Großbuchstaben um
nach oben • go top •
Vorbemerkung (s. http://de.wikipedia.org/wiki/Kyrillisches_Alphabet#Wiedergabe_mit_lateinischen_Buchstaben)
Für die graphische Wiedergabe der kyrillischen Schrift mit lateinischen Buchstaben (Romanisierung) gibt es verschiedene Möglichkeiten der Umschrift:
    1. sprachunabhängig (ISO 9:1995/GOST 7.79 mit 1:1-Buchstabenzuordnung),
    2. ausgangssprachabhängig (wissenschaftliche Transliteration, ISO/R 9:1968),
    3. ausgangs- und zielsprachabhängig (Transkription).
Die Umkehrbarkeit ist dabei nur im ersten Fall vollständig gewährleistet, mit kleinen Einschränkungen meist auch im zweiten.
Die in der Slawistik übliche wissenschaftliche Transliteration beruht auf dem tschechischen Alphabet. Die Normen der ISO und anderer Institute (v. a. GOST) bauen darauf auf, unterscheiden sich aber in Details davon. Die UN empfiehlt seit 1987 für geographische Bezeichnungen GOST 16876-71[5], die zumindest für das Russische keine Unterschiede zur wissenschaftlichen Transliteration und ISO/R 9 aufweist und nur drei zu ISO 9 (щ → šč/ŝ, я → ja/â, ю → ju/û). 
Buchstaben mit einheitlicher Transliteration:
Kyrillisch А
а
Б
б
В
в
Ѓ
ѓ
Д
д
Ђ
ђ
Е
е
Ё
ё
Ж
ж
З
з
И
и
Й
й
К
к
Л
л
М
м
Н
н
О
о
П
п
Р
р
С
с
Т
т
Ќ
ќ
Ћ
ћ
У
у
Ў
ў
Ф
ф
Ц
ц
Ч
ч
Ш
ш
Ь
ь
Ѣ
ѣ
Lateinisch A
a
B
b
V
v
Ǵ
ǵ
D
d
Đ
đ
E
e
Ë
ë
Ž
ž
Z
z
I
i
J
j
K
k
L
l
M
m
N
n
O
o
P
p
R
r
S
s
T
t

Ć
ć
U
u
Ǔ
ŭ
F
f
C
c
Č
č
Š
š
Ě
ě
Für die weitgehend phonetische Transkription gibt es in den europäischen Sprachen – auch und gerade der deutschen – eine lange Tradition, in deren Verlauf es auch zu Änderungen und Varianten kam (z. B. Namensendung -off/-ow/-ov/-ev oder in der DDR sh für ж). Neben der Verwendung von w anstelle von v für в weicht die vom Duden gepflegte (russisch-)deutsche Transkription vor allem bei den S-Lauten von der Transliteration ab (ш/ж → sch, з → s statt z, ц → z statt c). Im englischen Sprachraum dominieren zwei einander sehr ähnliche Standards, die zugunsten von Digraphen (meist mit h) weniger stark auf diakritische Zeichen wie Hatschek und Zirkumflex setzen (z. B. щ → shch statt šč oder ŝ): BGN/PCGN (Geographie) und ALA/LC (Bibliothekswesen). Durch die Verwendung in den internationalen Medien, bspw. im Profisportbereich, und deren unreflektierter Übernahme durch die lokale Presse finden sich die französische und vor allem englische Transkription auch in vielen anderen Ländern; ebenso tauchen wegen technischer Schwierigkeiten akzentbefreite Transliterationen auf. Es ist ein Qualitätsmerkmal von Verlagen und Redaktionen, den ausgewählten Transkriptions- oder Transliterationsstandard durchgängig einzuhalten.
Für wissenschaftliche Zwecke wird ausschließlich die wissenschaftliche Transliteration verwendet, ebenso beispielsweise zunehmend in Nachschlagewerken und auf Landkarten, während für publizistische die so genannte Duden-Transkription bevorzugt wird.
 
F_RLATIN kompatibel zu rFunc (RLATIN, LONGLATIN)
nur für Charset Win1251
Entrypoint rlatin nicht UTF-8 kompatibel - benutze U_CYRILLIC_LATIN
Input CSTRING(32760) String, der umgewandelt werden soll
Output CSTRING(32760) alle kyrillischen Buchstaben in lateinische Buchstaben
Ersetzt kyrillische Zeichen durch lateinische Zeichen nach der Methode der einheitlichen Transliteration.
Anmerkung:
Aus Kompatibilitätsgründen zur rFunc wurde für F_RLATIN die folgende Ersetzung beibehalten:
Kyrillisch Ё
ё
Є
є
Ї
ї
І
і
Lateinisch E
e
E
e
I
i
I
i
Kyrillisch А
а
Б
б
В
в
Ѓ
ѓ
Д
д
Ђ
ђ
Е
е
Ё
ё
Ж
ж
З
з
И
и
Й
й
К
к
Л
л
М
м
Н
н
О
о
П
п
Р
р
С
с
Т
т
Ќ
ќ
Ћ
ћ
У
у
Ў
ў
Ф
ф
Ц
ц
Ч
ч
Ш
ш
Ь
ь
Ѣ
ѣ
Lateinisch A
a
B
b
V
v
Ǵ
ǵ
D
d
Đ
đ
E
e
Ë
ë
Ž
ž
Z
z
I
i
J
j
K
k
L
l
M
m
N
n
O
o
P
p
R
r
S
s
T
t

Ć
ć
U
u
Ǔ
ŭ
F
f
C
c
Č
č
Š
š
, Ě
ě
Die Umwandlung funktioniert NUR, wenn die Datenbank mit dem Charset win1251 läuft.
nach oben • go top •
U_CYRILLIC_LATIN Funktion von adhoc
Entrypoint u_cyrillic_latin UTF-8 kompatibel
Input CSTRING(8191) String, der umgewandelt werden soll
Output CSTRING(8191) alle kyrillischen Buchstaben in lateinische Buchstaben
Ersetzt kyrillische Zeichen durch lateinische Zeichen nach der Methode der wissenschaftlichen Transliteration nach ISO 9.
Anzuwenden für Russisch, Bulgarisch, Serbo-Kroatisch, Ukrainisch und Weisrussisch.
Die Umwandlung funktioniert NUR, wenn die Datenbank mit dem Charset UTF-8 läuft.
TestSQL
SELECT 'Aleksandr Solženicyn' AS ISCORRECT, U_CYRILLIC_LATIN('Александр Солженицын') FROM RDB$DATABASE
SELECT 'Mihail Gorbačëv' AS ISCORRECT, U_CYRILLIC_LATIN('Михаил Горбачёв') FROM RDB$DATABASE
SELECT 'Ruslana Ližičko' AS ISCORRECT, U_CYRILLIC_LATIN('Руслана Лижичко') FROM RDB$DATABASE
SELECT 'AaBbVvGgDdEeË뎞ZzIiJjKkLlMmNnOoPpRrSsTtUuFfHhCcČ芚ŜŝʺʺYyʹʹÈèÛûÂâ' AS ISCORRECT, U_CYRILLIC_LATIN('АаБбВвГгДдЕеЁёЖжЗзИиЙйКкЛлМмНнОоПпРрСсТтУуФфХхЦцЧчШ шЩщЪъЫыЬьЭэЮюЯя') FROM RDB$DATABASE
SELECT NULL AS ISCORRECT, F_CYRILLLIC_LATIN(NULL) FROM RDB$DATABASE;
nach oben • go top •
F_PROPERCASE kompatibel zu FreeUDFLib, FreeUDFLibC, FreeUDFLib AvERP, GrUDF
Entrypoint propercase nicht UTF-8 kompatibel - benutze U_PROPERCASE
U_PROPERCASE Funktion von adhoc
Entrypoint u_propercase UTF-8 kompatibel
Input CSTRING(32760) String, der umgewandelt werden soll
Output CSTRING(32760) String bzgl. Groß-/Kleinschreibung so dass jedes Wort mit einem Großbuchstaben beginnt und alle anderen Buchstaben Kleinbuchstaben sind.
Wandelt auch  Sonderzeichen (nicht nur deutsche ä ö ü). Ein kleines ‘ß’ bleibt natürlich ein kleines ‘ß’.
TestSQL
SELECT 'Dies Ist Ein Test Äh' AS ISCORRECT, F_PROPERCASE('dies ist ein test äh') FROM RDB$DATABASE;
SELECT NULL AS ISCORRECT, F_PROPERCASE(NULL) FROM RDB$DATABASE;
SELECT 'Schöner Tag' AS ISCORRECT, U_PROPERCASE('SCHÖner taG') FROM RDB$DATABASE;
SELECT NULL AS ISCORRECT, U_PROPERCASE(NULL) FROM RDB$DATABASE;
nach oben • go top •
ab ersetzbar durch ASCII_CHAR
F_CHARACTER
F_CHR
kompatibel zu FreeUDFLib, FreeUDFLibC, FreeUDFLib AvERP
kompatibel zu GrUDF
Input/Output-kompatibel zu rFunc (CHR)
kompatibel zu  ib_udf (ASCII_CHAR)
Entrypoint character nicht UTF-8 kompatibel - benutze U_CHR
U_CHR Funktion von adhoc
Entrypoint u_character UTF-8 kompatibel
Input INTEGER ASCII-Code
Output CSTRING(2) Zeichen des ASCII-Codes vom Input
TestSQL
SELECT 'B' AS ISCORRECT, F_CHARACTER(66) FROM RDB$DATABASE;
SELECT 'ä' AS ISCORRECT, F_CHARACTER(228) FROM RDB$DATABASE;
SELECT 'B' AS ISCORRECT, F_CHR(66) FROM RDB$DATABASE;
SELECT 'ä' AS ISCORRECT, F_CHR(228) FROM RDB$DATABASE;
SELECT NULL AS ISCORRECT, F_CHARACTER(NULL) FROM RDB$DATABASE;
SELECT NULL AS ISCORRECT, F_CHR(NULL) FROM RDB$DATABASE;
SELECT 'ä' AS ISCORRECT, U_CHR(228) FROM RDB$DATABASE;
SELECT 'Θ' AS ISCORRECT, U_CHR(920) FROM RDB$DATABASE;
SELECT 'Ж' AS ISCORRECT, U_CHR(1046) FROM RDB$DATABASE;
SELECT 'ウ' AS ISCORRECT, U_CHR(12454) FROM RDB$DATABASE;
SELECT NULL AS ISCORRECT, U_CHR(NULL) FROM RDB$DATABASE;
nach oben • go top •
ab ersetzbar durch ASCII_VAL
F_ORD Input/Output-kompatibel zu rFunc (ORD)
kompatibel zu  ib_udf (ASCII_VAL)
Entrypoint ord nicht UTF-8 kompatibel - benutze U_ORD
U_ORD Funktion von adhoc
Entrypoint u_ord UTF-8 kompatibel
Input CSTRING(1) ASCII-Code-Nr. des Zeichens
Output SMALLINT Zeichen, das dem ASCII-Codes von Input entspricht
TestSQL
SELECT 65 AS ISCORRECT, F_ORD('A') FROM RDB$DATABASE;
SELECT NULL AS ISCORRECT, F_ORD(NULL) FROM RDB$DATABASE;
SELECT 228 AS ISCORRECT, U_ORD('ä') FROM RDB$DATABASE;
SELECT 920 AS ISCORRECT, U_ORD('Θ') FROM RDB$DATABASE;
SELECT 1046 AS ISCORRECT, U_ORD('Ж') FROM RDB$DATABASE;
SELECT 12454 AS ISCORRECT, U_ORD('ウ') FROM RDB$DATABASE;
SELECT NULL AS ISCORRECT, U_ORD(NULL) FROM RDB$DATABASE;
nach oben • go top •
F_ROT13 Funktion von adhoc
Entrypoint rot13 UTF-8 kompatibel
Input CSTRING(254) String, der verschlüsselt werden soll
Output CSTRING(254) Input-String, verschlüsselt nach dem ROT13 Algorithmus
aus Wikipedia:
ROT13 (engl. rotate by 13 places, zu deutsch in etwa „rotiere um 13 Stellen“) ist eine Verschiebechiffre (auch Caesarchiffre genannt), mit der auf einfache Weise Texte verschlüsselt werden können. Dies geschieht durch Ersetzung von Buchstaben – bei ROT13 im speziellen wird jeder Buchstabe des lateinischen Alphabets durch den im Alphabet um 13 Stellen davor bzw. dahinter liegenden Buchstaben ersetzt.
ROT13 ist seine eigene Umkehrung: um ROT13 zu entschlüsseln kann der selbe Algorithmus benutzt werden, so daß die gleiche Funktion zum Ver- und Entschlüsseln verwendet werden kann.
Der Name „ROT13“ stammt aus dem Usenet in den frühen 1980er Jahren. ROT13 ist nicht zur sicheren Verschlüsselung gedacht, es wird im Gegensatz dazu sogar oft als Beispiel für eine schwache, unsichere Verschlüsselung genannt. Vielmehr dient ROT13 dazu, einen Text unlesbar zu machen, also zu verschleiern, so dass eine Handlung des Lesers erforderlich ist, um den ursprünglichen Text lesen zu können. ROT13 lässt sich daher mit Lösungen von Rätseln in Zeitschriften vergleichen, die kopfüber gedruckt werden, damit sie nicht sofort versehentlich gelesen werden können.
TestSQL
SELECT F_ROT13(F_ROT13('Dies ist keine richtige Verschlüsselung')) AS ISCORRECT, F_ROT13('Dies ist keine richtige Verschlüsselung') FROM RDB$DATABASE;
SELECT NULL AS ISCORRECT, F_ROT13(NULL) FROM RDB$DATABASE;
nach oben • go top •
F_GENERATESNDXINDEX
F_SOUNDEX
kompatibel zu FreeUDFLib, FreeUDFLib AvERP
kompatibel zu FreeUDFLibC
Entrypoint soundex UTF-8 kompatibel
Input CSTRING(8190) String, von dem der Soundex generiert werden soll
Output CSTRING(6) (Ur-) Soundex vom String
Soundex ist ein phonetischer Algorithmus zur Indexierung von Wörtern und Phrasen nach ihrem Klang in der englischen Sprache. Gleichklingende Wörter sollen dabei zu einer identischen Zeichenfolge codiert werden. Berücksichtigt ab der 2. Stelle gezählt nur die ersten 6 Konsonanten bei der Ermittlung, wobei mehrfaches Auftreten nur einmal berücksichtigt wird (im Beispiel sind das l,m,y,w,r,d). Deswegen ist er ungeeignet, um längere Strings zu vergleichen.
TestSQL
SELECT 'H4564' AS ISCORRECT, F_GENERATESNDXINDEX('Hello my world') FROM RDB$DATABASE;
SELECT 'H4564' AS ISCORRECT, F_GENERATESNDXINDEX('Hello my world on my earth') FROM RDB$DATABASE;
SELECT 'H4564' AS ISCORRECT, F_SOUNDEX('Hello my world') FROM RDB$DATABASE;
SELECT 'H4564' AS ISCORRECT, F_SOUNDEX('Hello my world on my earth') FROM RDB$DATABASE;
SELECT NULL AS ISCORRECT, F_SOUNDEX(NULL) FROM RDB$DATABASE;
nach oben • go top •
F_GSOUNDEX Funktion von adhoc
Entrypoint gsoundex nicht UTF-8 kompatibel - wenn benötigt bitte nachfragen
Input CSTRING(8190) String
Output CSTRING(8190) (deutsch-)phonetischen String
Ermittelt einen (deutsch-)phonetischen String vom Input-Parameter. Kann z.B. zur Dubletten-Suche dienen.
TestSQL
SELECT 'MAYR' AS ISCORRECT, F_GSOUNDEX('Meier') FROM RDB$DATABASE;
SELECT 'MAYR' AS ISCORRECT, F_GSOUNDEX('Maier') FROM RDB$DATABASE;
SELECT 'MAYR' AS ISCORRECT, F_GSOUNDEX('Mayer') FROM RDB$DATABASE;
SELECT NULL AS ISCORRECT, F_GSOUNDEX(NULL) FROM RDB$DATABASE;
nach oben • go top •
F_TELEFONNR Funktion von adhoc
Entrypoint telefonnr UTF-8 kompatibel
Input CSTRING(32760) String, der eine TelefonNr. (oder Ähnliches, aus dem alles bis auf die Zahlen entfernt werden soll) enthält
INTEGER definiert die Anzahl der Ziffern am Ende, die durch * ersetzt werden
Output CSTRING(32760) String, aus dem alle nicht-nummerischen- und Leerzeichen entfernt wurden
Steht am Anfang ein “49" wird es durch ein “+49" ersetzt. Beginnt der String mit einem “+”, bleibt dies erhalten.
Anmerkung:
Diese Funktion dient dazu, um in einem String gespeicherte und “wild” formatierte TelefonNr. für TAPI an ein/e Telefon(anlage) zu übergeben (die selber diese “Intelligenz” nicht besitzt).
TestSQL
SELECT '0232653***' AS ISCORRECT, F_TELEFONNR(' (0232) / 6535-35', 3) FROM RDB$DATABASE;
SELECT '+001232653***' AS ISCORRECT, F_TELEFONNR('+001 (232) / 6535-35', 3) FROM RDB$DATABASE;
SELECT '+49232653***' AS ISCORRECT, F_TELEFONNR('+49 (232) / 6535-35', 3) FROM RDB$DATABASE;
SELECT NULL AS ISCORRECT, F_TELEFONNR(NULL, NULL) FROM RDB$DATABASE;
nach oben • go top •
F_DIGITS kompatibel  zu GrUDF
Entrypoint digits UTF-8 kompatibel
Input CSTRING(32760) String, aus dem die Zeichen entfernt werden sollen
Output CSTRING(32760) String aus dem alle nicht-numerischen Zeichen (z.B. für TAPI) entfernt wurden
TestSQL
SELECT '0232653535' AS ISCORRECT, F_DIGITS(' (0232) / 6535-35') FROM RDB$DATABASE;
SELECT NULL AS ISCORRECT, F_DIGITS(NULL) FROM RDB$DATABASE;
nach oben • go top •
F_STR2EXCEL Funktion von adhoc
Entrypoint excelstring nicht UTF-8 kompatibel - wenn benötigt bitte nachfragen
Input CSTRING(32760) String, der für Excel umgewandelt werden soll
Output CSTRING(32760) String angepaßt für Excel
Um auch mehrzeilige Texte und Texte, die Doppelhochkommata enthalten, aus längeren Strings nach Excel exportieren zu können, bedarf es einiger Umformungen. Diese Funktion erledigt das:
- fügt am Anfang und Ende des Strings jeweils ein Doppelhochkomma hinzu
- verdoppelt alle im Text selber vorkommenden Doppelhochkommata
- entfernt alle CHR(13) aus dem String
- begrenzt den übergebenen String auf 32760 Zeichen (Grenze von Excel für ein Feld)
TestSQL
SELECT '"1.Zeile ""Paul"" und' || F_LF() || '2.Zeile"' AS ISCORRECT, F_STR2EXCEL('1.Zeile "Paul" und' || F_CRLF() || '2.Zeile') FROM RDB$DATABASE;
SELECT NULL AS ISCORRECT, F_STR2EXCEL(NULL) FROM RDB$DATABASE;
Anmerkung:
Da es eigentlich keinen Sinn macht, einen in der Datenbank vorhandenen (sehr) langen Text in eine Excel-Zelle zu exportieren, dürfte diese Funktion (erst) in Kombination mit F_LEFT bzw. F_RIGHT erst praktikabel sein. Bsp.:
SELECT F_RIGHT(F_STR2EXCEL(STRFeldTAGEBUCH), 1000) FROM ... exportiert z.B. die letzten 1000 Zeichen des Tagebuchs.
nach oben • go top •
F_RC Input/Output-kompatibel zu rFunc (C, LONGC)
Entrypoint r_c UTF-8 kompatibel
Input CSTRING(254) String
Output CSTRING(254) Ist der String <null> ein Leerstring, sonst der Input-String
TestSQL
SELECT 'Leerstring/empty string' AS ISCORRECT, F_RC(UUIDCOMPR) FROM UUIDTEST WHERE UUIDTESTID = 5;
nach oben • go top •
F_FLOATOSTR Input/Output-kompatibel zu rFunc (FLOATTOSTR)
Entrypoint floattostr UTF-8 kompatibel
Input DOUBLE
CSTRING(254)
Fließkommazahl, die dargestellt werden soll
Ausgabeformat der Zahl als String analog der C-Funktion sprintf
Output CSTRING(254) Formatierte Zahl als String
TestSQL
SELECT '1.350e+01' AS ISCORRECT, F_FLOATTOSTR(13.5, '%7.3e') FROM RDB$DATABASE;
SELECT '+13.500' AS ISCORRECT, F_FLOATTOSTR(13.5, '%+7.3f') FROM RDB$DATABASE;
SELECT '13.534' AS ISCORRECT, F_FLOATTOSTR(13.5345, '%.5g') FROM RDB$DATABASE;
SELECT '13.53450' AS ISCORRECT, F_FLOATTOSTR(13.5345, '%.5f') FROM RDB$DATABASE;
SELECT '0000D' AS ISCORRECT, F_FLOATTOSTR(13, '%05X') FROM RDB$DATABASE;
SELECT '0x0d' AS ISCORRECT, F_FLOATTOSTR(13, '%#04x') FROM RDB$DATABASE;
SELECT NULL AS ISCORRECT, F_FLOATTOSTR(NULL, NULL) FROM RDB$DATABASE;
nach oben • go top •
F_INTTOSTR Input/Output-kompatibel zu rFunc (INTTOSTR)
Entrypoint inttostr UTF-8 kompatibel
Input INTEGER
CSTRING(254)
Ganzzahl, die dargestellt werden soll
Ausgabeformat der Zahl als String analog der C-Funktion sprintf
Output CSTRING(254) Formatierte Zahl als String
TestSQL
SELECT '0000000013' AS ISCORRECT, F_INTTOSTR(13, '%010d') FROM RDB$DATABASE;
SELECT '0xd' AS ISCORRECT, F_INTTOSTR(13, '%#x') FROM RDB$DATABASE;
SELECT NULL AS ISCORRECT, F_INTTOSTR(NULL, NULL) FROM RDB$DATABASE;
nach oben • go top •
 
String-Funktionen: Vergleichen
F_EQUALSTRING kompatibel zu FreeUDFLib AvERP, GrUDF
Input/Output-kompatibel zu rFunc (CEQUAL)
Entrypoint equalstring UTF-8 kompatibel
Input CSTRING(8190)
CSTRING(8190)
String 1
String 2
Output INTEGER Überprüft ob String 1 gleich String 2 ist. 1 = ist gleich, 0 = ist nicht gleich
TestSQL
SELECT 1 AS ISCORRECT, F_EQUALSTRING('Pauline ist im Urlaub', 'Pauline ist im Urlaub') FROM RDB$DATABASE;
SELECT 0 AS ISCORRECT, F_EQUALSTRING('Pauline ist im Urlaub', 'Paul ist im Urlaub') FROM RDB$DATABASE;
In FireBird 2.0 MIT <null>-Definition kommt <null> raus, in allen anderen Datenbanken ist der NULL-String identisch mit dem Leerstring, somit kommt in unterem SQL dann auch 1 raus.
SELECT NULL AS ISCORRECT, F_EQUALSTRING(NULL, '') FROM RDB$DATABASE;
nach oben • go top •
F_STRCMP Input/Output-kompatibel zu rFunc (STRCMP)
Entrypoint r_strcmp nicht UTF-8 kompatibel - benutze U_STRCMP
U_STRCMP Funktion von adhoc
Entrypoint u_rstrcmp UTF-8 kompatibel
Input CSTRING(8190)
CSTRING(8190)
String 1
String 2
Output INTEGER output < 0 : String 1 ist kleiner als String 2
output = 0 : String 1 = String 2
output > 0 : String 1 ist größer als String 2
Achtung: in der original rFunc-Funktion STRCMP ist im Vergleich zur BLOb-Funktion B_STRCMP der output bzgl. positiv und negativ vertauscht - bei der String-Funktion bedeutet ein positiver Wert, dass der erste String größer ist, bei der BLOB-Funktion bedeutet das, dass der zweite BLOb größer ist! Aus Kompatibilitätsgründen haben wir dieses Verhalten genau so in die FreeAdhocUDF übernommen!
In Linux ist der Wert des Outputs ein anderer als unter Windows!
TestSQL
SELECT 0 AS ISCORRECT, F_STRCMP('Pauline ist im Urlaub', 'Pauline ist im Urlaub') FROM RDB$DATABASE;
SELECT 73 AS ISCORRECT, F_STRCMP('Pauline ist im Urlaub', 'Paul ist im Urlaub') FROM RDB$DATABASE;
SELECT -73 AS ISCORRECT, F_STRCMP('Paul ist im Urlaub', 'Pauline ist im Urlaub') FROM RDB$DATABASE;
SELECT NULL AS ISCORRECT, F_STRCMP(NULL, NULL) FROM RDB$DATABASE;
SELECT -73 AS ISCORRECT, U_STRCMP('Päul ist im Urlaub', 'Päuline ist im Urlaub') FROM RDB$DATABASE;
SELECT NULL AS ISCORRECT, U_STRCMP(NULL, NULL) FROM RDB$DATABASE;
nach oben • go top •
 
String-Funktionen: Suchen / Ermitteln
F_FINDWORD kompatibel zu FreeUDFLib, FreeUDFLibC, FreeUDFLib AvERP
Entrypoint findword nicht UTF-8 kompatibel - benutze U_FINDWORD
Input CSTRING(32760)
INTEGER
String, in dem ein anderer String gesucht werden soll
Position, an der die Suche im String beginnen soll
Output CSTRING(254) Wort oder Teilwort, welches an der entsprechend angegebenen Positon steht
U_FINDWORD Funktion von adhoc
Entrypoint u_findword UTF-8 kompatibel
Input CSTRING(8191)
INTEGER
String, in dem ein anderer String gesucht werden soll
Position, an der die Suche im String beginnen soll
Output CSTRING(255) Wort oder Teilwort, welches an der entsprechend angegebenen Positon steht
Positionierung beginnt hier bei 0, d.h. 1.Stelle = 0 und sucht bis zum ersten Leerzeichen.
Unter FireBird 2.0 ergibt Parameter 2 < 0 oder > Länge von Parameter 1 <null> sonst '' (Leerstring).
TestSQL
SELECT 'ABC' AS ISCORRECT, F_FINDWORD('ABC 123 45678 9123', 0) FROM RDB$DATABASE;
SELECT 'BC' AS ISCORRECT, F_FINDWORD('ABC 123 45678 9123', 1) FROM RDB$DATABASE;
SELECT '123' AS ISCORRECT, F_FINDWORD('ABC 123 45678 9123', 3) FROM RDB$DATABASE;
SELECT '123' AS ISCORRECT, F_FINDWORD('ABC 123 45678 9123', 4) FROM RDB$DATABASE;
SELECT '' AS ISCORRECT, F_FINDWORD('ABC 123 45678 9123', 20) FROM RDB$DATABASE;
SELECT NULL AS ISCORRECT, F_FINDWORD('ABC 123 45678 9123', 20) FROM RDB$DATABASE;
SELECT NULL AS ISCORRECT, F_FINDWORD(NULL, NULL) FROM RDB$DATABASE;
SELECT 'äöü' AS ISCORRECT, U_FINDWORD('ABC äöü 45678 9123', 3) FROM RDB$DATABASE;
SELECT 'äöü' AS ISCORRECT, U_FINDWORD('ABC äöü 45678 9123', 4) FROM RDB$DATABASE;
SELECT 'öü' AS ISCORRECT, U_FINDWORD('ABC äöü 45678 9123', 5) FROM RDB$DATABASE;
SELECT NULL AS ISCORRECT, U_FINDWORD(NULL, NULL) FROM RDB$DATABASE;
nach oben • go top •
F_WORDNUM Input/Output-kompatibel zu rFunc (WORDNUM, LONGWORDNUM)
Entrypoint wordnum nicht UTF-8 kompatibel - wenn benötigt bitte nachfragen
Input CSTRING(32760)
INTEGER
CSTRING(31)
SMALLINT
String, in dem ein anderer String gesucht werden soll
String-Nr. , die gesucht werden soll (n-tes Wort)
Wordtrenner
Output CSTRING(254) n-Wort
Zählung für Parameter 2 beginnt bei 1.
TestSQL
SELECT 'ABC' AS ISORRECT, F_WORDNUM('ABC 123 45678 9123', 1, ' ', 0) FROM RDB$DATABASE;
SELECT NULL AS ISCORRECT, F_WORDNUM(NULL, NULL, NULL, NULL) FROM RDB$DATABASE;
nach oben • go top •
F_FINDNTHWORD kompatibel zu FreeUDFLib, FreeUDFLib AvERP
Entrypoint findnthword nicht UTF-8 kompatibel - wenn benötigt bitte nachfragen
Input CSTRING(32760)
INTEGER
String, in dem ein anderer String gesucht werden soll
String-Nr. , die gesucht werden soll (n-tes Wort)
Output CSTRING(254) n-Wort
Zählung für Parameter 2 beginnt bei 0.
Für FireBird 2.0 ergibt die Suche nach dem n-ten Wort, wenn es nicht so viele Wörter gibt <null>, sonst '' (Leerstring).
TestSQL
SELECT 'ABC' AS ISCORRECT, F_FINDNTHWORD('ABC 123 45678 9123', 0) FROM RDB$DATABASE;
SELECT '123' AS ISCORRECT, F_FINDNTHWORD('ABC 123 45678 9123', 1) FROM RDB$DATABASE;
SELECT '' AS ISCORRECT, F_FINDNTHWORD('ABC 123 45678 9123', 5) FROM RDB$DATABASE;
SELECT NULL AS ISCORRECT, F_FINDNTHWORD(NULL, NULL) FROM RDB$DATABASE;
SELECT NULL AS ISCORRECT, F_FINDNTHWORD('ABC 123 45678 9123', 5) FROM RDB$DATABASE;
nach oben • go top •
F_FINDWORDINDEX kompatibel zu FreeUDFLib, FreeUDFLibC, FreeUDFLib AvERP
Entrypoint findwordindex nicht UTF-8 kompatibel - wenn benötigt bitte nachfragen
Input CSTRING(32760)
INTEGER
String
zu überprüfenden Länge des Strings
Output INTEGER Sucht die in Parameter 2 angegebene Stelle im String. Ist diese Stelle im String vorhanden, ist das Ergebnis diese Stelle, ist die Stelle nicht im String vorhanden, ist das Ergebnis -1
Zählung beginnt bei 0.
TestSQL
SELECT 12 AS ISCORRECT, F_FINDWORDINDEX('Geburtstagsparty', 12) FROM RDB$DATABASE;
SELECT -1 AS ISCORRECT, F_FINDWORDINDEX('Geburtstagsparty', 16) FROM RDB$DATABASE;
SELECT NULL AS ISCORRECT, F_FINDWORDINDEX(NULL, NULL) FROM RDB$DATABASE;
nach oben • go top •
F_FINDWORDINDEXN
(F_FINDWORDINDEX)
Funktion von adhoc
Entrypoint findwordindexnull nicht UTF-8 kompatibel - wenn benötigt bitte nachfragen
Input CSTRING(32760)
INTEGER
String
zu überprüfenden Länge des Strings
Output INTEGER Sucht die in Parameter 2 angegebene Stelle im String. Ist diese Stelle im String vorhanden, ist das Ergebnis diese Stelle, ist die Stelle nicht im String vorhanden, ist das Ergebnis <null>.
Zählung beginnt bei 0. FireBird 2.0 Variante für F_FINDWORDINDEX mit Ergebnis <null> statt -1.
TestSQL
SELECT  NULL AS ISCORRECT, F_FINDWORDINDEXN('Geburtstagsparty', 16) FROM RDB$DATABASE;
nach oben • go top •
ab ersetzbar durch CHARACTER_LENGTH oder CHAR_LENGTH
F_STRINGLENGTH (..4, ..8, ..32)
F_BIGSTRINGLENGTH
kompatibel zu FreeUDFLib, FreeUDFLibC, FreeUDFLib AvERP, GrUDF
Input/Output-kompatibel zu rFunc (STRLEN)
Entrypoint stringlength nicht UTF-8 kompatibel - benutze U_STRINGLENGTH (...4, ...8)
U_STRINGLENGTH (..4, ..8)
Funktion von adhoc
Entrypoint u_stringlength UTF-8 kompatibel
Input CSTRING(32760) String, dessen Länge ermittelt werden soll
Output INTEGER Länge des Strings, berücksichtigt dabei auch einfache Leerzeichen am Ende
F_STRINGLENGTH und F_BIGSTRINGLENGTH dürfen nicht in einem SQL verwendet werden.
TestSQL
SELECT 17 AS ISCORRECT, F_STRINGLENGTH('Dies ist ein Test') FROM RDB$DATABASE;
SELECT 19 AS ISCORRECT, F_STRINGLENGTH('Dies ist ein Test  ') FROM RDB$DATABASE;
SELECT NULL AS ISCORRECT, F_STRINGLENGTH(NULL) FROM RDB$DATABASE;
SELECT 10 AS ISCORRECT, U_STRINGLENGTH('Číslicový ') FROM RDB$DATABASE;
SELECT NULL AS ISCORRECT, U_STRINGLENGTH(NULL) FROM RDB$DATABASE;
nach oben • go top •
F_STRINGLISTITEM kompatibel zu GrUDF
Entrypoint stringlistitem UTF-8 kompatibel
Input CSTRING(32760)
CSTRING(254)
Stringliste im Format ”n=..”,”m=..”, u.s.w.
Wert aus der Liste, der ausgegeben werden soll
Output CSTRING(1024) Sucht in einer Zeichenkette, die wie eine Stringliste ( NAME=Value) aufgebaut ist, nach dem Namen und gibt dann vollständig NAME=Value zurück.
TestSQL
SELECT '2=gelb' AS ISCORRECT, F_STRINGLISTITEM('"1=blau","2=gelb","3=grün","4=rot"', '2') FROM RDB$DATABASE;
SELECT NULL AS ISCORRECT, F_STRINGLISTITEM(NULL, NULL) FROM RDB$DATABASE;
nach oben • go top •
F_WORDCOUNT Funktion von adhoc
Entrypoint wordcount UTF-8 kompatibel
Input CSTRING(32760) String, in dem die Wörter gezählt werden sollen
Output INTEGER Anzahl der Wörter
Ein Wort endet durch ein oder mehrere Leerzeichen, TAB oder CRLF
TestSQL
SELECT 4 AS ISCORRECT, F_WORDCOUNT('ABC 123 45678 9123') FROM RDB$DATABASE;
SELECT NULL AS ISCORRECT, F_WORDCOUNT(NULL) FROM RDB$DATABASE;
nach oben • go top •
F_RWORDCOUNT Input/Output-kompatibel zu rFunc (WORDCOUNT)
Entrypoint r_wordcount nicht UTF-8 kompatibel - benutze F_WORDCOUNT
Input CSTRING(32760)
CSTRING(31)
SMALLINT
String, in dem die Wörter gezählt werden sollen
Wort-Trenner
Output INTEGER Anzahl der Wörter
TestSQL
SELECT 4 AS ISCORRECT, F_RWORDCOUNT('ABC 123 45678 9123', ' ', 0) FROM RDB$DATABASE;
SELECT NULL AS ISCORRECT, F_RWORDCOUNT(NULL, NULL, NULL) FROM RDB$DATABASE;
nach oben • go top •
F_STRINGCOUNT Funktion von adhoc
Entrypoint stringcount UTF-8 kompatibel
Input CSTRING(32760)
CSTRING(254)
String, in dem das Vorkommen des Wortes aus Parameter 2 gezählt werden soll
String, der in String 1 vorkommen soll
Output INTEGER Anzahl des Vorkommens von String 2 in String 1
F_RSTRINGCOUNT Input/Output-kompatibel zu rFunc (STRCOUNT)
Entrypoint r_stringcount UTF-8 kompatibel
Input CSTRING(254)
CSTRING(32760)
String, der in String 2 vorkommen soll
String, in dem das Vorkommen des Wortes aus Parameter 1 gezählt werden soll
Output INTEGER Anzahl des Vorkommens von String 1 in String 2
TestSQL
SELECT 2 AS ISCORRECT, F_STRINGCOUNT( 'ABC 123 45678 9123', '123') FROM RDB$DATABASE;
SELECT 2 AS ISCORRECT, F_RSTRINGCOUNT('123', 'ABC 123 45678 9123') FROM RDB$DATABASE;
SELECT 0 AS ISCORRECT, F_STRINGCOUNT( 'ABC 123 45678 9123', 'EFG') FROM RDB$DATABASE;
SELECT 0 AS ISCORRECT, F_RSTRINGCOUNT('EFG', 'ABC 123 45678 9123') FROM RDB$DATABASE;
SELECT NULL AS ISCORRECT, F_STRINGCOUNT(NULL, NULL) FROM RDB$DATABASE;
SELECT NULL AS ISCORRECT, F_RSTRINGCOUNT(NULL, NULL) FROM RDB$DATABASE;
nach oben • go top •
F_DOMAINFROMEMAIL Funktion von adhoc
Entrypoint domainfromemail UTF-8 kompatibel
Input CSTRING(254) eMail-String
Output CSTRING(254) aus der eMail extrahierte Domain
TestSQL
SELECT 'freeadhocudf.org' AS ISCORRECT, F_DOMAINFROMEMAIL('help@freeadhocudf.org') FROM RDB$DATABASE;
SELECT NULL AS ISCORRECT, F_DOMAINFROMEMAIL(NULL) FROM RDB$DATABASE;
vorige Seite • previous page • passée sitenach oben • go top • vers le hautnächste Seite • next page • prochain site