Funciones matem de mysql.pdf

© All Rights Reserved

2 views

Funciones matem de mysql.pdf

© All Rights Reserved

- rudiments 6
- 6Ei 110105 SDHC trig review
- Physics Chapter 3 Answers
- Math Review
- Notes-2nd Order ODE Pt2
- statics of particles
- Precalculus MATH 1730 Final Exam Review
- formula of physics
- Notes Exercises Set01
- school work
- Solution Manual Mechanical Engineering Principles John Bird 5
- bsc_trigno
- 2013_SM2
- Revision 9709 Paper 1
- Statics of Particles
- Calculus Course 4
- Calculus Summary
- Trigo Equations Chapter Theory.pdf
- precalculus practice 1
- DERIVATIVES OF FUNGTION

You are on page 1of 28

2 Mathematical Functions

MySQL 5.0 Reference Manual :: 12 Functions and Operators :: 12.6 Numeric Functions and Operators :: 12.6.2 Mathematical Functions

« 12.6.1 Arithmetic Operators

12.7 Date and Time Functions »

12.6.2 Mathematical Functions

Section Navigation [Toggle]

Table 12.12 Mathematical Functions 12.6 Numeric Functions and

Operators

Name Description 12.6.1 Arithmetic Operators

ABS() Return the absolute value 12.6.2 Mathematical Functions

ACOS() Return the arc cosine

ASIN() Return the arc sine

ATAN2(), ATAN() Return the arc tangent of the two arguments

ATAN() Return the arc tangent

CEIL() Return the smallest integer value not less than the argument

CEILING() Return the smallest integer value not less than the argument

CONV() Convert numbers between different number bases

COS() Return the cosine

COT() Return the cotangent

CRC32() Compute a cyclic redundancy check value

DEGREES() Convert radians to degrees

EXP() Raise to the power of

FLOOR() Return the largest integer value not greater than the argument

LN() Return the natural logarithm of the argument

LOG10() Return the base-10 logarithm of the argument

LOG2() Return the base-2 logarithm of the argument

LOG() Return the natural logarithm of the first argument

MOD() Return the remainder

PI() Return the value of pi

POW() Return the argument raised to the specified power

POWER() Return the argument raised to the specified power

RADIANS() Return argument converted to radians

RAND() Return a random floating-point value

ROUND() Round the argument

SIGN() Return the sign of the argument

SIN() Return the sine of the argument

https://dev.mysql.com/doc/refman/5.0/en/mathematical-functions.html 1/28

6/10/2015 MySQL :: MySQL 5.0 Reference Manual :: 12.6.2 Mathematical Functions

TAN() Return the tangent of the argument

TRUNCATE() Truncate to specified number of decimal places

ABS( X )

mysql> SELECT ABS(2);

> 2

mysql> SELECT ABS(32);

> 32

ACOS( X )

Returns the arc cosine of X , that is, the value whose cosine is X . Returns NULL if X is not in the range 1 to 1.

mysql> SELECT ACOS(1);

> 0

mysql> SELECT ACOS(1.0001);

> NULL

mysql> SELECT ACOS(0);

> 1.5707963267949

ASIN( X )

Returns the arc sine of X , that is, the value whose sine is X . Returns NULL if X is not in the range 1 to 1.

mysql> SELECT ASIN(0.2);

> 0.20135792079033

mysql> SELECT ASIN('foo');

++

https://dev.mysql.com/doc/refman/5.0/en/mathematical-functions.html 2/28

6/10/2015 MySQL :: MySQL 5.0 Reference Manual :: 12.6.2 Mathematical Functions

| ASIN('foo') |

++

| 0 |

++

1 row in set, 1 warning (0.00 sec)

mysql> SHOW WARNINGS;

++++

| Level | Code | Message |

++++

| Warning | 1292 | Truncated incorrect DOUBLE value: 'foo' |

++++

ATAN( X )

Returns the arc tangent of X , that is, the value whose tangent is X .

mysql> SELECT ATAN(2);

> 1.1071487177941

mysql> SELECT ATAN(2);

> 1.1071487177941

ATAN( Y , X ), ATAN2( Y , X )

Returns the arc tangent of the two variables X and Y . It is similar to calculating the arc tangent of Y / X , except

that the signs of both arguments are used to determine the quadrant of the result.

mysql> SELECT ATAN(2,2);

> 0.78539816339745

mysql> SELECT ATAN2(PI(),0);

> 1.5707963267949

CEIL( X )

CEILING( X )

https://dev.mysql.com/doc/refman/5.0/en/mathematical-functions.html 3/28

6/10/2015 MySQL :: MySQL 5.0 Reference Manual :: 12.6.2 Mathematical Functions

mysql> SELECT CEILING(1.23);

> 2

mysql> SELECT CEILING(1.23);

> 1

For exact-value numeric arguments, the return value has an exact-value numeric type. For string or floating-point

arguments, the return value has a floating-point type.

Converts numbers between different number bases. Returns a string representation of the number N , converted

from base from_base to base to_base . Returns NULL if any argument is NULL. The argument N is interpreted as

an integer, but may be specified as an integer or a string. The minimum base is 2 and the maximum base is 36. If

to_base is a negative number, N is regarded as a signed number. Otherwise, N is treated as unsigned. CONV()

works with 64-bit precision.

