How to get one letter and one number from REGEX Oracle Sql query - oracle-sqldeveloper

Trying to get just "P1:" from this code but if I add numbers to the one it will output those as well. How do I restrict it to only take numbers 1-9 and have it display "NULL" if it's two digits?
select REGEXP_SUBSTR('P1:EMAIL', '[P]+\d+[:]') as test from dual;

You have included the + operator, which means match one or more of the character or class. If you want to match exactly one then you don't want that. You also don't need the square brackets:
select REGEXP_SUBSTR('P1:EMAIL', 'P\d:') as test from dual;
You might also want to anchor the pattern to the start of the string, but that isn't clear; if so then:
select REGEXP_SUBSTR('P1:EMAIL', '^P\d:') as test from dual;

Related

Delete specific digit in a number using PostgreSQL

I have a column named membership_number varchar(255) in the memberships table.
Here is some sample data:
0000001234
0000002345
0000003456
membership_number must have 10 digits. If a user enters a number that has less than 10 digits, then the missing places are filled with leading zeroes accordingly.
At the moment, I have some data in this column as follows:
00001234.0
00002345.1
00003456.2
I would like to delete the decimal point which is the 2nd to the last digit and then add a leading zero to handle all of these undesired membership numbers. What would be the best way to do this?
I am aware of SUBSTRING() and its parameters but couldn't make it work so far.
Please backup your data before trying this.
Would that work?
UPDATE tablename SET membership_number = concat('0',replace(membership_number,'.','')) WHERE membership_number LIKE '%._'
Substring is not the function you want, you want a combination of REPLACE and LPAD functions:
select lpad( replace (membership_number, '.', ''), 10, '0')
from menberships;
(table name assumed) And why if it must be 10 digits do you define it as length up to 255?

How to replace second occurrence of word in postgre sql using SQL?

Eg.
select regex_replace('the growth is growth for', '?','good','ig');
it should return
the growth is good for
You can match the word you are looking for, followed by everything up to the 2nd word, followed by the word you are looking for again, then replace it with the first two matches, followed by the word you want to replace it with.
For example:
SELECT regexp_replace(
'the growth is growth for lots of growth',
'(growth)(.*?)(\1)',
'\1\2good', 'ig'
);
regexp_replace
---------------------------------------
the growth is good for lots of growth
(1 row)
Here, the (.*?) is matching everything after the first "growth" text, but to stop matching once it hits the next "growth" text, denoted by \1, meaning whatever was matched in the first group enclosed in parentheses. The ? character makes it non-greedy, matching the minimum needed. If it weren't there, it would match as much as it can, which would keep going if there were more than 2 instances to only replace the last.

PostgreSQL query to find a particular pattern in a text column

I have a text column in my database table which contains values like
A/B
A/B/C
A/B/C/D
A/B/C/D/E
Now, I want to select only those rows where this column value contains maximum three occurrences of '/'.
For clarity - expected output should be:
A/B
A/B/C
A/B/C/D
Can anyone help me with such a query?
I think it would be easier to simply remove everything else and count the number of remaining characters:
where length(regexp_replace(the_column, '[^/]', '', 'g')) <= 3
Online example

Postgresql : How can I determine how many characters in a text

a column has type text and its data looks like "{U}{R}" or "{3}{U}{U}{U}".
How can I determine how many "U" contains this column?
I want to select those data who has at least one and at most three {U}.
You can remove the code U and compare the size before/after removing it. This difference is the number of occurrence.
select length('{3}{U}{U}{U}{R}{R}')-length(translate('{3}{U}{U}{U}{R}{R}','U','')) AS U_CNT;
--> 3
or more generaly
select length(colname)-length(translate(colname,'U','')) AS U_CNT;

How do I format a number of arbitrary length?

If I have data that includes a numeric column with values into the miillions (eg 63254830038), and I want to format the number as a US Dollar amount (eg. $63,254,830,038), I know I can use:
SELECT numeric_column, to_char(numeric_column, '$999G999G999G999') from table
to format the values, but to do so reliably I either have to include an unnecessarily long text string ('$999G999G999G999') or know the maximum number of possible digits. Is there a way to say, broadly, "group numbers with a comma" instead of explicitly saying "group the hundreds, group the thousands, Oh! and please group the millions"?
You just need cast integer to money type.
E.g.:
tests=> select cast(63254830038 as money);
Or alternative syntax:
tests=> select 6323254830038::money;
And output (I'm from Poland, so money type take my locales and set correct currency symbol):
money
----------------------
63.254.830.038,00 zł
Monetary Types documentation.
You can try something like this (works in sql-server, not sure about postgresql)
select convert(varchar,cast('63254830038' as money),1)
You could do things the hard way using regular expressions: convert the number into a string, reverse it, use regexp_replace to insert commas between pairs of 3 digits, and then reverse it again:
select '$' || reverse(regexp_replace(
reverse(numeric_column::varchar),
E'(\\d\\d\\d)(?=\\d)', '\1,', 'g'))
Explanation
The first argument to regexp_replace is the expression to match, which contains two parts:
(\\d\\d\\d) means 3 digits, which are captured
(?=\\d) is a positive lookahead constraint of a single digit, meaning the match only counts if there is a digit following it. (That is, this digit is checked to exist, but it does not count as part of the match.)
The second argument is what to replace with: the 3 captured digits, plus a comma.
The third argument 'g' is a flag indicating that it should match and replace as many times as possible.
For more information on regular expressions in PostgreSQL, see the documentation.