Текст книги "Основы программирования в Linux"
Автор книги: Нейл Мэтью
Соавторы: Ричард Стоунс
Жанры:
Программирование
,сообщить о нарушении
Текущая страница: 31 (всего у книги 67 страниц)
Прежде чем мы перейдем к более сложным программам, полезно взглянуть на то, как MySQL обрабатывает ошибки. СУРБД MySQL использует ряд возвращаемых числовых кодов, предоставляемых дескриптором подключения. К двум обязательным подпрограммам относятся следующие:
unsigned int mysql_errno(MYSQL *connection);
и
char *mysql_error(MYSQL *connection);
Вы можете получить код ошибки, обычно любое ненулевое значение, вызвав подпрограмму mysql_errno и передав ей дескриптор подключения. Если никакой код ошибки не установлен, возвращается ноль. Поскольку код обновляется при каждом вызове библиотечной функции, можно извлечь код только последней выполненной команды, за исключением двух подпрограмм обработки ошибок, которые не приводят к обновлению кода ошибки.
Возвращаемое значение – в действительности код ошибки, коды ошибок определены в файле include с именем errmsg.h или в файле mysqld_error.h. Оба файла можно найти в каталоге MySQL с именем include. Первый сообщает об ошибках клиентской стороны, а второй – об ошибках сервера.
Если вы предпочитаете текстовое сообщение об ошибке, можно вызвать подпрограмму mysql_error, которая вместо кода предоставляет осмысленное текстовое сообщение. Текст сообщения пишется в некоторую внутреннюю область статической памяти, поэтому для сохранения текста ошибки его следует скопировать куда– нибудь.
Вы можете вставить элементарную обработку ошибок в вашу программу для того, чтобы увидеть все это в действии. Возможно, вы уже заметили, что можно столкнуться с проблемой, поскольку подпрограмма mysql_real_connect в случае сбоя возвращает указатель NULL, лишая вас кода ошибки. Если дескриптор подключения сделать переменной, его все же можно получить при аварийном завершении mysql_real_connect.
Далее приведен файл connect2.c, демонстрирующий, как применять структуру дескриптора подключения без динамического выделения памяти для нее, а также как написать некоторый базовый программный код обработки ошибок. Внесенные изменения выделены цветом.
#include
#include
#include «mysql.h»
int main(int argc, char *argv[]) {
MYSQL my_connection;
mysql_init(&my_connection);
if (mysql_real_connect(&my_connection, «localhost», «rick»,
«I do not know», «foo», 0, NULL, 0)) {
printf(«Connection successn»);
mysql_close(&my_connection);
} else {
fprintf(stderr, «Connection failedn»);
if (mysql_errno(&my_connection)) {
fprintf(stderr, «Connection error %d: %sn»,
mysql_errno(&my_connection), mysql_error(&my_connection));
}
}
return EXIT_SUCCESS;
}
Вы смогли легко решить проблему, устранив перезапись вашего дескриптора подключения результатом, возвращаемым при аварийном завершении mysql_real_connect. И кроме того, это отличный пример еще одного способа применения структур дескрипторов подключения. Вы можете вызвать ошибку, выбрав некорректное имя пользователя или пароль, и получите код ошибки, подобный предлагаемому монитором mysql:
$ ./connect2
Connection failed
Connection error 1045: Access denied for user: 'rick@localhost' (Using password: YES)
$
Теперь, когда вы можете подключаться к вашей базе данных и корректно обрабатывать ошибки, самое время дать вашей программе реальную работу. У основной функции API, предназначенной для выполнения операторов языка SQL, подходящее имя.
int mysql_query(MYSQL *connection, const char *query);
He слишком сложная? Эта подпрограмма принимает указатель на дескриптор подключения и несколько, хочется надеяться, корректных SQL-операторов в виде текстовой строки (без завершения каждого из них точкой с запятой, как в мониторе mysql). В случае удачного завершения возвращается ноль. Вторую подпрограмму mysql_real_query можно применять при запросе двоичных данных, но в этой главе мы используем только подпрограмму mysql_query.
SQL-операторы, не возвращающие данных
Для простоты начнем с рассмотрения нескольких SQL-операторов, которые не возвращают данные: UPDATE, DELETE и INSERT.
Еще одна важная функция, которую мы рассмотрим, проверяет количество строк, затронутых запросом:
my_ulonglong mysql_affected_rows(MYSQL *connection);
Первое, что вы, вероятно, заметили в этой функции, – очень необычный тип возвращаемых данных. Из соображений переносимости применяется беззнаковый (unsigned) тип. Когда используется функция printf, рекомендуется приводить его к типу unsigned long (длинное беззнаковое) со спецификатором формата %lu. Эта функция возвращает количество строк, измененных предварительно выполненным запросом UPDATE, INSERT или DELETE. Возвращаемое значение, используемое в MySQL, может вас, озадачить, если у вас есть опыт работы с другими базами данных SQL. СУРБД MySQL возвращает количество строк, действительно измененных обновлением, в то время как многие другие СУБД будут считать запись измененной просто потому, что она соответствует одному из условий WHERE.
В основном в случае функций mysql_ возврат 0 означает отсутствие измененных строк, а положительное значение указывает на реальный результат, обычно количество строк, затронутых оператором.
Сначала следует создать таблицу children в вашей базе данных foo, если вы еще не сделали этого. Удалите (с помощью команды drop) любую существующую таблицу, чтобы быть уверенным в том, что вы имеете дело с чистым определением таблицы, и повторно отправьте идентификаторы, применяемые в столбце AUTO_INCREMENT.
$ mysql -u rick -p foo
Enter password:
Welcome to the MySQL monitor. Commands end with ; or g.
mysql> DROP TABLE children;
Query OK, 0 rows affected (0.58 sec)
mysql> CREATE TABLE children (
-> childno int(11) AUTO_INCREMENT NOT NULL PRIMARY KEY,
-> fname varchar(30),
-> age int
-> );
Query OK, 0 rows affected (0.09 sec)
mysql>
Теперь добавьте программный код в файл connect2.c, для того чтобы вставить новую строку в вашу таблицу. Назовите эту новую программу insert1.с. Учтите, что разбиение оператора на несколько строк объясняется физической шириной страницы; обычно вы не должны разбивать реальный SQL-оператор, если он не слишком длинный, в этом случае можно применить символ / в конце строки для переноса оставшейся части SQL-оператора на следующую строку.
#include
#include
#include «mysql.h»
int main(int argc, char *argv[]) {
MYSQL my_connection;
int res;
mysql_init(&my_connection);
if (mysql_real_connect(&my_connection, «localhost»,
«rick», «secret», «foo», 0, NULL, 0)) {
printf(«Connection successn»);
res = mysql_query(&my_connection,
«INSERT INTO children(fname, age) VALUES('Ann', 3)»);
if (!res) {
printf(«Inserted %lu rowsn»,
(unsigned long)mysql_affected_rows(&my_connection));
} else {
fprintf(stderr, «Insert error %d: %sn»,
mysql_errno(&my_connection), &mysql_error(&my_connection));
}
mysql_close(&my_connection);
} else {
fprintf(stderr, «Connection failedn»);
if (mysql_errno(&my_connection)) {
printf(stderr, «Connection error %d: %sn»,
mysql_errno(&my_connection), mysql_error(&my_connection));
}
}
return EXIT_SUCCESS;
}
Как и ожидалось, одна строка добавлена.
Теперь измените код, чтобы включить UPDATE вместо INSERT, и посмотрите на сообщение об измененных строках.
mysql_errno(&my_connection), mysql_error(&my_connection));
}
}
res = mysql_query(&my_connection,
«UPDATE children SET AGE = 4 WHERE fname = 'Ann'»);
if (!res) {
printf(«Updated %lu rowsn»,
(unsigned long)mysql_affected_rows(&my_connection));
} else {
fprintf (stderr, «Update error %d: %sn»,
mysql_errno(&my_connection), mysql_error(&my_connection));
}
Назовите эту программу update1.c. Она пытается задать возраст 4 года для всех детей с именем Ann.
Предположим, что ваша таблица children содержит следующие данные:
mysql> SELECT * from CHILDREN;
+–+–+–+
| childno | fname | age |
+–+–+–+
| 1 | Jenny | 21 |
| 2 | Andrew | 17 |
| 3 | Gavin | 9 |
| 4 | Duncan | 6 |
| 5 | Emma | 4 |
| 6 | Alex | 15 |
| 7 | Adrian | 9 |
| 8 | Ann | 3 |
| 9 | Ann | 4 |
| 10 | Ann | 3 |
| 11 | Ann | 4 |
+–+–+–+
11 rows in set (0.00 sec)
В вашей таблице есть четыре ребенка с именем Ann. Вы можете рассчитывать на то, что при выполнении программы update1 количество измененных строк будет равно четырем, т.е. числу строк, отбираемых по условию WHERE. Но если вы выполните программу, то увидите отчет программы об изменении только двух строк, поскольку учитываются только те строки, данные которых действительно нуждались в корректировке. Можно выбрать более традиционный вариант отчета, используя флаг CLIENT_FOUND_ROWS в функции mysql_real_connect:
if (mysql_real_connect(&my_connection, «localhost»,
«rick», «secret», «foo», 0, NULL, CLIENT_FOUND_ROWS)) {
Если восстановить данные в вашей базе данных и затем выполнить программу с приведенным изменением, она сообщит о четырех измененных строках.
Последняя странность функции mysql_affected_rows проявляется при удалении информации из базы данных. Если вы удаляете данные с помощью условия WHERE, mysql_affected_rows вернет ожидаемое вами количество удаленных строк. Но если в операторе DELETE нет условия WHERE, будут удалены все строки, но в сообщении программы о количестве строк, затронутых запросом, будет указан ноль. Это происходит потому, что MySQL оптимизирует удаление всех строк, заменяя многократные построчные удаления.
На подобное поведение не влияет флаг CLIENT_FOUND_ROWS.
Что же вы вставили?
Существует небольшая, но важная особенность вставки данных. Ранее мы упоминали столбец типа AUTO_INCREMENT, в который MySQL автоматически вставляет идентификаторы. Это свойство весьма полезно, особенно при наличии нескольких пользователей.
Рассмотрим определение таблицы еще раз:
CREATE TABLE children (
childno INTEGER AUTO_INCREMENT NOT NULL PRIMARY KEY,
fname VARCHAR(30),
age INTEGER
);
Как видите, столбец childno– поле типа AUTO_INCREMENT. Это замечательно, но когда вы вставили строку, как узнать, какой номер присвоен ребенку, чье имя вы только что вставили?
Можно выполнить оператор SELECT для того чтобы извлечь данные, отобранные по имени ребенка. Но это очень неэффективный способ и не гарантирующий уникальности выбора: допустим, что у вас есть два ребенка с одним и тем же именем. Или несколько пользователей могли быстро вставить данные, и появились другие добавленные строки между вашим оператором обновления и оператором SELECT. Поскольку выяснение значения столбца типа AUTO_INCREMENT – столь распространенная проблема, MySQL предлагает специальное решение в виде функции LAST_INSERT_ID().
Когда MySQL вставляет данные в столбец типа AUTO_INCREMENT, она отслеживает для каждого пользователя последнее присвоенное ею значение. Программы пользователей могут узнать его, просто используя в операторе SELECT специальную функцию LAST_INSERT_ID(), которая действует немного похоже на псевдостолбец.
Выполните упражнение 8.2.
Упражнение 8.2. Извлечение ID, сгенерированного в столбце типа AUTO_INCREMENT
Вы сможете увидеть, как это работает, вставив несколько значений в вашу таблицу и затем применив функцию LAST_INSERT_ID().
mysql> INSERT INTO children(fname, age) VALUES('Tom', 13);
Query OK, 1 row affected (0.06 sec)
mysql> SELECT LAST_INSERT_ID();
+–+
| last_insert_id() |
+–+
| 14 |
+–+
1 row in set (0.01 sec)
mysql> INSERT INTO children(fname, age) VALUES('Harry', 17);
Query OK, 1 row affected (0.02 sec)
mysql> SELECT LAST_INSERT_ID();
+–+
| last_insert_id() |
+–+
| 15 |
+–+
1 row in set (0.00 sec)
mysql>
Как это работает
При каждой вставке строки MySQL выделяет новое значение для столбца id и запоминает его, поэтому вы сможете узнать это значение с помощью функции LAST_INSERT_ID().
Если хотите поэкспериментировать, чтобы убедиться в уникальности возвращаемого номера в вашем сеансе, откройте еще один сеанс и вставьте другую строку. В исходном сеансе повторите выполнение оператора SELECT LAST_INSERT_ID();. Вы увидите, что номер не изменился, поскольку возвращаемый номер – последний, добавленный в текущем сеансе. Но если вы выполните оператор SELECT * FROM children, то увидите, что в другом сеансе действительно были вставлены данные.
Выполните упражнение 8.3.
Упражнение 8.3. Использование автоматически формируемых ID в программе на С
В этом примере вы измените вашу программу insert1.c, чтобы посмотреть, как она работает на С. Ключевые изменения выделены цветом. Назовите откорректированную программу insert2.c.
#include
#include
#include «mysql.h»
int main(int argc, char *argv[]) {
MYSQL my_connection;
MYSQL_RES* res_ptr;
MYSQL_ROW sqlrow;
int res;
mysql_init(&myconnection);
if (mysql_real_connect(&my_connection, «localhost»,
«rick», «bar», «rick», 0, NULL, 0)) {
printf(«Connection successn»);
res = mysql_query(&my_connection,
«INSERT INTO children(fname, age) VALUES('Robert', 7)»);
if (!res) {
printf(«Inserted %lu rowsn»,
(unsigned long)mysql_affected_rows(&my_connection));
} else {
fprintf(stderr, «Insert error %d: %sn»,
mysql_errno(&myconnection), mysql_error(&my_connection));
}
res = mysql_query(&my_connection, «SELECT LAST INSERT ID()»);
if (res) {
printf(«SELECT error %sn», mysql_error(&my_connection);
} else {
res_ptr= mysql_use_result(&my_connection);
if (res_ptr) {
while ((sqlrow = mysql_fetch_row(res_ptr))) {
printf(«We inserted childno %sn», sqlrow[0]);
}
mysql_free_result(res_ptr);
}
}
mysql_close(&my_connection);
} else {
fprintf(stderr, «Connection failedn»);
if (mysql_errno(&my_connection)) {
fprintf(stderr, «Connection error %d: %sn»,
mysql_errno(&my_connection), mysql_error(&my_connection));
}
}
return EXIT_SUCCESS;
}
Далее приведен вывод:
$ gcc -I/usr/include/mysql insert2.c -L/usr/lib/mysql -lmysqlclient -o insert2
$ ./insert2
Connection success
Inserted 1 rows
We inserted childno 6
$ ./insert2
Connection success
Inserted 1 rows
We inserted childno 7
Как это работает
После вставки строки вы извлекаете выделенный ID, применив функцию LAST_INSERT_ID() в обычном операторе SELECT. Затем вы использовали функцию mysql_use_result(), которую мы вскоре поясним, для извлечения данных из выполненного вами оператора SELECT и вывели их на экран. Сейчас не задумывайтесь всерьез о механизме извлечения значений, на следующих нескольких страницах мы дадим нужные пояснения.
Операторы, возвращающие данные
Основное назначение языка – конечно, извлечение данных, а не их добавление или обновление. Данные извлекаются с помощью оператора SELECT.
Примечание
MySQL также поддерживает SQL-операторы
SHOW,DESCRIBEиEXPLAIN, предназначенные для возврата результатов, но мы не собираемся рассматривать их в данной книге. Как обычно, в руководстве можно найти описание этих операторов.
Получение данных в вашем приложении на языке С обычно будет включать четыре шага:
1. Выполнение запроса.
2. Извлечение данных.
3. Обработка этих данных.
4. Наведение порядка при необходимости.
Так же, как в случае операторов INSERT и DELETE, вы воспользуетесь функцией mysql_query для отправки SQL-запроса. Далее вы извлечете данные о помощью функций mysql_store_result или mysql_use_result в зависимости от того, как хотите получить данные. Затем будет применена последовательность вызовов функции mysql_fetch_row для обработки данных. И наконец, вы используете функцию mysql_free_result для очистки памяти, которая применялась для выполнения вашего запроса.
Разница между функциями mysql_use_result и mysql_store_result в основном определяется тем, хотите ли вы получать данные построчно или весь набор за один шаг. Последний вариант больше подходит в том случае, когда вы рассчитываете на не слишком большой результирующий набор.
Функции для извлечения всех данных сразу
Вы сможете извлечь в единственном вызове все данные из оператора SELECT (или другого оператора, возвращающего данные), применяя функцию mysql_store_result:
MYSQL_RES *mysql_store_result(MYSQL* connection);
Ясно, что вам понадобится эта функция после успешного вызова функции mysql_query. Она немедленно сохранит все возвращенные данные в клиентской части. Функция вернет указатель на новую структуру, называемую структурой результирующего набора, или NULL, если оператор завершился аварийно.
В случае успеха вы далее вызываете функцию mysql_num_rows для определения количества возвращенных записей, которое, мы надеемся, будет положительным числом, но может быть и 0, если ни одной строки не возвращено.
my_ulonglong mysql_num_rows(MYSQL_RES* result);
Эта функция принимает в качестве параметра структуру с результатом, возвращенную mysql_store_result, и возвращает количество строк в данном результирующем наборе. Если функция mysql_store_result завершилась успешно, функция mysql_num_rows также завершится успешно.
Данная комбинация функций – легкий способ извлечь нужные вам данные. На этом этапе все данные локальны для программы-клиента и вам не нужно больше поддерживать подключение, связанное с возможностью возникновения ошибок в сети или базе данных. Получив количество возвращенных строк, вы упростите последующий программный код.
Если окажется, что вы должны работать с особенно большим набором данных, лучше извлекать меньшие по объему, более управляемые порции данных. В этом случае приложению быстрее передается управление, и использование сетевых ресурсов будет более щадящим. Мы рассмотрим этот вариант подробнее при обсуждении функции mysql_use_result.
Теперь, когда у вас есть данные, можно обработать их с помощью функции mysql_fetch_row и перемещаться по набору, используя функции mysql_data_seek, mysql_row_seek и mysql_row_tell. Давайте рассмотрим их.
□ Функция mysql_fetch_row извлекает одну строку из структуры типа result, которую вы получили с помощью функции mysql_store_result, и помещает ее структуру row. Когда данные иссякли или возникла ошибка, возвращается NULL. В следующем разделе мы вернемся к обработке данных в структуре типа row.
MYSQL_ROW mysql_fetch_row(MYSQL_RES *result);
□ Функция mysql_data_seek позволяет перемещаться в результирующем наборе, задавая строку, которая будет возвращена при следующем вызове функции mysql_fetch_row. Значение offset – номер строки в диапазоне от нуля до общего количества строк в результирующем наборе, уменьшенного на единицу. Передача нулевого значения вызовет возврат первой строки при следующем вызове функции mysql_fetch_row.
void mysql_data_seek(MYSQL_RES *result, my_ulonglong offset);
□ Функция mysql_row_tell возвращает величину смещения, обозначая текущую позицию в результирующем наборе. Это не номер строки и его нельзя использовать в функции mysql_data_seek.
MSSQL_ROW_OFFSET mysql_row_tell(MYSQL_RES *result);
Но ее можно применять с функцией
MYSQL_ROW_OFFSET mysql_row_seek(MYSQL_RES *result,
MYSQL_ROW_OFFSET offset);
которая перемещает текущую позицию в результирующем наборе и возвращает предыдущую позицию.
Примечание
Эта пара функций очень полезна для перемещения между известными записями в результирующем наборе. Будьте внимательны и не путайте величину смещения, используемую функциями
row_tellиrow_seekсо значением смещения, применяемым в функцииdata_seek. Иначе ваши результаты будут непредсказуемыми.
После того как вы сделаете с вашими данными все, что нужно, вы должны явно применить функцию mysql_free_result, позволяющую библиотеке MySQL навести после себя порядок.
void mysql_free_result(MYSQL_RES *result);
Когда с результирующим набором будет покончено, обязательно нужно вызвать эту. функцию и позволить библиотеке MySQL уничтожить объекты, которым она выделила память.
Извлечение данных
Теперь вы можете написать свое первое приложение с выборкой данных. Вы. хотите выбрать все записи, в которых возраст ребенка более 5 лет. Пока вы еще не знаете, как обработать эти данные, поэтому начнем с простого их извлечения. Важный фрагмент, в котором вы считываете результирующий набор и выводите в цикле полученные данные, выделен цветом. Далее приведена программа select1.с.
#include
#include
#include «mysql.h»
MYSQL my_connection;
MYSQL_RES *res_ptr;
MYSQL_ROW sqlrow;
int main(int argc, char *argv[]) {
int res;
mysql_init(&my_connection);
if (mysql_real_connect(&my_connection, «localhost», «rick»,
«secret», «foo», 0, NULL, 0)) {
printf(«Connection successn»);
res = mysql_query(&my_connection,
«SELECT childno, fname, age FROM children WHERE age > 5»);
if (res) {
printf(«SELECT error: %sn», mysql_error(&my_connection));
} else {
res_ptr = mysql_store_result(&my_connection);
if (res_ptr) {
printf(«Retrieved %lu rowsn»,
(unsigned long)mysql_num_rows(res_ptr));
while ((sqlrow = mysql_fetch_row(res_ptr))) {
printf(«Fetched data...n»);
}
if (mysql_errno(&my_connection)) {
fprintf(stderr, «Retrieve error: %sn»,
mysql_error(&my_connection));
}
mysql_free_result(res_ptr);
}
}
mysql_close(&my_connection);
} else {
fprintf(stderr, "Connection failedn');
if (mysql_errno(&my_connection)) {
fprintf(stderr, «Connection error %d: %sn»,
mysql_errno(&my_connection), mysql_error(&my_connection));
}
}
return EXIT_SUCCESS;
}
Построчное извлечение данных
Для извлечения данных строка за строкой, если вы действительно хотите этого, пользуйтесь функцией mysql_use_result вместо функции mysql_store_result.
MYSQL_RES *mysql_use_result(MYSQL *connection);
Как и mysql_store_result, функция mysql_use_result в случае ошибки возвращает NULL; если она выполняется успешно, то возвращает указатель на объект с результирующим набором. Но эта функция отличается тем, что не считывает никаких данных в результирующий набор, который инициализировала.
Примечание
Для того чтобы действительно получить данные, следует многократно применять функцию
mysql_fetch_rowдо тех пор, пока все данные не будут извлечены. Если вы не получите все данные от функцииmysql_use_result, последующие операции в вашей программе, направленные на извлечение данных, могут вернуть поврежденную информацию.
В чем же выигрыш от вызова функции mysql_use_result по сравнению с вызовом функции mysql_store_result? У первой из названных функций есть ряд существенных преимуществ, касающихся управления ресурсами; но ее нельзя применять с функциями mysql_data_seek, mysql_row_seek или mysql_row_tell и польза от применения mysql_num_rows ограничена, поскольку она не может нормально функционировать до тех пор, пока не будут извлечены все данные.
Вы также увеличьте время ожидания в вашей программе, т.к. запрос каждой строки должен пройти по сети и также должны быть отправлены обратно результаты. Еще одна возможность – разрыв сетевого соединения в середине операции, оставляющий вас с неполным набором данных.
Но ни один из перечисленных недостатков никак не уменьшает достоинств, упомянутых ранее: лучше сбалансированная сетевая загрузка и меньшие непроизводительные потери памяти в случае возможных очень больших наборов данных.
Замена программы select1.c на программу select2.c, использующую метод mysql_use_result, проста, поэтому далее мы приводим измененный фрагмент в виде закрашенных серым цветом строк:
if (res) {
printf(«SELECT error: %sn», mysql_error(&my_connection));
} else {
res_ptr = mysql_use_result(&my_connection);
if (res_ptr) {
while ((sqlrow = mysql_fetch_row(res_ptr))) {
printf(«Fetched data...n»);
}
if (mysql_errno(&my_connection)) {
printf(«Retrieve error: %sn», mysql_error(&my_connection));
}
mysql_free_result(res_ptr);
}
}
Учтите, что вы не можете получить количество строк до тех пор, пока не будет извлечен последний результат. Но проверяя ошибки как можно раньше и чаще, вы облегчите применение функции mysql_use_result. Разрабатывая программу таким образом, можно уберечься от головной боли при последующих ее модификациях.
Обработка полученных данных
Зная, как извлекать строки, можно перейти к рассмотрению обработки полученных реальных данных.
MySQL, как большинство баз данных SQL, возвращает два вида данных:
□ данные, извлеченные из таблицы и называемые данными столбцов;
□ данные о данных, так называемые метаданные, например, имена столбцов и их типы.
Сначала сосредоточимся на получении данных, как таковых, в пригодном к использованию виде.
Функция mysql_field_count предоставляет некоторую базовую информацию о результате запроса. Она принимает ваше подключение как объект и возвращает количество полей (столбцов) в результирующем наборе.
unsigned int mysql_field_count(MYSQL * connection);
Помимо этого вы можете использовать mysql_field_count и в других случаях, таких как определение причины аварийного завершения вызова функции mysql_store_result. Если mysql_store_result возвращает NULL, а функция mysql_field_count – положительное число, можно предположить ошибку извлечения. Если же функция mysql_field_count возвращает 0, нет извлекаемых столбцов, что объясняет сбой при попытке сохранить результат. Естественно ожидать, что вы знаете, сколько предполагаемых столбцов должно быть получено в конкретном запросе. Таким образом, эта функция особенно полезна в компонентах общей обработки запросов и в любой ситуации, когда запросы формируются на лету.
Примечание
В программах, написанных для более ранних версий MySQL, вы можете встретить функцию
mysql_num_fields. Она может принимать в качестве параметра указатель на структуру дескриптора подключения или структуру результата запроса и возвращает количество столбцов.
Если оставить в стороне заботы о форматировании, вы уже знаете, как немедленно вывести данные. Добавьте простую функцию display_row в программу select2.c.
Примечание
Обратите внимание на то, что для упрощения примера данные о подключении, результате и строке, полученные из функции
mysql_fetch_row, все сделаны глобальными. В рабочей программе мы не рекомендуем делать это.
1. Далее приведена очень простая подпрограмма для вывода данных:
void display_row() {
unsigned int field_count;
field_count = 0;
while (field_count < mysql_field_count(&my_commection)) {
printf("%s ", sqlrow[field_count]);
field_count++;
}
printf(«n»);
}
2. Вставьте ее в конец файла select2.c и добавьте объявление и вызов функции:
void display_row();
int main(int argc, char *argv[]) {
int res;
mysql_init(&my_connection);
if (mysql_real_connect(&my_connection, «localhost», «rick»,
«bar», «rick», 0, NULL, 0)) {
printf(«Connection successn»);
res = mysql_query(&my_connection,
«SELECT childno, fname, age FROM children WHERE age > 5»);
if (res) {
printf(«SELECT error: %sn», mysql_error(&my_connection));
} else {
res_ptr = mysql_use_result(&my_connection);
if (res_ptr) {
while ((sqlrow = mysql_fetch_row(res_ptr))) {
printf(«Fetched data...n»);
display_row();
}
}
}
}
}
3. Теперь сохраните законченный проект с именем select3.c. В заключение откомпилируйте и выполните select3, как показано далее:
$ gcc -I/usr/include/mysql select3. с -L/usr/lib/mysql -lmysqlclient -о select3
$ ./select3
Connection success
Fetched data...
1 Jenny 21
Fetched data...
2 Andrew 17
$
Итак, программа работает, несмотря на не слишком эстетически привлекательный вывод. Но вы не смогли учесть в результате возможные значения NULL. Если вы хотите вывести более искусно отформатированные (в виде таблицы, например) данные, следует получить из MySQL данные и метаданные. Одновременно считать как данные, так и метаданные в новую структуру вы можете с помощью функции mysql_fetch_field.
MYSQL_FIELD *mysql_fetch_field(MYSQL_RES *result);
Вызывать эту функцию следует многократно, до тех пор, пока не будет возвращено значение NULL, которое сигнализирует о том, что данные закончились. Далее вы можете использовать указатель на структуру данных о поле для получения сведений о столбце. Структура типа MYSQL_FIELD определена в файле mysql.h, как показано в табл. 8.12.
Таблица 8.12
MYSQL_FIELD | |
|---|---|
char *name; | Имя столбца в виде строки |
char *table; | Имя таблицы, из которой получен столбец. Оно особенно полезно в запросе с использованием нескольких таблиц. Имейте в виду, что вычисляемое значение в результате, такое как MAX, будет иметь пустую строку для имени таблицы |
char *def; | При вызове функции mysql_list_fields (которую мы не обсуждаем) это поле содержит значение в столбце по умолчанию |
enum enum_field_types type; | Тип столбца. См. пояснения сразу после таблицы |
unsigned int length; | Ширина столбца, заданная при определении таблицы |
unsigned int max_length; | Если применяется функция mysql_store_result, это поле содержит длину в байтах самого длинного извлеченного значения столбца. Если применяется функция mysql_use_result, поле не задается |
unsigned int flags; | Флаги содержат информацию об определении столбца, а не о найденных данных. у распространенных флагов очевидные значения: NOT_NULL_FLAG, PRI_KEY_FLAG, UNSIGNED_FLAG, AUTO_INCREMENT_FLAG и BINARY_FLAG. Полный список флагов можно найти в документации MySQL |
unsigned int decimals; | Количество знаков после десятичной точки. Справедливо только для числовых полей |
Типов столбца огромное множество. Полный перечень можно найти в файле mysql_com.h и в документации.
К самым распространенным относятся следующие:
FIELD_TYPE_DECIMAL
FIELD_TYPE_LONG
FIELD_TYPE_STRING
FIELD_TYPE_VAR_STRING
Далее приведен особенно полезный макрос IS_NUM, возвращающий значение true, если тип поля числовой:
if (IS_NUM(myslq_field_ptr->type)) printf(«Numeric type fieldn»);
Прежде чем обновлять вашу программу, следует упомянуть еще одну функцию:
MYSQL_FIELD_OFFSET mysql_field_seek(MYSQL_RES* result,
MYSQL_FIELD_OFFSET offset);
Ее можно использовать для переопределения текущего номера поля, который автоматически увеличивается при каждом вызове mysql_fetch_field. Если передать нулевое смещение, вы вернетесь назад к первому столбцу.
Теперь, имея всю необходимую информацию для написания программы выборки, покажите все дополнительные данные, относящиеся к заданному столбцу.
Далее приведена программа select4.c, которую мы воспроизводим полностью, чтобы у вас был полный пример для изучения. В программе нет расширенного анализа типов столбцов, в ней только демонстрируются требуемые основные правила.