mysql> SELECT CONV('a',16,2);

> '1010'

mysql> SELECT CONV('6E',18,8);

> '172'

mysql> SELECT CONV(17,10,18);

> 'H'

mysql> SELECT CONV(10+'10'+'10'+0xa,10,10);

> '40'

COS( X )

mysql> SELECT COS(PI());

> 1

COT( X )

mysql> SELECT COT(12);

https://dev.mysql.com/doc/refman/5.0/en/mathematical-functions.html 4/28

6/10/2015 MySQL :: MySQL 5.0 Reference Manual :: 12.6.2 Mathematical Functions

> 1.5726734063977

mysql> SELECT COT(0);

> NULL

CRC32( expr )

Computes a cyclic redundancy check value and returns a 32-bit unsigned value. The result is NULL if the argument

is NULL. The argument is expected to be a string and (if possible) is treated as one if it is not.

mysql> SELECT CRC32('MySQL');

> 3259397556

mysql> SELECT CRC32('mysql');

> 2501908538

DEGREES( X )

mysql> SELECT DEGREES(PI());

> 180

mysql> SELECT DEGREES(PI() / 2);

> 90

EXP( X )

Returns the value of e (the base of natural logarithms) raised to the power of X . The inverse of this function is LOG()

(using a single argument only) or LN().

mysql> SELECT EXP(2);

> 7.3890560989307

mysql> SELECT EXP(2);

> 0.13533528323661

mysql> SELECT EXP(0);

> 1

FLOOR( X )

https://dev.mysql.com/doc/refman/5.0/en/mathematical-functions.html 5/28

6/10/2015 MySQL :: MySQL 5.0 Reference Manual :: 12.6.2 Mathematical Functions

mysql> SELECT FLOOR(1.23);

> 1

mysql> SELECT FLOOR(1.23);

> 2

For exact-value numeric arguments, the return value has an exact-value numeric type. For string or floating-point

arguments, the return value has a floating-point type.

FORMAT( X , D )

Formats the number X to a format like '#,###,###.##', rounded to D decimal places, and returns the result as a

string. For details, see Section 12.5, “String Functions”.

HEX(N_or_S)

This function can be used to obtain a hexadecimal representation of a decimal number or a string; the manner in

which it does so varies according to the argument's type. See this function's description in Section 12.5, “String

Functions”, for details.

LN( X )

Returns the natural logarithm of X ; that is, the base-e logarithm of X . If X is less than or equal to 0, then NULL is

returned.

mysql> SELECT LN(2);

> 0.69314718055995

mysql> SELECT LN(2);

> NULL

This function is synonymous with LOG( X ). The inverse of this function is the EXP() function.

LOG( X ), LOG( B , X )

If called with one parameter, this function returns the natural logarithm of X . If X is less than or equal to 0, then NULL

is returned.

The inverse of this function (when called with a single argument) is the EXP() function.

mysql> SELECT LOG(2);

> 0.69314718055995

https://dev.mysql.com/doc/refman/5.0/en/mathematical-functions.html 6/28

6/10/2015 MySQL :: MySQL 5.0 Reference Manual :: 12.6.2 Mathematical Functions

mysql> SELECT LOG(2);

> NULL

If called with two parameters, this function returns the logarithm of X to the base B . If X is less than or equal to 0, or

if B is less than or equal to 1, then NULL is returned.

mysql> SELECT LOG(2,65536);

> 16

mysql> SELECT LOG(10,100);

> 2

mysql> SELECT LOG(1,100);

> NULL

LOG2( X )

mysql> SELECT LOG2(65536);

> 16

mysql> SELECT LOG2(100);

> NULL

LOG2() is useful for finding out how many bits a number requires for storage. This function is equivalent to the

expression LOG( X ) / LOG(2).

LOG10( X )

mysql> SELECT LOG10(2);

> 0.30102999566398

mysql> SELECT LOG10(100);

> 2

mysql> SELECT LOG10(100);

> NULL

https://dev.mysql.com/doc/refman/5.0/en/mathematical-functions.html 7/28

6/10/2015 MySQL :: MySQL 5.0 Reference Manual :: 12.6.2 Mathematical Functions

mysql> SELECT MOD(234, 10);

> 4

mysql> SELECT 253 % 7;

> 1

mysql> SELECT MOD(29,9);

> 2

mysql> SELECT 29 MOD 9;

> 2

MOD() also works on values that have a fractional part and returns the exact remainder after division:

mysql> SELECT MOD(34.5,3);

> 1.5

PI()

Returns the value of π (pi). The default number of decimal places displayed is seven, but MySQL uses the full

double-precision value internally.

mysql> SELECT PI();

> 3.141593

mysql> SELECT PI()+0.000000000000000000;

> 3.141592653589793116

POW( X , Y )

mysql> SELECT POW(2,2);

https://dev.mysql.com/doc/refman/5.0/en/mathematical-functions.html 8/28

6/10/2015 MySQL :: MySQL 5.0 Reference Manual :: 12.6.2 Mathematical Functions

> 4

mysql> SELECT POW(2,2);

> 0.25

POWER( X , Y )

RADIANS( X )

Returns the argument X , converted from degrees to radians. (Note that π radians equals 180 degrees.)

mysql> SELECT RADIANS(90);

> 1.5707963267949

RAND(), RAND( N )

