Bigint

MS Access Data Types

Data type	Description	Storage
Text	Use for text or combinations of text and numbers. 255 characters maximum
Memo	Memo is used for larger amounts of text. Stores up to 65,536 characters. Note: You cannot sort a memo field. However, they are searchable
Byte	Allows whole numbers from 0 to 255	1 byte
Integer	Allows whole numbers between -32,768 and 32,767	2 bytes
Long	Allows whole numbers between -2,147,483,648 and 2,147,483,647	4 bytes
Single	Single precision floating-point. Will handle most decimals	4 bytes
Double	Double precision floating-point. Will handle most decimals	8 bytes
Currency	Use for currency. Holds up to 15 digits of whole dollars, plus 4 decimal places. Tip: You can choose which country’s currency to use	8 bytes
AutoNumber	AutoNumber fields automatically give each record its own number, usually starting at 1	4 bytes
Date/Time	Use for dates and times	8 bytes
Yes/No	A logical field can be displayed as Yes/No, True/False, or On/Off. In code, use the constants True and False (equivalent to -1 and 0). Note: Null values are not allowed in Yes/No fields	1 bit
Ole Object	Can store pictures, audio, video, or other BLOBs (Binary Large OBjects)	up to 1GB
Hyperlink	Contain links to other files, including web pages
Lookup Wizard	Let you type a list of options, which can then be chosen from a drop-down list	4 bytes

❮ Previous
Next ❯

Сравнение значений sql_variant

Тип sql_variant находится на вершине иерархического списка преобразования типов данных. Для сравнения данных типа sql_variant иерархия типов данных SQL Server разбивается на семейства типов.

Иерархия типов данных	Семейство типов данных
sql_variant	sql_variant
datetime2	Дата и время
datetimeoffset	Дата и время
datetime	Дата и время
smalldatetime	Дата и время
date	Дата и время
time	Дата и время
float	Приблизительное числовое значение
real	Приблизительное числовое значение
decimal	Точное числовое значение
money	Точное числовое значение
smallmoney	Точное числовое значение
bigint	Точное числовое значение
int	Точное числовое значение
smallint	Точное числовое значение
tinyint	Точное числовое значение
bit	Точное числовое значение
nvarchar	Юникод
nchar	Юникод
varchar	Юникод
char	Юникод
varbinary	Двоичные данные
binary	Двоичные данные
uniqueidentifier	Уникальный идентификатор

К сравнениям типов sql_variant применяются указанные ниже правила.

• При сравнении значений sql_variant различных базовых типов данных, находящихся в разных семействах типов данных, большим из двух значений считается то, семейство типа данных которого находится выше в иерархии.
• При сравнении значений sql_variant различных базовых типов данных, находящихся в одном семействе типов данных, значение, базовый тип данных которого находится ниже в иерархии, неявно приводится к другому типу данных, после чего производится сравнение.
• При сравнении значений sql_variant типа данных char, varchar, nchar или nvarchar их параметры сортировки сначала сравниваются на основе следующих критериев: код языка, версия кода языка, флаги сравнения и идентификатор сортировки. Каждый из этих критериев сравнивается как целочисленное значение в приведенном порядке. Если все эти критерии равны, то сами строковые значения сравниваются в соответствии с параметрами сортировки.

Агрегатные функции

Агрегатные функции выполняют вычисление на наборе значений и возвращают одиночное значение. Они допускаются в списке выбора или в предложении HAVING инструкции SELECT. Агрегатную функцию можно использовать в сочетании с предложением GROUP BY для статистических вычислений на основе категорий строк. Используйте предложение OVER для вычисления статистического значения на основе определенного диапазона значений. Предложение OVER не может следовать за агрегатными функциями GROUPING и GROUPING_ID.

Все агрегатные функции являются детерминированными. Это означает, что они всегда возвращают одинаковый результат для одинаковых входных значений. Дополнительные сведения см. в статье Детерминированные и недетерминированные функции.

Remarks

