foxdb
1.0.0
Строитель запросов FoxDB использует привязку параметров PDO для защиты вашего приложения от атак SQL -инъекций. Нет необходимости чистить или дезинфицировать струны, передаваемые к строителю запросов в качестве привязки запросов.
composer require webriumfoxdb
Конфигурация
Выбирать
Вставьте заявления
Обновлять заявления
Удалить заявления
Специальные функции
Схема
Красноречивая
use Foxdb DB ;
use Foxdb Config ;
DB :: addConnection ( ' main ' , [
' host ' => ' localhost ' ,
' port ' => ' 3306 ' ,
' database ' => ' test ' ,
' username ' => ' root ' ,
' password ' => ' 1234 ' ,
' charset ' =>Config:: UTF8 ,
' collation ' =>Config:: UTF8_GENERAL_CI ,
' fetch ' =>Config:: FETCH_CLASS
]);Оператор
'main'- это имя по умолчанию конфигурации подключения
Вы можете использовать метод table , предоставленный фасадом DB , чтобы начать запрос. Метод table возвращает экземпляр «Строительного застройщика для свободного запроса» для данной таблицы, позволяя вам цеплять больше ограничений на запрос, а затем, наконец, получить результаты запроса, используя метод GET:
use Foxdb DB ;
$ users = DB :: table ( ' users ' )-> get ();
foreach ( $ users as $ user ) {
echo $ user -> name ;
} Если вам просто нужно получить одну строку из таблицы базы данных, вы можете использовать first метод фасада DB. Этот метод вернет один объект StdClass:
$ user = DB :: table ( ' users ' )-> where ( ' name ' , ' Jack ' )-> first ();
return $ user -> email ; Если вам не нужна целая строка, вы можете извлечь одно значение из записи, используя метод value . Этот метод будет возвращать значение столбца напрямую:
$ email = DB :: table ( ' users ' )-> where ( ' name ' , ' John ' )-> value ( ' email ' ); Чтобы получить одну строку по значению столбца id , используйте метод find :
$ user = DB :: table ( ' users ' )-> find ( 3 ); Разница между методом find и first состоит в том, что first метод возвращает результат в форме StdClass, если он существует, но метод find возвращает результат в форме Model , которая дает нам больше функций. (Если значение не существует, оба метода возвращают ложь.)
? Из версии 3 и выше, запросы можно использовать для поиска
$ user = User:: find ( 3 );
if ( $ user ){
$ user -> name = ' Tom ' ;
$ user -> save (); // update name
}
$ user = User:: where ( ' phone ' , ' 09999999999 ' )-> find ();
if ( $ user ){
$ user -> phone = ' 09999999998 ' ;
$ user -> save (); // update user phone number
} Вы можете использовать метод pluck . В этом примере мы получим коллекцию пользовательских названий:
use Foxdb DB ;
$ titles = DB :: table ( ' users ' )-> pluck ( ' title ' );
foreach ( $ titles as $ title ) {
echo $ title ;
}Вы можете указать столбец, который полученная коллекция должна использовать в качестве клавиш, предоставив второй аргумент методу отвода:
$ titles = DB :: table ( ' users ' )-> pluck ( ' title ' , ' name ' );
foreach ( $ titles as $ name => $ title ) {
echo $ title ;
} Если вам нужно работать с тысячами записей базы данных, рассмотрите возможность использования метода chunk , предоставленного Facade DB. Этот метод извлекает небольшую часть результатов за раз и подает каждый кусок в закрытие для обработки. Например, давайте изберем всю таблицу пользователей в куски 100 записей за раз:
use Foxdb DB ;
DB :: table ( ' users ' )-> orderBy ( ' id ' )-> chunk ( 100 , function ( $ users ) {
foreach ( $ users as $ user ) {
//
}
});Вы можете остановить обработку дальнейших кусков путем возвращения ложного от закрытия:
DB :: table ( ' users ' )-> orderBy ( ' id ' )-> chunk ( 100 , function ( $ users ) {
// Process the records...
return false ;
}); Вы можете использовать each метод.
use Foxdb DB ;
DB :: table ( ' users ' )-> orderBy ( ' id ' )-> each ( function ( $ user ) {
//
});FoxDB создал простой метод для страниц. В приведенном ниже примере количество результатов ограничено 10 записями, и вы можете получить информацию, изменяя номер страницы.
$ page = 1 ;
$ list = DB :: table ( ' posts ' )
-> is ( ' active ' )
-> paginate ( 10 , $ page );Его вывод - это stdclass, содержащий следующие свойства:
$ list -> total ; // The total number of rows
$ list -> count ; // The number of rows received on the current page
$ list -> per_page ; // The number of rows to display on each page
$ list -> prev_page ; // Previous page number. If not available, its value is false
$ list -> next_page ; // next page number. If not available, its value is false
$ list -> current_page ; // Current page number
$ list -> data ; // List of data rows Строитель запросов также предоставляет различные методы для извлечения совокупных значений, таких как count , max , min , avg и sum . Вы можете вызвать любой из этих методов после построения вашего запроса:
use Foxdb DB ;
$ users = DB :: table ( ' users ' )-> count ();
$ price = DB :: table ( ' orders ' )-> max ( ' price ' );Конечно, вы можете объединить эти методы с другими предложениями, чтобы точно настроить то, как рассчитывается ваше совокупное значение:
$ price = DB :: table ( ' orders ' )
-> where ( ' finalized ' , 1 )
-> avg ( ' price ' );Вместо того, чтобы использовать метод графа, чтобы определить, существуют ли какие -либо записи, которые соответствуют ограничениям вашего запроса, вы можете использовать существующие и не существующие методы:
if ( DB :: table ( ' orders ' )-> where ( ' finalized ' , 1 )-> exists ()) {
// ...
}
if ( DB :: table ( ' orders ' )-> where ( ' finalized ' , 1 )-> doesntExist ()) {
// ...
}Указание пункта SELECT
Вы не всегда хотите выбрать все столбцы из таблицы базы данных. Используя метод select , вы можете указать пользовательский пункт «Выбрать» для запроса:
use Foxdb DB ;
$ users = DB :: table ( ' users ' )
-> select ( ' name ' , ' email as user_email ' )
-> get ();
// Or you can send as an array
$ users = DB :: table ( ' users ' )
-> select ([ ' name ' , ' email as user_email ' ])
-> get ();Но есть более современный способ сделать это. Вы можете вести себя как пример ниже
$ users = DB :: table ( ' users ' )
-> select ( function ( $ query ){
$ query -> field ( ' name ' );
$ query -> field ( ' email ' )-> as ( ' user_email ' );
})
-> get (); Иногда вам может потребоваться вставить произвольную строку в запрос. Чтобы создать выражение необработанной строки, вы можете использовать метод raw предоставленный фасадом DB :
$ users = DB :: table ( ' users ' )
-> select ( DB :: raw ( ' count(*) as user_count, status ' ))
-> where ( ' status ' , ' <> ' , 1 )
-> groupBy ( ' status ' )
-> get ();Чтобы использовать параметр в сыром, как пример ниже
DB::raw('count(?)',['id'])
️ Необработанные заявления будут введены в запрос как строки, поэтому вы должны быть чрезвычайно осторожны, чтобы избежать создания уязвимостей инъекций SQL.
Но для этой цели лучше использовать следующий метод, чтобы избежать атаки SQL injection
$ users = DB :: table ( ' users ' )
-> select ( function ( $ query ){
$ query -> count ( ' * ' )-> as ( ' user_count ' )
$ query -> field ( ' status ' );
})
-> get (); В этой структуре у вас есть доступ к field , count , sum , avg , min , max , all , as методы.
Вместо использования метода DB :: RAW вы также можете использовать следующие методы для вставки необработанного выражения в различные части вашего запроса. Помните, FoxDB не может гарантировать, что любой запрос, использующий необработанные выражения, защищен от уязвимостей инъекций SQL.
Методы где -то и Orwhereraw могут использоваться для введения необработанного », где« предложение »в ваш запрос. Эти методы принимают необязательный массив привязков в качестве второго аргумента:
$ orders = DB :: table ( ' orders ' )
-> whereRaw ( ' price > IF(state = "TX", ?, 100) ' , [ 200 ])
-> get ();Методы HistRaw и OrhavingRaw могут использоваться для обеспечения необработанной строки в качестве значения пункта «иметь». Эти методы принимают необязательный массив привязков в качестве второго аргумента:
$ orders = DB :: table ( ' orders ' )
-> select ( ' department ' , DB :: raw ( ' SUM(price) as total_sales ' ))
-> groupBy ( ' department ' )
-> havingRaw ( ' SUM(price) > ? ' , [ 2500 ])
-> get ();Строитель запросов также может быть использован для добавления пунктов присоединения к вашим запросам. Чтобы выполнить базовое «внутреннее соединение», вы можете использовать метод соединения в экземпляре Builder. Первый аргумент, переданный методу соединения, - это имя таблицы, к которой вы должны присоединиться, в то время как остальные аргументы указывают ограничения столбца для соединения. Вы можете даже присоединиться к нескольким таблицам в одном запросе:
use Foxdb DB ;
$ users = DB :: table ( ' users ' )
-> join ( ' contacts ' , ' users.id ' , ' = ' , ' contacts.user_id ' )
-> join ( ' orders ' , ' users.id ' , ' = ' , ' orders.user_id ' )
-> select ( ' users.* ' , ' contacts.phone ' , ' orders.price ' )
-> get ();В Foxdb вы можете сделать это легче
$ users = DB :: table ( ' users ' )
-> select ( ' users.* ' , ' orders.price ' )
-> join ( ' orders.user_id ' , ' users.id ' )
-> get (); В этой структуре вы вводите имя таблицы, которую вы хотите объединить с ее иностранным ключом ( 'orders.user_id' ), а затем первичный ключ ( 'user.id' ).
Если вы хотите выполнить «левое соединение» или «правое соединение» вместо «внутреннего соединения», используйте методы левого суда или правого суда. Эти методы имеют такую же подпись, как и метод соединения:
$ users = DB :: table ( ' users ' )
-> leftJoin ( ' posts ' , ' users.id ' , ' = ' , ' posts.user_id ' )
-> get (); $ users = DB :: table ( ' users ' )
-> rightJoin ( ' posts ' , ' users.id ' , ' = ' , ' posts.user_id ' )
-> get ();Вы можете использовать метод Crossjoin для выполнения «перекрестного соединения». Крестные соединения генерируют декартовый продукт между первой таблицей и таблицей соединений:
$ sizes = DB :: table ( ' sizes ' )
-> crossJoin ( ' colors ' )
-> get ();Вы можете использовать строитель запросов, где метод добавить », где» полагается на запрос. Самый базовый призыв к методу, где требуется три аргумента. Первый аргумент - это имя столбца. Второй аргумент - оператор, который может быть любым из поддерживаемых операторов базы данных. Третий аргумент - это значение для сравнения со значением столбца.
Например, следующий запрос извлекает пользователей, где значение столбца голосов равно 100, а значение столбца возраста больше 35:
$ users = DB :: table ( ' users ' )
-> where ( ' votes ' , ' = ' , 100 )
-> where ( ' age ' , ' > ' , 35 )
-> get ();Для удобства, если вы хотите убедиться, что столбец - это = к данному значению, вы можете передать значение в качестве второго аргумента методу, где. Foxdb предположит, что вы хотели бы использовать оператор = оператор:
$ users = DB :: table ( ' users ' )-> where ( ' votes ' , 100 )-> get ();Как упоминалось ранее, вы можете использовать любой оператор, который поддерживается вашей системой баз данных:
$ users = DB :: table ( ' users ' )
-> where ( ' votes ' , ' >= ' , 100 )
-> get (); $ users = DB :: table ( ' users ' )
-> where ( ' votes ' , ' <> ' , 100 )
-> get (); $ users = DB :: table ( ' users ' )
-> where ( ' name ' , ' like ' , ' T% ' )
-> get ();При цепочке вместе вызовы к методу застройщика запросов, положения «где» будут соединяться вместе с использованием оператора. Тем не менее, вы можете использовать метод OR, чтобы присоединиться к пункту к запросу с помощью оператора OR. Метод или где -то принимает те же аргументы, что и метод, где метод:
$ users = DB :: table ( ' users ' )
-> where ( ' votes ' , ' > ' , 100 )
-> orWhere ( ' name ' , ' John ' )
-> get ();Если вам нужно сгруппировать условие "или" в скобках, вы можете передать закрытие в качестве первого аргумента метода OR:
$ users = DB :: table ( ' users ' )
-> where ( ' votes ' , ' > ' , 100 )
-> orWhere ( function ( $ query ) {
$ query -> where ( ' name ' , ' Abigail ' )
-> where ( ' votes ' , ' > ' , 50 );
})
-> get ();Приведенный выше пример приведет к следующему SQL:
select * from users where votes > 100 or (name = 'Abigail' and votes > 50)
Методы whereNot и orWhereNot могут использоваться для отмены данной группы ограничений запросов. Например, следующий запрос исключает продукты, которые находятся на очистке или имеют цену, которая меньше десяти:
$ products = DB :: table ( ' products ' )
-> whereNot ( function ( $ query ) {
$ query -> where ( ' clearance ' , true )
-> orWhere ( ' price ' , ' < ' , 10 );
})
-> get (); Между методом whereBetween проверяет, что значение столбца находится между двумя значениями:
$ users = DB :: table ( ' users ' )
-> whereBetween ( ' votes ' , [ 1 , 100 ])
-> get (); whereNotBetween проверяет, что значение столбца находится за пределами двух значений:
$ users = DB :: table ( ' users ' )
-> whereNotBetween ( ' votes ' , [ 1 , 100 ])
-> get (); Метод whereIn проверяет, что значение данного столбца содержится в данном массиве:
$ users = DB :: table ( ' users ' )
-> whereIn ( ' id ' , [ 1 , 2 , 3 ])
-> get (); Метод whereNotIn проверяет, что значение данного столбца не содержится в данном массиве:
$ users = DB :: table ( ' users ' )
-> whereNotIn ( ' id ' , [ 1 , 2 , 3 ])
-> get (); Метод whereNull подтверждает, что значение данного столбца равна нулю:
$ users = DB :: table ( ' users ' )
-> whereNull ( ' updated_at ' )
-> get (); Метод whereNotNull подтверждает, что значение столбца не является нулевым:
$ users = DB :: table ( ' users ' )
-> whereNotNull ( ' updated_at ' )
-> get (); Метод whereDate может использоваться для сравнения значения столбца с датой:
$ users = DB :: table ( ' users ' )
-> whereDate ( ' created_at ' , ' 2016-12-31 ' )
-> get (); Метод whereMonth может использоваться для сравнения значения столбца с определенным месяцем:
$ users = DB :: table ( ' users ' )
-> whereMonth ( ' created_at ' , ' 12 ' )
-> get (); Метод whereDay может использоваться для сравнения значения столбца с определенным днем месяца:
$ users = DB :: table ( ' users ' )
-> whereDay ( ' created_at ' , ' 31 ' )
-> get (); Метод whereYear можно использовать для сравнения значения столбца с определенным году:
$ users = DB :: table ( ' users ' )
-> whereYear ( ' created_at ' , ' 2016 ' )
-> get (); Метод whereTime можно использовать для сравнения значения столбца с определенным временем:
$ users = DB :: table ( ' users ' )
-> whereTime ( ' created_at ' , ' = ' , ' 11:20:45 ' )
-> get (); Метод whereColumn может использоваться для проверки того, что два столбца равны:
$ users = DB :: table ( ' users ' )
-> whereColumn ( ' first_name ' , ' last_name ' )
-> get (); Вы также можете перенести оператор сравнения с методом whereColumn :
$ users = DB :: table ( ' users ' )
-> whereColumn ( ' updated_at ' , ' > ' , ' created_at ' )
-> get (); Метод orderBy позволяет сортировать результаты запроса с помощью данного столбца. Первым аргументом, принятым методом orderBy , должен быть столбец, который вы хотите сортировать, в то время как второй аргумент определяет направление своего рода и может быть либо ASC, либо DESC:
$ users = DB :: table ( ' users ' )
-> orderBy ( ' name ' , ' desc ' )
-> get ();Чтобы сортировать по нескольким столбцам, вы можете просто вызвать заказ столько раз, сколько необходимо:
$ users = DB :: table ( ' users ' )
-> orderBy ( ' name ' , ' desc ' )
-> orderBy ( ' email ' , ' asc ' )
-> get (); latest и oldest методы позволяют легко заказать результаты на дату. По умолчанию результат будет упорядочен столбцом таблицы created_at . Или вы можете передать имя столбца, которое вы хотите сортировать по:
$ user = DB :: table ( ' users ' )
-> latest ()
-> first ();Метод Inrandomorond может использоваться для случайного сортировки результатов запроса. Например, вы можете использовать этот метод, чтобы принести случайного пользователя:
$ randomUser = DB :: table ( ' users ' )
-> inRandomOrder ()
-> first ();groupBy & having методов Как и следовало ожидать, groupBy и having методов могут быть использованы для группировки результатов запроса. having метода, похожая на подпись метода: где метод:
$ users = DB :: table ( ' users ' )
-> groupBy ( ' account_id ' )
-> having ( ' account_id ' , ' > ' , 100 )
-> get ();Вы можете передать несколько аргументов методу Groupby для группы по нескольким столбцам:
$ users = DB :: table ( ' users ' )
-> groupBy ( ' first_name ' , ' status ' )
-> having ( ' account_id ' , ' > ' , 100 )
-> get ();Чтобы создать более продвинутые, имея заявления, см. Метод hastRaw.
Вы можете использовать методы skip и take методы, чтобы ограничить количество результатов, возвращаемых из запроса, или пропустить заданное количество результатов в запросе:
$ users = DB :: table ( ' users ' )-> skip ( 10 )-> take ( 5 )-> get (); В качестве альтернативы вы можете использовать методы limit и offset . Эти методы функционально эквивалентны методам принятия и пропуска соответственно:
$ users = DB :: table ( ' users ' )
-> offset ( 10 )
-> limit ( 5 )
-> get (); Строитель запросов также предоставляет метод insert , который может использоваться для вставки записей в таблицу баз данных. Метод вставки принимает массив имен и значений столбцов:
DB :: table ( ' users ' )-> insert ([
' email ' => ' [email protected] ' ,
' votes ' => 0
]); Если таблица имеет идентификатор автоматического инкюрения, используйте метод insertGetId для вставки записи, а затем получить идентификатор:
$ id = DB :: table ( ' users ' )-> insertGetId (
[ ' email ' => ' [email protected] ' , ' votes ' => 0 ]
);В дополнение к вставке записей в базу данных, строитель запросов также может обновлять существующие записи, используя метод обновления. Метод обновления, как и метод вставки, принимает массив паров столбцов и значений, указывающих на обновление столбцов. Метод обновления возвращает количество затронутых строк. Вы можете ограничить запрос на обновление, используя, где положения:
$ affected = DB :: table ( ' users ' )
-> where ( ' id ' , 1 )
-> update ([ ' votes ' => 1 ]);Строитель запросов также предоставляет удобные методы для увеличения или уменьшения значения данного столбца. Оба эти метода принимают хотя бы один аргумент: столбец для изменения. Второй аргумент может быть предоставлен, чтобы указать сумму, на которую столбец должен быть увеличен или уменьшен:
DB :: table ( ' users ' )-> increment ( ' votes ' );
DB :: table ( ' users ' )-> increment ( ' votes ' , 5 );
DB :: table ( ' users ' )-> decrement ( ' votes ' );
DB :: table ( ' users ' )-> decrement ( ' votes ' , 5 ); DB :: table ( ' users ' )-> where ( ' id ' , $ id )-> delete ();Вы можете использовать более приятный синтаксис, который в дополнение к сокращению кода также помогает сделать код более читабельным
Для создания запросов на основе логического, вы можете использовать true и false или is методы
$ active_list = DB :: table ( ' users ' )-> is ( ' active ' )-> get ();
// OR
$ active_list = DB :: table ( ' users ' )-> true ( ' active ' )-> get (); $ inactive_list = DB :: table ( ' users ' )-> is ( ' active ' , false )-> get ();
//OR
$ inactive_list = DB :: table ( ' users ' )-> false ( ' active ' )-> get ();Вам не нужно использовать метод, где для ваших запросов последовательно. Вы можете использовать метод или использование или вместо или где -то.
Пример:
DB :: table ( ' users ' )
-> is ( ' active ' )
-> and ( ' credit ' , ' > ' , 0 )
-> or ( ' vip ' , true )
-> get (); DB :: table ( ' users ' )
-> in ( ' id ' , [ 1 , 5 , 10 ])
-> get ();Также доступны другие методы, такие как следующие методы:
not(..) / orNot(..)
in(..) / notIn(..) / orIn(..) / orNotIn(..)
like(..) / orLike(..)
null(..) / orNull(..) / notNull(..) / orNotNull(..)
date(..) / orDate(..)
year(..) / orYear(..)
month(..) / orMonth(..)
day(..) / orDay(..)
time(..) / orTime(..)