Returns a random floating-point value v in the range 0 <= v < 1.0. If a constant integer argument N is specified, it

is used as the seed value, which produces a repeatable sequence of column values. In the following example, note

that the sequences of values produced by RAND(3) is the same both places where it occurs.

mysql> CREATE TABLE t (i INT);

Query OK, 0 rows affected (0.42 sec)

mysql> INSERT INTO t VALUES(1),(2),(3);

Query OK, 3 rows affected (0.00 sec)

Records: 3 Duplicates: 0 Warnings: 0

mysql> SELECT i, RAND() FROM t;

+++

| i | RAND() |

+++

| 1 | 0.61914388706828 |

| 2 | 0.93845168309142 |

| 3 | 0.83482678498591 |

+++

https://dev.mysql.com/doc/refman/5.0/en/mathematical-functions.html 9/28

6/10/2015 MySQL :: MySQL 5.0 Reference Manual :: 12.6.2 Mathematical Functions

3 rows in set (0.00 sec)

mysql> SELECT i, RAND(3) FROM t;

+++

| i | RAND(3) |

+++

| 1 | 0.90576975597606 |

| 2 | 0.37307905813035 |

| 3 | 0.14808605345719 |

+++

3 rows in set (0.00 sec)

mysql> SELECT i, RAND() FROM t;

+++

| i | RAND() |

+++

| 1 | 0.35877890638893 |

| 2 | 0.28941420772058 |

| 3 | 0.37073435016976 |

+++

3 rows in set (0.00 sec)

mysql> SELECT i, RAND(3) FROM t;

+++

| i | RAND(3) |

+++

| 1 | 0.90576975597606 |

| 2 | 0.37307905813035 |

| 3 | 0.14808605345719 |

+++

3 rows in set (0.01 sec)

The effect of using a nonconstant argument is undefined. As of MySQL 5.0.13, nonconstant arguments are not

permitted.

https://dev.mysql.com/doc/refman/5.0/en/mathematical-functions.html 10/28

6/10/2015 MySQL :: MySQL 5.0 Reference Manual :: 12.6.2 Mathematical Functions

To obtain a random integer R in the range i <= R < j , use the expression FLOOR( i + RAND() * ( j − i )). For

example, to obtain a random integer in the range the range 7 <= R < 12, you could use the following statement:

SELECT FLOOR(7 + (RAND() * 5));

You cannot use a column with RAND() values in an ORDER BY clause, because ORDER BY would evaluate the

column multiple times. However, you can retrieve rows in random order like this:

ORDER BY RAND() combined with LIMIT is useful for selecting a random sample from a set of rows:

RAND() is not meant to be a perfect random generator. It is a fast way to generate random numbers on demand that

is portable between platforms for the same MySQL version.

ROUND( X ), ROUND( X , D )

Rounds the argument X to D decimal places. The rounding algorithm depends on the data type of X . D defaults to 0

if not specified. D can be negative to cause D digits left of the decimal point of the value X to become zero.

mysql> SELECT ROUND(1.23);

> 1

mysql> SELECT ROUND(1.58);

> 2

mysql> SELECT ROUND(1.58);

> 2

mysql> SELECT ROUND(1.298, 1);

> 1.3

mysql> SELECT ROUND(1.298, 0);

> 1

mysql> SELECT ROUND(23.298, 1);

> 20

The return type is the same type as that of the first argument (assuming that it is integer, double, or decimal). This

means that for an integer argument, the result is an integer (no decimal places):

https://dev.mysql.com/doc/refman/5.0/en/mathematical-functions.html 11/28

6/10/2015 means that for an integer argument, the resultMySQL

is an ::integer

MySQL 5.0

(noReference

decimalManual :: 12.6.2 Mathematical Functions

places):

mysql> SELECT ROUND(150.000,2), ROUND(150,2);

+++

| ROUND(150.000,2) | ROUND(150,2) |

+++

| 150.00 | 150 |

+++

Before MySQL 5.0.3, the behavior of ROUND() when the argument is halfway between two integers depends on the

C library implementation. Different implementations round to the nearest even number, always up, always down, or

always toward zero. If you need one kind of rounding, you should use a well-defined function such as TRUNCATE()

or FLOOR() instead.

As of MySQL 5.0.3, ROUND() uses the following rules depending on the type of the first argument:

For exact-value numbers, ROUND() uses the “round half away from zero” or “round toward nearest” rule: A value

with a fractional part of .5 or greater is rounded up to the next integer if positive or down to the next integer if

negative. (In other words, it is rounded away from zero.) A value with a fractional part less than .5 is rounded down

to the next integer if positive or up to the next integer if negative.

For approximate-value numbers, the result depends on the C library. On many systems, this means that ROUND()

uses the "round to nearest even" rule: A value with any fractional part is rounded to the nearest even integer.

The following example shows how rounding differs for exact and approximate values:

mysql> SELECT ROUND(2.5), ROUND(25E1);

+++

| ROUND(2.5) | ROUND(25E1) |

+++

| 3 | 2 |

+++

SIGN( X )

Returns the sign of the argument as 1, 0, or 1, depending on whether X is negative, zero, or positive.

mysql> SELECT SIGN(32);

https://dev.mysql.com/doc/refman/5.0/en/mathematical-functions.html 12/28