sql_variant может использоваться в столбцах, параметрах, переменных и значениях, возвращаемых определяемыми пользователем функциями. sql_variant позволяет этим объектам баз данных поддерживать значения других типов данных.

Столбец типа sql_variant может содержать строки различных типов данных. Например, в столбце, определенном как sql_variant, могут храниться значения int, binary и char.

Максимальная длина значения типа данных sql_variant составляет 8016 байт. Сюда входят сведения о базовом типе и значение базового типа. Максимальная длина значения соответствующего базового типа составляет 8 000 байт.

Перед тем как задействовать тип данных sql_variant в таких операциях, как сложение и вычитание, его нужно привести к значению базового типа данных.

Типу данных sql_variant может быть присвоено значение по умолчанию. Этот тип данных в качестве значения может содержать значение NULL, однако значению NULL не будет соответствовать базовый тип. Кроме того, тип данных sql_variant не может в качестве базового иметь другой тип данных sql_variant.

Уникальный, первичный или внешний ключ может содержать столбцы типа sql_variant, но общая длина значений данных, составляющих ключ определенной строки, не должна превышать максимальную длину индекса. Эта длина составляет 900 байт.

Таблица может иметь любое количество столбцов типа sql_variant.

Тип sql_variant нельзя использовать в инструкциях CONTAINSTABLE и FREETEXTTABLE.

Протокол ODBC поддерживает тип sql_variant не полностью. Поэтому столбцы типа sql_variant, запрашиваемые через поставщик Microsoft OLE DB для ODBC (MSDASQL), возвращаются в виде двоичных данных. Например, столбец типа sql_variant, содержащий строку «PS2091», возвращается в виде 0x505332303931.

Решение

Для обхода этих ограничений JavaScript- разработчики представляют большие целые числа, используя тип данных String. Например, API Twitter добавляет строковую версию идентификаторов к объектам в ответах, пересылаемых в формате JSON. Также разработан целый ряд библиотек, таких как bignumber.js, чтобы упростить работу с большими целыми числами.

Благодаря типу данных BigInt приложениям больше не требуется обходной путь для безопасного представления целых чисел за пределами Number.MAX_SAFE_INTEGER и Number.MIN_SAFE_INTEGER. Арифметические операции над большими целыми числами теперь могут выполняться в JavaScript без риска потери точности.

Дополнительным преимуществом использования BigInt вместо сторонней библиотеки является лучшая производительность кода во время выполнения.

Чтобы создать BigInt, добавьте n в конец целого числа. Для сравнения:

console.log(9007199254740995n);    // → 9007199254740995n
console.log(9007199254740995);     // → 9007199254740996

Также можно вызвать конструктор BigInt():

BigInt("9007199254740995");    // → 9007199254740995n

Значения BigInt также могут быть записаны в двоичной, восьмеричной или шестнадцатеричной системе исчисления:

// двоичная
console.log(0b100000000000000000000000000000000000000000000000000011n); 
// → 9007199254740995n
// шестнадцатеричная
console.log(0x20000000000003n);
// → 9007199254740995n
// восьмеричная
console.log(0o400000000000000003n);
// → 9007199254740995n
// заметьте, что старая форма восьмеричной записи не поддерживается 
console.log(0400000000000000003n);
// → синтаксическая ошибка

Но вы не сможете использовать оператор строгого равенства для сравнения BigInt с обычным числом, потому что они разного типа данных:

console.log(10n === 10);    // → false
console.log(typeof 10n);    // → bigint
console.log(typeof 10);     // → number

Вместо этого можно использовать оператор равенства, который выполняет неявное преобразование типов данных перед компиляцией:

console.log(10n == 10);    // → true

В BigInt могут использоваться все арифметические операторы, кроме унарного оператора плюс (+):

10n + 20n;    // → 30n
10n - 20n;    // → -10n
+10n;         // → Ошибка: нельзя преобразовать значение BigInt value в number
-10n;         // → -10n
10n * 20n;    // → 200n
20n / 10n;    // → 2n
23n % 10n;    // → 3n
10n ** 3n;    // → 1000n
const x = 10n;
++x;          // → 11n
--x;          // → 9n

