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'문은 연결 구성의 기본 이름입니다.
DB Facade가 제공 한 table 방법을 사용하여 쿼리를 시작할 수 있습니다. table 메소드는 주어진 테이블의 유창한 쿼리 빌더 인스턴스를 반환하여 쿼리에 더 많은 제약을 체인 한 다음 get 메소드를 사용하여 쿼리 결과를 검색 할 수 있습니다.
use Foxdb DB ;
$ users = DB :: table ( ' users ' )-> get ();
foreach ( $ users as $ user ) {
echo $ user -> name ;
} 데이터베이스 테이블에서 단일 행을 검색 해야하는 경우 DB Facade의 first 방법을 사용할 수 있습니다. 이 메소드는 단일 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 형태로 결과를 반환하여 더 많은 기능을 제공합니다. (값이 존재하지 않으면 두 가지 방법이 모두 false를 반환합니다.)
? 버전 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 ;
}PLUCK 메소드에 두 번째 인수를 제공하여 결과 컬렉션이 키로 사용 해야하는 열을 지정할 수 있습니다.
$ titles = DB :: table ( ' users ' )-> pluck ( ' title ' , ' name ' );
foreach ( $ titles as $ name => $ title ) {
echo $ title ;
} 수천 개의 데이터베이스 레코드를 사용해야하는 경우 DB Facade에서 제공하는 chunk 방법을 사용해보십시오. 이 방법은 한 번에 작은 결과를 검색하고 각 청크를 처리를 위해 폐쇄로 공급합니다. 예를 들어, 전체 사용자 테이블을 한 번에 100 개의 레코드 덩어리로 검색해 봅시다.
use Foxdb DB ;
DB :: table ( ' users ' )-> orderBy ( ' id ' )-> chunk ( 100 , function ( $ users ) {
foreach ( $ users as $ user ) {
//
}
});폐쇄에서 False를 반환하여 추가 청크가 처리되는 것을 막을 수 있습니다.
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 ' );카운트 방법을 사용하여 쿼리의 제약 조건에 맞는 레코드가 존재하는지 확인하는 대신, 당신은 exists 및 downtexist 메소드를 사용할 수 있습니다.
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 (); 때로는 임의의 문자열을 쿼리에 삽입해야 할 수도 있습니다. 원시 문자열 표현식을 만들려면 DB Facade에서 제공하는 raw 방법을 사용할 수 있습니다.
$ users = DB :: table ( ' users ' )
-> select ( DB :: raw ( ' count(*) as user_count, status ' ))
-> where ( ' status ' , ' <> ' , 1 )
-> groupBy ( ' status ' )
-> get ();아래 예제와 같이 RAW의 매개 변수를 사용하려면
DB::raw('count(?)',['id'])
켈 RAW 문은 문자열로 쿼리에 주입되므로 SQL 주입 취약점을 생성하지 않도록 매우주의해야합니다.
그러나이를 위해 SQL injection 공격을 피하기 위해 다음 방법을 사용하는 것이 좋습니다.
$ users = DB :: table ( ' users ' )
-> select ( function ( $ query ){
$ query -> count ( ' * ' )-> as ( ' user_count ' )
$ query -> field ( ' status ' );
})
-> get (); 이 구조에서는 방법 as field , count , sum , avg , min , max all 액세스 할 수 있습니다.
DB :: RAW 메소드를 사용하는 대신 다음 방법을 사용하여 쿼리의 여러 부분에 원시 표현식을 삽입 할 수도 있습니다. FoxDB는 원시 표현식을 사용하는 쿼리가 SQL 주입 취약성으로부터 보호된다고 보장 할 수 없습니다.
whereraw 및 orwhereraw 방법을 사용하여 쿼리에 조항을 "여기서"를 주입 할 수 있습니다. 이 방법은 선택적 바인딩 배열을 두 번째 인수로 받아들입니다.
$ orders = DB :: table ( ' orders ' )
-> whereRaw ( ' price > IF(state = "TX", ?, 100) ' , [ 200 ])
-> get ();핸드 로우 및 오르 하우 빙하 방법은 "hading"조항의 값으로 원시 문자열을 제공하는 데 사용될 수 있습니다. 이 방법은 선택적 바인딩 배열을 두 번째 인수로 받아들입니다.
$ orders = DB :: table ( ' orders ' )
-> select ( ' department ' , DB :: raw ( ' SUM(price) as total_sales ' ))
-> groupBy ( ' department ' )
-> havingRaw ( ' SUM(price) > ? ' , [ 2500 ])
-> get ();쿼리 빌더는 조인 조항을 쿼리에 추가하는 데 사용될 수도 있습니다. 기본 "내부 조인"을 수행하려면 쿼리 빌더 인스턴스에서 조인 메소드를 사용할 수 있습니다. 결합 메소드에 전달 된 첫 번째 인수는 결합해야 할 테이블의 이름이며 나머지 인수는 조인의 열 제약 조건을 지정합니다. 단일 쿼리에서 여러 테이블에 가입 할 수도 있습니다.
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 메소드를 사용하여 "Cross Join"을 수행 할 수 있습니다. Cross Join은 첫 번째 테이블과 결합 된 테이블 사이에 데카르트 제품을 생성합니다.
$ sizes = DB :: table ( ' sizes ' )
-> crossJoin ( ' colors ' )
-> get ();쿼리 빌더를 사용하여 메소드를 추가하여 "여기서"클로를 쿼리에 추가 할 수 있습니다. Where 메소드에 대한 가장 기본적인 호출에는 세 가지 인수가 필요합니다. 첫 번째 인수는 열의 이름입니다. 두 번째 인수는 운영자이며, 데이터베이스의 지원되는 운영자가 될 수 있습니다. 세 번째 인수는 열의 값과 비교할 값입니다.
예를 들어, 다음 쿼리는 투표 값의 값이 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 ();쿼리 빌더가있는 곳에서 함께 호출 할 때, "여기서"조항이 및 연산자를 사용하여 함께 결합 될 것입니다. 그러나 ORWhere 메소드를 사용하여 OR 연산자를 사용하여 쿼리에 조항을 결합 할 수 있습니다. Orwhere 메소드는 Where 메소드와 동일한 인수를 받아들입니다.
$ users = DB :: table ( ' users ' )
-> where ( ' votes ' , ' > ' , 100 )
-> orWhere ( ' name ' , ' John ' )
-> get ();괄호 안에 "또는"조건을 그룹화 해야하는 경우, 당신은 또는 어디에서나 어디에서나 첫 번째 인수로 폐쇄를 전달할 수 있습니다.
$ 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 방법은 주어진 쿼리 제약 조건을 무효화하는 데 사용될 수 있습니다. 예를 들어, 다음 쿼리는 통관 중이거나 가격이 10 미만인 제품을 제외합니다.
$ 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 메소드는 주어진 열의 값이 null인지 확인합니다.
$ 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 ();여러 열로 정렬하려면 필요한만큼 OrderBy를 호출 할 수 있습니다.
$ users = DB :: table ( ' users ' )
-> orderBy ( ' name ' , ' desc ' )
-> orderBy ( ' email ' , ' asc ' )
-> get (); latest 및 oldest 방법을 사용하면 날짜별로 쉽게 결과를 주문할 수 있습니다. 기본적으로 결과는 테이블의 created_at 열에서 주문됩니다. 또는 정렬하려는 열 이름을 전달할 수 있습니다.
$ user = DB :: table ( ' users ' )
-> latest ()
-> first ();Inrandomorder 방법은 쿼리 결과를 무작위로 정렬하는 데 사용될 수 있습니다. 예를 들어이 메소드를 사용하여 임의의 사용자를 가져올 수 있습니다.
$ randomUser = DB :: table ( ' users ' )
-> inRandomOrder ()
-> first ();groupBy & 방법이 having 예상대로 groupBy 와 having 이 쿼리 결과를 그룹화하는 데 사용될 수 있습니다. 방법의 having 은 WHER 메소드의 서명과 유사합니다.
$ 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 ();보다 진보 된 진술을 구축하려면 핸드 로우 방법을 참조하십시오.
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
]); 테이블에 자동 증가 ID가있는 경우 insertGetId 메소드를 사용하여 레코드를 삽입 한 다음 ID를 검색하십시오.
$ id = DB :: table ( ' users ' )-> insertGetId (
[ ' email ' => ' [email protected] ' , ' votes ' => 0 ]
);쿼리 빌더는 데이터베이스에 레코드를 삽입하는 것 외에도 업데이트 메소드를 사용하여 기존 레코드를 업데이트 할 수도 있습니다. 삽입 메소드와 마찬가지로 업데이트 메소드는 열을 업데이트 할 열 및 값 쌍의 배열을 허용합니다. 업데이트 메소드는 영향을받는 행의 수를 반환합니다. Clauses를 사용하여 업데이트 쿼리를 제한 할 수 있습니다.
$ 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 ();쿼리의 Where 메소드를 연속적으로 사용할 필요가 없습니다. 방법 또는 사용 또는 대신 또는 어디서나 사용할 수 있습니다.
예:
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(..)