6/10/2015 MySQL :: MySQL 5.0 Reference Manual :: 12.6.2 Mathematical Functions

> 1

mysql> SELECT SIGN(0);

> 0

mysql> SELECT SIGN(234);

> 1

SIN( X )

mysql> SELECT SIN(PI());

> 1.2246063538224e16

mysql> SELECT ROUND(SIN(PI()));

> 0

SQRT( X )

mysql> SELECT SQRT(4);

> 2

mysql> SELECT SQRT(20);

> 4.4721359549996

mysql> SELECT SQRT(16);

> NULL

TAN( X )

mysql> SELECT TAN(PI());

> 1.2246063538224e16

mysql> SELECT TAN(PI()+1);

> 1.5574077246549

TRUNCATE( X , D )

Returns the number X , truncated to D decimal places. If D is 0, the result has no decimal point or fractional part. D

https://dev.mysql.com/doc/refman/5.0/en/mathematical-functions.html 13/28

6/10/2015 MySQL :: MySQL 5.0 Reference Manual :: 12.6.2 Mathematical Functions

can be negative to cause D digits left of the decimal point of the value X to become zero.

mysql> SELECT TRUNCATE(1.223,1);

> 1.2

mysql> SELECT TRUNCATE(1.999,1);

> 1.9

mysql> SELECT TRUNCATE(1.999,0);

> 1

mysql> SELECT TRUNCATE(1.999,1);

> 1.9

mysql> SELECT TRUNCATE(122,2);

> 100

mysql> SELECT TRUNCATE(10.28*100,0);

> 1028

User Comments

Posted by [name withheld] on November 28 2002 12:27am [Delete] [Edit]

randomly but ALSO use LIMIT so he could page

results - of course random will be different each time.

the same session; so here is the idea:

is likely to stay the same for a session, perhaps

based on some session id, or timed-expiring cookie

value, etc, or from short-term stable HTTP headers.

each record (doesn't have to be unique but works

https://dev.mysql.com/doc/refman/5.0/en/mathematical-functions.html 14/28

6/10/2015 MySQL :: MySQL 5.0 Reference Manual :: 12.6.2 Mathematical Functions

well if it is).

Then:

LIMIT blah;

numeric_field+session_value will be the same for a

session, and numeric_field + session value are NOT

the same from row to row so we still get random

ordering.

Sam Liddicott

I might be caused by compiler ability to count to upto 30 places under zero. Win32 mysql probably mighe be compiled with 32bit compiler rather

than 64bit. -- Hyungjin Ahn(ahj6@hotmail.com)

You may need to compare columns in databases after converting say a string column to a numeric column. These comparisons are automatic

Example

in the WHERE clause you may have to do something like this

oem.oem_id=substring(sku,5,3)

Here sku is a string who substring starting from location 5 from left and then having total length of 3 is compared with a numeric value of oem_id

to satisfy the WHERE clause.

http://www.bitmechanic.com/mail-archives/mysql/May1997/0494.html

I wanted to round to the nearest 0 or 5 cents in currency and this query worked:

select round((((cost*100) - (cost*100)%5) /100), 2) from SessionCost;

https://dev.mysql.com/doc/refman/5.0/en/mathematical-functions.html 15/28

6/10/2015 MySQL :: MySQL 5.0 Reference Manual :: 12.6.2 Mathematical Functions

If "SELECT * FROM tab ORDER BY RAND()" doesn't work for you. Try to put a random value between the brackets.

Here is my work around for MySQL rounding issues (On most systems it rounds to the nearest even number on 5). This mess of a calculation will

round up always in mysql, which is how most people in the united states think about rounding:

This example rounds to 2 decimal places. If you want to round to three decimals just switch out the 2s for 3s and the 1000s for 10000s, etc.

It basically works by replacing all the fives beyond the two decimal places with sixes, which will always round up. Then calling the round function.

floor(num * 100 + .55)/100

In a list where some elements had priority and others not I needed to randomise the prioritised items and not the rest. The prioritised entries all

had a value of 1 in a field called 'enhanced' and all entries had an abbreviated name ('abbrev') that they were otherwise sorted by. Using

ORDER BY (RAND() * enhanced) desc, abbrev

I could change the order of the enhanced listings yet maintain an alphabetical listing thereafter.

As mentioned in the manual, ROUND function has problems with values near to the limit values. The same prblem is found in the format function

Let's see it:

round(1.15,1)=1.2 OK

round(1.25,1)=1.2 BAD, sould be 1.3

round(1.35,1)=1.4 OK

round(1.45,1)=1.4 BAD, sould be 1.5

round(1.55,1)=1.6 OK

And so on...

https://dev.mysql.com/doc/refman/5.0/en/mathematical-functions.html 16/28

6/10/2015 MySQL :: MySQL 5.0 Reference Manual :: 12.6.2 Mathematical Functions

A walkarround for this sould be to use truncate adding 0,06. The same problem in found in the format function.

+---------------+----------------+-----------------------+

| round(1.45,1) | FORMAT(1.45,1) | truncate(1.45+0.06,1) |

+---------------+----------------+-----------------------+

| 1.4 | 1.4 | 1.5 |

+---------------+----------------+-----------------------+

Of corse, if you want to use more than one digit, you should add as many 0 as you need to de value added in the truncate function. Note that in