Некоторые программы могут полагаться на инвариант, в котором оператор + всегда создаёт Number или выдает исключение. Изменение поведения оператора + также приведет к нарушению кода asm.js.

При использовании BigInt ожидается, что арифметические операторы будут возвращать значение BigInt. Поэтому результат работы оператора деления (/) автоматически округляется до ближайшего целого числа. Например:

25 / 10;      // → 2.5
25n / 10n;    // → 2n

Неявное преобразование типа

При неявном преобразовании типов данных может потеряться информация, поэтому операции между BigInt и Number не допускаются. При операциях с большими целыми числами и чисел с плавающей запятой результирующее значение может быть представлено как BigInt или Number. Рассмотрим следующий пример:

(9007199254740992n + 1n) + 0.5

Результат этого выражения находится вне диапазона BigInt и Number. Число с дробной частью не может быть точно преобразовано в BigInt. И BigInt больше 253 не может быть точно преобразовано в Number.

Из-за этого невозможно выполнять арифметические операции между Number и BigInt. Попытка сделать это вызовет ошибку TypeError:

10 + 10n;    // → TypeError
Math.Max(2n, 4n, 6n);    // → TypeError

Но операторы сравнения не следуют этому правилу:

10n > 5;    // → true

Если вы хотите выполнить арифметические вычисления с BigInt и Number,  сначала необходимо определить область, в которой должна быть выполнена операция. Для этого преобразуйте любой из операндов, вызвав конструктор Number() или BigInt():

BigInt(10) + 10n;    // → 20n
// или
10 + Number(10n);    // → 20

Число BigInt считается истинным значением, если оно не равно 0n:

if (5n) {
    // этот блок кода будет выполнен 
}
if (0n) {
    // а этот нет
}

При сортировке массива, состоящего из элементов BigInt и Number, не происходит явного преобразования типов:

const arr = ;
arr.sort();    // → 

Битовые операторы, такие как |, &, <<, >> и ^, работают с BigInt так же, как с Number. Смешанные операнды не допускаются. Вот некоторые примеры:

90 | 115;      // → 123
90n | 115n;    // → 123n
90n | 115;     // → TypeError

Статус-кво: Number

Примитивный тип данных в JavaScript представлен числами с плавающей запятой двойной точности. Константа содержит максимально возможное целое число, которое можно безопасно увеличить на единицу. Его значение равно .

Примечание: для удобства чтения я группирую цифры, используя символы подчеркивания в качестве разделителей. Соответствующее предложение позволит использовать такую запись для обычных числовых литералов JavaScript.

Его увеличение на единицу даёт ожидаемый результат:

Но если мы увеличим его ещё на единицу, не сможет точно сохранить результат:

Обратите внимание, что результат выражения будет равен результату выражения. Поэтому всегда, когда мы получаем конкретно это значение в JavaScript, нельзя сказать, является ли оно точным или нет

Любые вычисления с целыми числами вне безопасного целочисленного диапазона (т. е. от до ) потенциально не точны. По этой причине мы можем полагаться только на целочисленные значения в безопасном диапазоне.

Примеры

A. Объявление переменной типа table

В следующем примере создается переменная типа , в которой хранятся значения, задаваемые в предложении OUTPUT инструкции UPDATE. Две следующие инструкции возвращают значения в табличную переменную , а результаты операции обновления — в таблицу . Результаты в столбце отличаются от значений в столбце таблицы . Это связано с тем, что триггер , обновляющий значение до текущей даты, был определен для таблицы . Однако столбцы, возвращенные из , отражают состояние данных перед срабатыванием триггеров. Дополнительные сведения см. в статье Предложение OUTPUT (Transact-SQL).

Б. Создание встроенной функции с табличным значением

Результатом следующего примера является встроенная функция, возвращающая табличное значение. Для каждого из товаров, проданных в магазине, она возвращает три столбца: , и статистику с начала года по магазину — .

При вызове этой функции выполняется следующий запрос.

Пример с несколькими выражениями

Затем давайте посмотрим, как имитировать запрос INTERSECT в MySQL, который возвращает более одного столбца.

Во-первых, так вы должны использовать оператор INTERSECT для возврата нескольких выражений.

MySQL

SELECT contact_id, last_name, first_name
FROM contacts
WHERE contact_id < 100
INTERSECT
SELECT customer_id, last_name, first_name
FROM customers
WHERE last_name <> ‘Johnson’;

1 2 3 4 5 6 7

SELECTcontact_id,last_name,first_name FROMcontacts WHEREcontact_id<100 INTERSECT SELECTcustomer_id,last_name,first_name FROMcustomers WHERElast_name<>’Johnson’;

Опять же, поскольку вы не можете использовать оператор INTERSECT в MySQL, вы можете использовать предложение EXISTS в более сложных ситуациях для имитации запроса INTERSECT следующим образом:

MySQL

SELECT contacts.contact_id, contacts.last_name, contacts.first_name
FROM contacts
WHERE contacts.contact_id < 100
AND EXISTS (SELECT *
FROM customers
WHERE customers.last_name <> ‘Markoski’
AND customers.customer_id = contacts.contact_id
AND customers.last_name = contacts.last_name
AND customers.first_name = contacts.first_name);

1 2 3 4 5 6 7 8 9

SELECTcontacts.contact_id,contacts.last_name,contacts.first_name FROMcontacts WHEREcontacts.contact_id<100 ANDEXISTS(SELECT* FROMcustomers WHEREcustomers.last_name<>’Markoski’ ANDcustomers.customer_id=contacts.contact_id ANDcustomers.last_name=contacts.last_name ANDcustomers.first_name=contacts.first_name);

В этом более сложном примере вы можете использовать предложение EXISTS для возврата нескольких выражений, которые существуют как в таблице contacts, где contact_id меньше 100, так и в таблице customers, где last_name не равно ‘Markoski’.

Поскольку вы выполняете INTERSECT, вам необходимо соединить пересекающиеся поля следующим образом:

AND customers.customer_id = contacts.contact_id
AND customers.last_name = contacts.last_name
AND customers.first_name = contacts.first_name

Это соединение выполняется для того, чтобы поля customer_id, last_name и first_name из таблицы customers пересекались бы с полями contact_id, last_name и first_name из таблицы contacts.

Тип данных UNIQUEIDENTIFIER

Как можно судить по его названию, тип данных UNIQUEIDENTIFIER является однозначным идентификационным номером, который сохраняется в виде 16-байтовой двоичной строки. Этот тип данных тесно связан с идентификатором GUID (Globally Unique Identifier — глобально уникальный идентификатор), который гарантирует однозначность в мировом масштабе. Таким образом, этот тип данных позволяет однозначно идентифицировать данные и объекты в распределенных системах.

Инициализировать столбец или переменную типа UNIQUEIDENTIFIER можно посредством функции NEWID или NEWSEQUENTIALID, а также с помощью строковой константы особого формата, состоящей из шестнадцатеричных цифр и дефисов. Эти функции рассматриваются в следующей статье.

К столбцу со значениями типа данных UNIQUEIDENTIFIER можно обращаться, используя в запросе ключевое слово ROWGUIDCOL, чтобы указать, что столбец содержит значения идентификаторов. (Это ключевое слово не генерирует никаких значений.) Таблица может содержать несколько столбцов типа UNIQUEIDENTIFIER, но только один из них может иметь ключевое слово ROWGUIDCOL.

About the Proposal

Motivation: Why Do We Need Such Big Numbers?

There are a number of cases in JavaScript coding where integers larger than 253 come up — both instances where signed or unsigned 64-bit integers are needed and times where we may want integers even larger than 64-bits.

64-bit Use Cases