case of using 2 digits, the result of format is correct but round stills failing. It is more reliable to do the calculation using your own formula, with

truncate.

+----------------+-----------------+-------------------------+

| round(1.145,2) | FORMAT(1.145,2) | truncate(1.145+0.006,2) |

+----------------+-----------------+-------------------------+

| 1.14 | 1.15 | 1.15 |

+----------------+-----------------+-------------------------+

Take special care when using the the unsafe version with grouping functions like SUM(), as the end result can be way off if there is a big mix of

negative/positive numbers.

sign(num) * truncate(abs(num)+0.06,1)

E.g...

+-----------------------+------------------------+-------------------------------------------+

| truncate(1.45+0.06,1) | truncate(-1.45+0.06,1) | sign(-1.45) * truncate(abs(-1.45)+0.06,1) |

+-----------------------+------------------------+-------------------------------------------+

| 1.5 | WRONG --> -1.3 | CORRECT --> -1.5 |

+-----------------------+------------------------+-------------------------------------------+

https://dev.mysql.com/doc/refman/5.0/en/mathematical-functions.html 17/28

6/10/2015 MySQL :: MySQL 5.0 Reference Manual :: 12.6.2 Mathematical Functions

Posted by Ken Halsted on January 25 2006 4:28pm [Delete] [Edit]

I finally had to come up with my own solution for rounding with currency in the U.S.

But mysql was returning: round(25.725,2) as 25.72 which was throwing off my calc.

if num=25.725

============================

truncate(num + 0.0051,2)

============================

Ken

The rounding functions above are a little bit off from what most people would consider standard rounding.

If you use 6 as the number you are adding to the digit beyond significance then you will be rounding up 0.4s as well as 0.5s.

Here is my method:

rounding to two decimals

TRUNCATE(num + (SIGN(num) * 0.005), 2)

example 1

TRUNCATE(0.004 + (SIGN(0.004) * 0.005),2) = TRUNCATE(0.009,2) = 0.00

example 2

TRUNCATE(0.005 + (SIGN(0.005) * 0.005),2) = TRUNCATE(0.010,2) = 0.01

TRUNCATE(num + (SIGN(num) * 0.0005), 3)

etc.

BTW this seems to be how PHP's round function works, so if you are trying to get calculations in PHP to match MySQL this is how I did it.

https://dev.mysql.com/doc/refman/5.0/en/mathematical-functions.html 18/28

6/10/2015 MySQL :: MySQL 5.0 Reference Manual :: 12.6.2 Mathematical Functions

Posted by Tim Reynolds on April 15 2006 7:01pm [Delete] [Edit]

FLOOR(i + RAND() * (j - i))

I only ever get results in the range of i to j-1.

Shouldn't it be

FLOOR(i + RAND() * (j - i + 1 )) ?

I am getting results in the range I need with that. Maybe I am missing something, maybe once in a great while there will be a result that is j+1 and

I have just not seen it.

CREATE FUNCTION IRAND(param1 INT, param2 INT) RETURNS INT

RETURN FLOOR(param1 + RAND() * (param2-param1+1)) ;

That is true. The RAND() function returns a value 0.0 <= x <= 1.0

Thus, the values '0.0' and '1.0' can be returned althoug the changes are very very little.

In the example, where one wants a value between 7 and 12 inclusive, the value of '12' will hardly ever be returned.

I wanted a value of '0' or '1' (i.e. yes or no), so I used FLOOR(RAND() + 0.5), cuz if I'd used FLOOR(i + RAND() * (j – i), i.e. FLOOR(0 + RAND() *

(1 – 0)) which evaluates to (FLOOR(RAND()), I would have gotten only one '1' and a trillillizillion 0's.

ROUND(X,Y)

ok i experienced like the description says different behaviour on rounding on different systems

so based on the examples by other ppl who might work for their issue but are neither save nor a

general purpose solution i have come up with my own solution for rounding up on 5

number : Y

general solution :

TRUNCATE((Y+SIGN(Y)*(POW(10,(1-X))/18)),X)

https://dev.mysql.com/doc/refman/5.0/en/mathematical-functions.html 19/28

6/10/2015 MySQL :: MySQL 5.0 Reference Manual :: 12.6.2 Mathematical Functions

y = 12.449

x=1

result : 12.5

Simple but effective function for rounding to two decimals correctly (eg. 0.625 rounds to 0.63), unlike with the broken 'round' function

RETURNS decimal(10,2)

DETERMINISTIC

SQL SECURITY DEFINER

COMMENT ''

BEGIN

return round_me;

END;

1. first SELECT finds out number of rows available, usnig a WHERE clause if desired.

2. web code chooses a random row from the number of rows (from step 1.) and saves this number in $x.

3. second SELECT (using the same WHERE clause in step 1.) uses LIMIT 1,$x.

Actually Order by Rand() Limit(1,X) won't work on larger sets, as it has to read through X-1 records to return the 1 you need.

In avarage it means reading through <NumberOfRecords>/2 records every time, thus it's slow.

Yes, using limit is a silly way of doing that. Why not just select with id = the random id you picked?

https://dev.mysql.com/doc/refman/5.0/en/mathematical-functions.html 20/28

6/10/2015 MySQL :: MySQL 5.0 Reference Manual :: 12.6.2 Mathematical Functions

rand_id = rand(max)

row = dbh.query("select * from table where id = #{rand_id}").fetch_hash

puts "Fetched: #{row['id']}"

Nate:

Doing it that way doesn't work for everyone, some id values less than the max id might no longer exist in the table due to deletes.

mysql_query('START TRANSACTION');

mysql_query('ROLLBACK');

It's similar to michael's idea (posted above), only he had the limit parameters in the wrong order.

Instead of using RAND and LIMIT tricks for randomness, with their limitations on speed, if you have a primary key that's an auto-incrementer, you

could do it with these two SELECT like so:

...then grab a random number (shown as $r below) between 1 and max in your code. Now return back to SQL like so:

...Then, to create the illusion of more randomness, just use an ORDER BY clause on the second SELECT above based on something arbitrary.

For instance, if 'articles' has a column like author name and another like category, you could change the SELECT statement above like:

https://dev.mysql.com/doc/refman/5.0/en/mathematical-functions.html 21/28

6/10/2015 MySQL :: MySQL 5.0 Reference Manual :: 12.6.2 Mathematical Functions

SELECT * FROM articles where pkey > $r ORDER BY category, name LIMIT $limit;

...So, by using this strategy, it's faster than having to randomly determine your pkeys and selecting only one record at a time.

In my case, I wanted to sort classified listings with some close approximation of randomness in order to rotate the listings, and this strategy has

worked for me.

After I had problems with the ROUND() function in an accounting application where i need commercial rounding I wrote this stored function that

works very well for my needs:

RETURN TRUNCATE((value * POW(10, preci)) + (IF(value = 0, 1,(value / ABS(value)))*(0.5 * POW(1, preci*-1))), 0) / POW(10, preci);

If you want to select more records randomly you can use following method:

SET @toGet=10;

SET @left=(SELECT COUNT(*) FROM tableName)+1;

SELECT *, @toGet:=@toGet-1

FROM tableName

WHERE (@left:=@left-1)>0 AND RAND()<@toGet/@left;

It's much faster than ORDER BY RAND() LIMIT 10 (especially if you want to fetch small random subset of rows stored in table) but if it happens

to return same set of rows, it returns them always in same order. If you want them to have random order then you have to scramble them after

fetching using subquery:

SET @toGet=10;

SET @left=(SELECT COUNT(*) FROM tableName)+1;

SELECT * FROM (

SELECT *, @toGet:=@toGet-1

FROM tableName

WHERE (@left:=@left-1)>0 AND RAND()<@toGet/@left

) t ORDER BY RAND()

or on client side.

Oddly truncate produces 2 different results for the same mathematical function with variations in placement of truncate in relation to a conditional:

https://dev.mysql.com/doc/refman/5.0/en/mathematical-functions.html 22/28

6/10/2015 MySQL :: MySQL 5.0 Reference Manual :: 12.6.2 Mathematical Functions

+------------+-------+

| version() | fscpm |

+------------+-------+

| 5.0.27-log | 0.18 |

+------------+-------+

+------------+-------+

| version() | fscpm |

+------------+-------+

| 5.0.27-log | 0.17 |

+------------+-------+

Nearest even rounding is not bad. In fact, it results in less statistically biased results than always rounding up.

If you reached this page looking for functions like MIN(a,b,...) and MAX(a,b,...) they are named LEAST()and GREATEST(), and are in section

11.2.3. Comparison Functions and Operators.

For those of you who need to implement banker's rounding in MySQL (handy if you're doing invoice reports and the numbers need to match up

with accounting software like Simply Accounting that use banker's rounding), this is what I use:

CREATE DEFINER=`root`@`%` FUNCTION `BROUND`( value DECIMAL(65,30), places TINYINT(3) UNSIGNED ) RETURNS decimal(65,30)

COMMENT 'WARNING over decimal(65,30) will round normally!'

DETERMINISTIC

RETURN

CASE WHEN

LOCATE( '.', value ) >= 1

AND LENGTH( SUBSTRING( value, LOCATE( '.', value ) +1 ) ) < 31

AND places > -1

AND LENGTH( value ) - LOCATE( '.', value ) > places

AND SUBSTRING( value, LOCATE( '.', value ) + places + 1, 1 ) = 5

https://dev.mysql.com/doc/refman/5.0/en/mathematical-functions.html 23/28

6/10/2015 MySQL :: MySQL 5.0 Reference Manual :: 12.6.2 Mathematical Functions

AND SUBSTRING( value, LOCATE( '.', value ) + places + (CASE WHEN places = 0 THEN -1 ELSE 0 END ), 1 ) % 2 = 1

THEN

SUBSTRING( value, 1, LOCATE( '.', value ) + places + (CASE WHEN places = 0 THEN -1 ELSE 0 END ) )

ELSE

ROUND( value, places )

END;

WARNINGS:

- The old function I had posted here before today was wrong, to anyone who used it I am deeply sorry.

- Also do not use Felipe's function below as it is broken because a correct BROUND(6.434503,3) function should indeed return 6.435, NOT

6.434, as there is a 3 to the right of the 5. However BROUND(6.434500,3) WILL return 6.434. In banker's rounding, the only difference between

regular rounding occurs when what is being rounded either ends in a 5, or ends in a 5 with a few zeroes after it. If however you do want this

incorrect behaviour for some reason, you can remove "AND SUBSTRING( value, LOCATE( '.', value ) + places + 2 ) = 0" from this or use Felipe's

function instead.

- Note that if you pass a value greater than 29 into my second parameter you will get regular rounding, because the DECIMAL data type has a

precision of 30, and to pass anything larger than 29 in the second parameter would mean you would have gone over that limit. To avoid getting a

fatal error when doing this, and for simplicity, I used strings in this function, and made it fail over to ROUND() in this instance.

The BROUND posted by Mike N on March 9 2010 4:47pm doesn't works with bround(6.434503,3). The correct result is 6,435 but the function

returns 6.434000000000000000000000000000.

RETURNS DECIMAL(32,16)

RETURN

IF(ABS(Val - ROUND(Val, Digits)) * POWER(10, Digits+1) = 5,

IF(CONVERT(TRUNCATE(ABS(Val) * POWER(10,Digits), 0),UNSIGNED) % 2,

ROUND(Val,Digits),

TRUNCATE(Val,Digits)

),

ROUND(Val, Digits)

https://dev.mysql.com/doc/refman/5.0/en/mathematical-functions.html 24/28

6/10/2015 MySQL :: MySQL 5.0 Reference Manual :: 12.6.2 Mathematical Functions

);

select BankersRound(1.346,3),BankersRound(4.735500,3),BankersRound(7.834500,3),BankersRound(2.983600,3),BankersRound(6.434503,3);

and i got

on MySQL 5.1.42

Before today, Felipe's comment above stating that my function was broken was correct. As of 2011-01-28, it is now correct, and actually his is

wrong, though his was more correct than my function before I fixed it today. See my comment above for an explanation of why this is.

I'm a bit confused. After some time thinking about your explanation and testing my function I still don't know why it's wrong. As you can see

select BankersRound(6.434503,3);

returns

6.4350000000000000

as there is a 3 to the right of the 5. So if can you help me to see why I'm wrong?

PS: Sorry for inconvenience, I don't want to be rude with you. For common purposes, for instace, if you have a decimal column (my case) you

can use my version. If I'm not wrong it's probably faster. Although if you need more precision or work with bigger numbers you can use Mike's

version. Finally I don't think we need to fight for this. ;-)

FLOOR, when its argument is a negative, is working in a mathematic manner. While FLOOR(2.5) returns 2, FLOOR(-2.5), however, returns -3. If

you feel strange this behavior use @v-MOD(@v,1) instead of FLOOR.

SET @v = - 2.5;

SELECT @v - MOD( @v , 1 ) , FLOOR( @v )

https://dev.mysql.com/doc/refman/5.0/en/mathematical-functions.html 25/28

6/10/2015 MySQL :: MySQL 5.0 Reference Manual :: 12.6.2 Mathematical Functions

You'll gain:

@v-MOD(@v,1) FLOOR(@v)

-2.000000000000000000000000000000 -3

In order words I needed to round up or down to the nearest 5 cents.

It took me some time to work it out so I thought I would document it here in order to save somebody else the hair loss.

ROUND( value / 5, 2 ) * 5.

ROUND( (v1 + ( v2 / 3 ) ) / 5, 2 ) * 5.

+--------+-------+------------+--------+

| v1 | v2 | simplecalc | answer |

+--------+-------+------------+--------+

| 46.25 | 24.50 | 54.416667 | 54.40 | // round down

| 46.25 | 44.05 | 60.933333 | 60.95 | // round up

| 79.15 | 24.50 | 87.316667 | 87.30 | // etc

| 79.15 | 44.05 | 93.833333 | 93.85 |

| 111.10 | 24.50 | 119.266667 | 119.25 |

| 111.10 | 44.05 | 125.783333 | 125.80 |

| 26.00 | 17.50 | 31.833333 | 31.85 |

| 45.50 | 15.50 | 50.666667 | 50.65 |

| 67.50 | 15.50 | 72.666667 | 72.65 |

| 26.00 | 31.55 | 36.516667 | 36.50 |

| 45.50 | 27.95 | 54.816667 | 54.80 |

| 67.50 | 27.95 | 76.816667 | 76.80 |

+--------+-------+------------+--------+

https://dev.mysql.com/doc/refman/5.0/en/mathematical-functions.html 26/28

6/10/2015 MySQL :: MySQL 5.0 Reference Manual :: 12.6.2 Mathematical Functions

ROUND( ( ( v1 + ( v2 / 3 ) + 0.03 ) ) / 5, 2 ) * 5

+--------+-------+------------+--------+

| v1 | v2 | simplecalc | answer |

+--------+-------+------------+--------+

| 46.25 | 24.50 | 54.416667 | 54.45 |

| 46.25 | 44.05 | 60.933333 | 60.95 |

| 79.15 | 24.50 | 87.316667 | 87.35 |

| 79.15 | 44.05 | 93.833333 | 93.85 |

| 111.10 | 24.50 | 119.266667 | 119.30 |

| 111.10 | 44.05 | 125.783333 | 125.80 |

| 26.00 | 17.50 | 31.833333 | 31.85 |

| 45.50 | 15.50 | 50.666667 | 50.70 |

| 67.50 | 15.50 | 72.666667 | 72.70 |

| 26.00 | 31.55 | 36.516667 | 36.55 |

| 45.50 | 27.95 | 54.816667 | 54.85 |

| 67.50 | 27.95 | 76.816667 | 76.85 |

+--------+-------+------------+--------+

Note: While CONV(N, from_base, to_base) does accept a string for N and returns a string. The return is still limited to type unsigned/signed

bigint.

SELECT @N, CONV(@N, 16, 10), ~0 as max_bigint_unsigned;

+------------------------------------------+----------------------+----------------------+

| @N | CONV(@N, 16, 10) | max_bigint_unsigned |

+------------------------------------------+----------------------+----------------------+

| 36cf9111723dba5bb0fe6e91465323d1390f252c | 18446744073709551615 | 18446744073709551615 |

+------------------------------------------+----------------------+----------------------+

https://dev.mysql.com/doc/refman/5.0/en/mathematical-functions.html 27/28

6/10/2015 MySQL :: MySQL 5.0 Reference Manual :: 12.6.2 Mathematical Functions

© 2015, Oracle Corporation and/or its affiliates

https://dev.mysql.com/doc/refman/5.0/en/mathematical-functions.html 28/28

- rudiments 6Uploaded bySarthak Chowdhuri
- 6Ei 110105 SDHC trig reviewUploaded byCarolyn Copeland Lang
- Physics Chapter 3 AnswersUploaded byAbovethesystem
- Math ReviewUploaded byjagan2rule
- Notes-2nd Order ODE Pt2Uploaded byHimanshu Sharma
- statics of particlesUploaded byJuniusBrutus
- Precalculus MATH 1730 Final Exam ReviewUploaded byvelisa815986
- formula of physicsUploaded byAbhishek Singh
- Notes Exercises Set01Uploaded byNo Name
- school workUploaded byrachna357
- Solution Manual Mechanical Engineering Principles John Bird 5Uploaded byridwansadely
- bsc_trignoUploaded byleo_3455
- 2013_SM2Uploaded bySophia Duong
- Revision 9709 Paper 1Uploaded byapi-25887606
- Statics of ParticlesUploaded bynsbaruaole
- Calculus Course 4Uploaded byAbhijit Kar Gupta
- Calculus SummaryUploaded byYusuf Nasir
- Trigo Equations Chapter Theory.pdfUploaded byAditya
- precalculus practice 1Uploaded byapi-248877347
- DERIVATIVES OF FUNGTIONUploaded bynormasulasa
- part1ch1Uploaded byRavi Khandelwal
- Suplemen_1aUploaded bysebelasmetergmailcom
- Network AnalysisUploaded byravin kumar
- Engineering Trigonometry Part 1.pdfUploaded byIamRoque Escobar Jaguio III
- Skmm3023 Ch03.Simultaneous.linear.eqns TutorialUploaded byMohamad Khairul Mohd Noor
- formulas4FJ4Uploaded byAmsalu Setey
- Math-11-Final-Exam-Review-Package-11-June-2012-smrd5g.docxUploaded bySean Lehmar Capariño
- EngMath(4)2012_2_HWsol_Chap11_11.1_11.4Uploaded byHeather Johnson
- Add SineUploaded byMonte Carlo Palado
- differentiation1.pdfUploaded bycesamav

- bill syllabusUploaded byapi-265461002
- Projectile MotionUploaded byguptaprabhu
- 8MA0-01 as Pure Mathematics May 2018 Mark Scheme (Final)Uploaded byZorain Sultan
- MTT101 Syllabus - SpringUploaded byshihabsultan
- TI-Nspire ReferenceGuide EnUploaded byMorrizon Rdz
- 2014-hsc-maths-ext-2.pdfUploaded byKyle N Samaroo
- Specimen (IAL) MS - C34 EdexcelUploaded byM. Amir
- Elliptic FunctionsUploaded byNshuti Rene Fabrice
- 3.1 Complex Numbers Extra (1)Uploaded byShalin Ramli
- OpenSCAD User Manual_Print version.pdfUploaded byqqwerty1982
- High Dive Unit ProblemUploaded byssooshi
- Embedded C Programming and the ATMEL AVR 2nd EditionUploaded byLSLLSL
- Applications of Trig Graphs (1)Uploaded bySSSSSSSSSS
- Trigonometry ExercisesUploaded byGuilherme Oliveira
- Pure 1Uploaded byMufaro Mutoti
- Matlab 1Uploaded byIchwan Setiawan
- Trigonometric EquationsUploaded byShivaRam J
- 1MM 17 T00 Orientation HandoutUploaded byAlyssa
- 4.3 HomeworkUploaded byPedro Rodriguez Jr.
- Calc 3 Cheat SheetUploaded byGloria Carrillo
- solvingTrigoFunc[1].docxUploaded byZarini Ahmad
- OBJECTIVE MATHEMATICS for IIT-JEE {Mains/Advance}Uploaded byWIN POINT Educations
- Chapter 4-Fourier SeriesUploaded bySarah Wahida
- DifferentiationUploaded byDawin Morna
- Secant MethodUploaded byjeffrey marapia
- c.pdfUploaded byJiyu
- vehicle roll estimatorUploaded byRaja Amer Azim
- Sample 3648Uploaded byP Singh Karki
- St Gabriels Prelim 2009 Em p1Uploaded byJASON_INGHAM
- Debra Ross - Pre-Calculus And Geometry.pdfUploaded byFabrícioPio