Often, other systems with which Javascript interacts provides data as 64-bit integers, which lose precision when coerced to Javascript Numbers.

These might come when reading certain machine registers or wire protocols or using protobufs or JSON documents that have GUIDs generated by 64-bit systems in them — including things like credit card or account numbers — which currently must remain strings in Javascript. (Note, however, s cannot be serialized to JSON directly. But you can use libraries like granola to serialize and deserialize BigInt and other JS datatypes to JSON.)

In node, may give some data as 64-bit integers, which has caused issues already:

fs.lstatSync('one.gif').ino
//  9851624185071828

fs.lstatSync('two.gif').ino
//  9851624185071828, duplicate, but different file!

Finally, 64-bit integers enable higher resolution — nanosecond! — timestamps. These will be put to use in the temporal proposal, currently in Stage 1.

Bigger Than 64-bit Use Cases

Integers larger than 64-bit values are most likely to arise when doing mathematical calculations with larger integers, such as solving Project Euler problems or exact geometric calculations. Adding makes it possible to meet a reasonable user expectation of a high-level language that integer arithmetic will be «correct» and not suddenly overflow.

Design Goals, Or Why Is This Like This?

These principles guided the decisions made with this proposal. Check out for more in-depth discussion of each.

Find a balance between maintaining user intuition and preserving precision

In general, this proposal has aimed to work in a manner complementary to user intuition about how Javascript works. At the same time, the goal for this proposal is to add further affordances for precision to the language. Sometimes these can conflict.

When a messy situation comes up, this proposal errs on the side of throwing an exception rather than rely on type coercion and risk giving an imprecise answer. This is what’s behind throwing a on adding a and a and other : If we don’t have a good answer, better to not give one.

For more discussion of these choices, see Axel Rauschmeyer’s proposal and further discussion of its effects on Numbers. We ended up concluding that it would be impractical to provide transparent interoperability between Number and BigInt.

Don’t break math

The semantics of all operators should ideally be based on some mathematical first principles, to match developer expectations. The division and modulo operators are based on conventions from other programming languages for integers.

Don’t break JavaScript ergonomics

This proposal comes with built-in operator overloading in order to not make s too ugly to be usable. One particular hazard, if were to be operated on with static methods, is that users may convert the into a in order to use the operator on it—this would work most of the time, just not with big enough values, so it might pass tests. By including operator overloading, it would be even shorter code to add the s properly than to convert them to , which minimizes the chance of this bug.

Don’t break the web

This proposal doesn’t change anything about the way Numbers work. The name was chosen in part to avoid compatibility risks carried by the more general name (and in part to make it clear that they are useful for the «big» cases).

Don’t break good performance

Design work here has been done in conjunction with prototyping in to ensure that the proposal is efficiently implementable.

Don’t break potential future value types extensions

When adding new primitives to the language, it is important to avoid giving them superpowers that would be very difficult to generalize. This is another good reason for to avoid mixed operands.

Mixed comparisons are a one-off exception to this principle, however, taken in support of the intuition design principle.

Don’t break a consistent model of JavaScript

This proposal adds a new primitive type with wrappers, similar to . As part of integrating s into the JavaScript specification, a high amount of rigor will be required to differentiate three types floating around in the specification: Mathematical values, s and s.

has been shipped in Chrome, Node, Firefox, and is underway in Safari.

Related specification proposals:

• BigInt WebAssembly JS API integration proposal
• HTML serialization of BigInt
• BigInt as an IndexedDB key

Структура DateTime

Последнее обновление: 18.08.2016

Для работы с датами и временем в .NET предназначена структура DateTime. Она представляет дату и время от 00:00:00 1 января 0001 года
до 23:59:59 31 декабря 9999 года.

Для создания нового объекта DateTime также можно использовать конструктор. Пустой конструктор создает начальную дату:

DateTime date1 = new DateTime();
Console.WriteLine(date1); // 01.01.0001 0:00:00

То есть мы получим минимально возможное значение, которое также можно получить следующим образом:

Console.WriteLine(DateTime.MinValue);

Чтобы задать конкретную дату, нужно использовать один из конструкторов, принимающих параметры:

DateTime date1 = new DateTime(2015, 7, 20); // год - месяц - день
Console.WriteLine(date1); // 20.07.2015 0:00:00

Установка времени:

DateTime date1 = new DateTime(2015, 7, 20, 18, 30, 25); // год - месяц - день - час - минута - секунда
Console.WriteLine(date1); // 20.07.2015 18:30:25

Если необходимо получить текущую время и дату, то можно использовать ряд свойств DateTime:

Console.WriteLine(DateTime.Now);
Console.WriteLine(DateTime.UtcNow);
Console.WriteLine(DateTime.Today);

Консольный вывод:

20.07.2015 11:43:33
20.07.2015 8:43:33
20.07.2015 0:00:00

Свойство берет текущую дату и время компьютера, — дата и время относительно времени по
Гринвичу (GMT) и — только текущая дата.

При работе с датами надо учитывать, что по умолчанию для представления дат применяется григорианский календарь. Но что будет, если мы захотим получить день недели для
5 октября 1582 года:

DateTime someDate = new DateTime(1582, 10, 5);
Console.WriteLine(someDate.DayOfWeek);

Консоль выстветит значение Tuesday, то есть вторник. Однако, как может быть известно из истории, впервые переход с юлианского календаря на григорианский
состоялся в октябре 1582 года. Тогда после даты 4 октября (четверг) (еще по юлианскому календарю) сразу перешли к 15 октября (пятница)(уже по григорианскому календарю).
Таким образом, фактически выкинули 10 дней. То есть после 4 октября шло 15 октября.

В большинстве случаев данный факт вряд ли как-то повлияет на вычисления, однако при работе с очень давними датами данный аспект следует учитывать.

Операции с DateTime

Основные операции со структурой DateTime связаны со сложением или вычитанием дат. Например, надо к некоторой дате прибавить или, наоборот,
отнять несколько дней.

Для добавления дат используется ряд методов:

• : добавляет к дате значение TimeSpan

• : добавляет к текущей дате несколько дней

• : добавляет к текущей дате несколько часов

• : добавляет к текущей дате несколько минут

• : добавляет к текущей дате несколько месяцев

• : добавляет к текущей дате несколько лет

Например, добавим к некоторой дате 3 часа:

DateTime date1 = new DateTime(2015, 7, 20, 18, 30, 25); // 20.07.2015 18:30:25
Console.WriteLine(date1.AddHours(3)); // 20.07.2015 21:30:25

Для вычитания дат используется метод Substract(DateTime date):

DateTime date1 = new DateTime(2015, 7, 20, 18, 30, 25); // 20.07.2015 18:30:25
DateTime date2 = new DateTime(2015, 7, 20, 15, 30, 25); // 20.07.2015 15:30:25
Console.WriteLine(date1.Subtract(date2)); // 03:00:00

Здесь даты различаются на три часа, поэтому результатом будет дата «03:00:00».

Метод Substract не имеет возможностей для отдельного вычитания дней, часов и так далее. Но это и не надо, так как мы можем передавать в метод
AddDays() и другие методы добавления отрицательные значения:

// вычтем три часа
DateTime date1 = new DateTime(2015, 7, 20, 18, 30, 25);  // 20.07.2015 18:30:25
Console.WriteLine(date1.AddHours(-3)); // 20.07.2015 15:30:25

Кроме операций сложения и вычитания еще есть ряд методов форматирования дат:

DateTime date1 = new DateTime(2015, 7, 20, 18, 30, 25);
Console.WriteLine(date1.ToLocalTime()); // 20.07.2015 21:30:25
Console.WriteLine(date1.ToUniversalTime()); // 20.07.2015 15:30:25
Console.WriteLine(date1.ToLongDateString()); // 20 июля 2015 г.
Console.WriteLine(date1.ToShortDateString()); // 20.07.2015
Console.WriteLine(date1.ToLongTimeString()); // 18:30:25
Console.WriteLine(date1.ToShortTimeString()); // 18:30

Метод преобразует время UTC в локальное время, добавляя смещение относительно времени по Гринвичу.
Метод , наоборот, преобразует локальное время во время UTC, то есть вычитает смещение относительно времени по Гринвичу.
Остальные методы преобразуют дату к определенному формату.

НазадВперед

Numeric типы данных

Ниже перечислены числовые типы данных в MySQL:

Синтаксис	Максимальный размер	Пояснение
BIT	Очень маленькое целочисленное значение, эквивалентное TINYINT (1). Подписанные значения варьируются от -128 до 127. Беззнаковые значения варьируются от 0 до 255.
TINYINT(m)	Очень маленькое целочисленное значение. Подписанные значения варьируются от -128 до 127. Беззнаковые значения варьируются от 0 до 255.
SMALLINT(m)	Малое целочисленное значение. Подписанные значения варьируются от -32768 до 32767. Беззнаковые значения варьируются от 0 до 65535.
MEDIUMINT(m)	Среднее целочисленное значение. Подписанные значения варьируются от -8388608 до 8388607. Беззнаковые значения варьируются от 0 до 16777215.
INT(m)	Стандартное целочисленное значение. Подписанные значения варьируются от -2147483648 до 2147483647. Беззнаковые значения варьируются от 0 до 4294967295.
INTEGER(m)	Стандартное целочисленное значение. Подписанные значения варьируются от -2147483648 до 2147483647. Беззнаковые значения варьируются от 0 до 4294967295.	Это синоним типа данных INT.
BIGINT(m)	Большое целочисленное значение. Подписанные значения варьируются от -9223372036854775808 до 9223372036854775807. Беззнаковые значения варьируются от 0 до 18446744073709551615.
DECIMAL(m,d)	Число с фиксированной точкой. m по умолчанию — 10, если не указано. d по умолчанию равно 0, если не указано.	Где m — всего цифр, а d — количество цифр после десятичного знака.
DEC(m,d)	Число с фиксированной точкой. m по умолчанию — 10, если не указано. d по умолчанию равно 0, если не указано.	Где m — всего цифр, а d — количество цифр после десятичного знака. Это синоним типа DECIMAL.
NUMERIC(m,d)	Число с фиксированной точкой. m по умолчанию — 10, если не указано. d по умолчанию равно 0, если не указано.	Где m — всего цифр, а d — количество цифр после десятичного знака. Это синоним типа DECIMAL.
FIXED(m,d)	Число с фиксированной точкой. m по умолчанию — 10, если не указано. d по умолчанию равно 0, если не указано.	Где m — всего цифр, а d — количество цифр после десятичного знака. (Представлено в MySQL 4.1) Это синоним типа DECIMAL.
FLOAT(m,d)	Число с плавающей точкой с одиночной точностью.	Где m — всего цифр, а d — количество цифр после десятичного знака.
DOUBLE(m,d)	Число с плавающей точкой с двойной точностью.	Где m — всего цифр, а d — количество цифр после десятичного знака. Это синоним типа данных DOUBLE.
DOUBLE PRECISION(m,d)	Число с плавающей точкой с двойной точностью.	Где m — всего цифр, а d — количество цифр после десятичного знака.
REAL(m,d)	Число с плавающей точкой с двойной точностью.	Где m — всего цифр, а d — количество цифр после десятичного знака. Это синоним типа данных DOUBLE.
FLOAT(p)	Число с плавающей точкой.	Где p — точность.
BOOL	Синонимы TINYINT (1)	Рассматривается как тип данных типа boolean, где значение 0 считается FALSE, а любое другое значение считается TRUE.
BOOLEAN	Синонимы TINYINT (1)	Рассматривается как тип данных типа boolean, где значение 0 считается FALSE, а любое другое значение считается TRUE.