PdoOne
4.10
pdoone. SQL Server (2008 R2 이상), MySQL (5.7 이상) 및 Oracle (12.1 이상)과 호환되는 PHP의 PDO 라이브러리를위한 간단한 래퍼입니다.
이 라이브러리는 가능한 빨리 일하려고 합니다. 대부분의 작업은 간단한 문자열/배열 관리이며 PDO 라이브러리의 베어 메탈에서 작업하지만 확장 EFTEC/PDOONEORM을 사용하여 ORM을 만들 수도 있습니다.
이것을 돌리십시오
$ stmt = $ pdo -> prepare ( " SELECT * FROM myTable WHERE name = ? " );
$ stmt -> bindParam ( 1 , $ _POST [ ' name ' ], PDO :: PARAM_STR );
$ stmt -> execute ();
$ result = $ stmt -> get_result ();
$ products =[];
while ( $ row = $ result -> fetch_assoc ()) {
$ product []= $ row ;
}
$ stmt -> close ();이것으로
$ products = $ pdoOne
-> select ( " * " )
-> from ( " myTable " )
-> where ( " name = ? " ,[ $ _POST [ ' name ' ]])
-> toList ();또는 ORM 사용 (EFTEC/PDOONEORM 라이브러리 사용)
ProductRepo // this class was generated with echo $pdoOne()->generateCodeClass(['Product']); or using the cli.
:: where ( " name = ? " ,[ $ _POST [ ' name ' ]])
:: toList ();| exampleticketphp | 예제 컵 케이크 | 예제 검색 | 예제 다른 방법 |
|---|---|---|---|
 |  |  |
더 많은 예 :
PDOONE을 사용하여 예제 MySQL PHP 및 PDO
이 라이브러리는 PHP 7.1 이상이 필요하며 확장 PDO 및 확장 PDO-MYSQL (MySQL), PDO-SQLSRV (SQL Server) 또는 PDO-OCI (Oracle)가 필요합니다.
Composer.json 다음 요구 사항을 편집 한 다음 Composer를 업데이트하십시오.
{
"require" : {
"eftec/PdoOne" : " ^4.0.1 "
}
}또는 CLI 사용을 통해 설치하십시오
작곡가는 EFTEC/PDOONE이 필요합니다
라이브러리에서 폴더 lib를 다운로드하고 폴더 프로젝트에 넣으십시오. 그런 다음 포함 된 모든 파일을 포함시켜야합니다.
다음과 같이 클래스 pdoone 인스턴스를 만듭니다. 그런 다음 Method Connect () 또는 Open ()을 사용하여 연결을 열 수 있습니다.
use eftec PdoOne ;
// mysql
$ dao = new PdoOne ( " mysql " , " 127.0.0.1 " , " root " , " abc.123 " , " sakila " , "" );
$ conn -> logLevel = 3 ; // it is for debug purpose and it works to find problems.
$ dao -> connect ();
// sql server 10.0.0.1instance or (local)instance or machinenameinstance or machine (default instance)
$ dao = new PdoOne ( " sqlsrv " , " (local)sqlexpress " , " sa " , " abc.123 " , " sakila " , "" );
$ conn -> logLevel = 3 ; // it is for debug purpose and it works to find problems.
$ dao -> connect ();
// test (mockup)
$ dao = new PdoOne ( " test " , " anyy " , " any " , " any " , " any " , "" );
$ dao -> connect ();
// oci (oracle) ez-connect. Remember that you must have installed Oracle Instant client and added to the path.
$ cs = ' (DESCRIPTION =(ADDRESS = (PROTOCOL = TCP)(HOST = localhost)(PORT = 1521))(CONNECT_DATA =(SERVER = DEDICATED)(SERVICE_NAME = instancia1))) ' ;
$ dao = new PdoOne ( " oci " , $ cs , " sa " , " abc.123 " ); // oracle uses the user as the schema
$ conn -> logLevel = 3 ; // it is for debug purpose and it works to find problems.
$ dao -> connect ();
// oci (oracle) tsnnames (the environment variables TNS_ADMIN and PATH must be correctly configured), also tnsnames.ora must exists.
$ cs = ' instancia1 ' ;
$ dao = new PdoOne ( " oci " , $ cs , " sa " , " abc.123 " ); // oracle uses the user as the schema
$ conn -> logLevel = 3 ; // it is for debug purpose and it works to find problems.
$ dao -> connect ();어디
$ dao = New PDOONE ( "MySQL", "127.0.0.1", "root", "ABC.123", "Sakila", "");
Oracle은 설치하기가 까다 롭습니다. Windows에서 Oracle Home의 빈 폴더에서 모든 DLL을 PHP 폴더 및 Apache 폴더에 복사해야합니다.
runRawQuery () 메소드를 사용하면 매개 변수가 있거나없는 PDO에 직접 명령을 실행할 수 있습니다. 그리고 그것은 pdostatement 또는 배열을 반환 할 수 있습니다. 우리가 속도를 원할 때 유용합니다.
runRawquery ($ rawsql, $ param, $ returnArray, $ fetchMode, $ fetchArgument)
String $ rawsql 배열 | null $ param [type1, value1, type2, value2] 또는 [name1 => value, name2 = value2] bool $ returnArray (default)라는 쿼리를 실행합니다. false 인 경우 pdostatement int $ fetchmode를 반환합니다. 예 : pdo :: fetch_assoc null $ fetchargument fetchmode의 인수.
$ sql = ' select * from table where id=1 ' ;
$ pdoStatement = $ pdoOne -> runRawQuery ( $ sql ,[], false ); // [] are the parameters그러나 배열을 반환하도록 변경할 수 있습니다
$ sql = ' select * from table where id=1 ' ;
$ values = $ pdoOne -> runRawQuery ( $ sql ); // [] are the parameters우리는 또한 매개 변수를 전달할 수 있습니다.
$ values = $ con -> runRawQuery ( ' select * from table where id=? ' ,[ 20 ]); // with parameter
$ values = $ con -> runRawQuery ( ' select * from table where id=:name ' ,[ ' name ' => 20 ]); // with named parameter
$ values = $ con -> runRawQuery ( ' select * from table ' ,[]); // without parameter.이 라이브러리는 준비된 명령문을 사용하므로 SQL 주입이 없습니다 (매개 변수를 사용하는 경우)
$ name = " O'hara " ;
$ values = $ con -> runRawQuery ( " select * from table where name=:name " ,[ ' name ' => $ name ]); // it works.✅
$ values = $ con -> runRawQuery ( " select * from table where name=? " ,[ $ name ]); // it works ok.✅
$ values = $ con -> runRawQuery ( " select * from table where name=' $ name ' " ); // it will crash.runquery () 메소드를 사용하면 pdo에서 준비된 문을 실행할 수 있습니다. 논쟁을 전달하고 싶을 때 유용합니다. runquery ()는 pdo preadingstatement가 필요합니다.
이 방법은 이미 PDO 문으로 작업하지 않는 한 권장되지 않으며 모든 코드를 조정하고 싶지 않습니다.
$ sql = " insert into `product`(name) values(?) " ;
$ stmt = $ pdoOne -> prepare ( $ sql );
$ productName = " Cocacola " ;
$ stmt -> bind_param ( " s " , $ productName ); // s stand for a string. Also i =integer, d = double and b=blob
$ rows = $ pdoOne -> runQuery ( $ stmt );
$ allRows = $ rows -> fetch_all ( PDO :: FETCH_ASSOC );쿼리 빌더를 사용하여 명령을 작성할 수 있습니다. 자세한 내용은 쿼리 빌더 (DQL)에 대한 장을 확인할 수 있습니다.
// query builder
$ pdoOne -> set ([ ' name ' => ' cocacola ' ])
-> from ( ' product ' )
-> insert ();라이브러리 eftec pdooneorm을 사용하면 테이블의 [orm] (#orm)을 만들 수 있습니다. ORM이 생성되면 다음 코드를 사용할 수 있습니다.
ProductRepo:: toList ([ ' category ' => ' drink ' ]);여기서 Productrepo는 ORM을 사용하여 생성 된 서비스 클래스입니다.
기본적으로 PDOONE은 모드에서 쿼리를 실행합니다.
$ pdo -> setFechMode ( PDO :: FETCH_CLASS , ' stdClass ' )-> runRawQuery ( $ query );
// or you can run as
$ pdo -> runRawQuery ( $ query , null , true , false , null , PDO :: FETCH_CLASS , ' stdClass ' )PDOONE은 5 가지 유형의 날짜를 허용합니다.
SQL 형식 날짜가 데이터베이스에 저장되는 방식입니다. 데이터베이스의 유형에 따라 다릅니다. 예를 들어 MySQL은 YMD 형식을 사용할 수 있습니다.
인간 형식 최종 사용자가 우리의 날짜를 어떻게 보는지 형식입니다.
ISO 날짜 형식 . 값을 전송하고 직렬화 할 수있는 형식입니다.
타임 스탬프 : 1-1970 년 이후 몇 초를 계산합니다.
클래스 / PHP 클래스 : DateTime 객체입니다.
거래를 실행하는 방법에는 3 가지가 있습니다.
| 방법 | 설명 |
|---|---|
| startTransaction () | 거래를 시작합니다. 유형 데이터베이스에 따라 쌓일 수 있습니다. |
| 저지르다() | 거래를 커밋하고 폐쇄합니다 |
| 롤백 () | 롤백 (및 마감) |
예:
try {
$ sql = " insert into `product`(name) values(?) " ;
$ pdoOne -> startTransaction ();
$ result = $ pdoOne -> runRawQuery ( $ sql ,[ ' Fanta ' => $ productName ], false );
$ pdoOne -> commit (); // transaction ok
} catch ( Exception $ e ) {
$ pdoOne -> rollback ( false ); // error, transaction cancelled, the false means that it doesn't throw an exception if we want rollback.
}테이블이 존재하는 경우 true를 반환합니다 (현재 데이터베이스/스키마)
테이블 열의 통계 (배열)를 반환합니다.
$ stats = $ pdoOne -> statValue ( ' actor ' , ' actor_id ' );| 최소 | 맥스 | avg | 합집합 | 세다 |
|---|---|---|---|---|
| 1 | 205 | 103.0000 | 21115 | 205 |
테이블의 모든 열을 반환합니다
$ result = $ pdoOne -> columnTable ( ' actor ' );| colname | Coltype | colsize | Colpres | 콜 스케일 | 이키 | isidentity |
|---|---|---|---|---|---|---|
| actor_id | smallint | 5 | 0 | 1 | 1 | |
| First_name | 바르 차 | 45 | 0 | 0 | ||
| 성 | 바르 차 | 45 | 0 | 0 | ||
| 마지막 _update | 타임 스탬프 | 0 | 0 |
테이블의 모든 외국 키를 반환합니다 (소스 테이블)
정의 및 기본 키를 사용하여 테이블을 만듭니다.
참고 : CLI (출력 클래스 코드)를 실행하여 기존 테이블을 사용하여 테이블을 만들기위한 코드를 생성 할 수 있습니다.
php pdoone.php -database mysql -server 127.0.0.1 -user root -pwd abc.123 -db sakila -input film -output classcode
예 : (MySQL)
$ pdo -> createTable ( ' film ' ,
[
" film_id " => " smallint unsigned not null auto_increment " ,
" title " => " varchar(255) not null " ,
" description " => " text " ,
" release_year " => " year " ,
" language_id " => " tinyint unsigned not null " ,
" original_language_id " => " tinyint unsigned " ,
" rental_duration " => " tinyint unsigned not null default '3' " ,
" rental_rate " => " decimal(4,2) not null default '4.99' " ,
" length " => " smallint unsigned " ,
" replacement_cost " => " decimal(5,2) not null default '19.99' " ,
" rating " => " enum('G','PG','PG-13','R','NC-17') default 'G' " ,
" special_features " => " set('Trailers','Commentaries','Deleted Scenes','Behind the Scenes') " ,
" last_update " => " timestamp not null default CURRENT_TIMESTAMP on update CURRENT_TIMESTAMP "
],[
" film_id " => " PRIMARY KEY " ,
" title " => " KEY " ,
" language_id " => " FOREIGN KEY REFERENCES`language`(`language_id`) ON UPDATE CASCADE " ,
" original_language_id " => " FOREIGN KEY REFERENCES`language`(`language_id`) ON UPDATE CASCADE "
]); $ pdo -> createTable ( ' film ' ,
[
" film_id " => " smallint unsigned not null auto_increment " ,
" title " => " varchar(255) not null " ,
" description " => " text " ,
" release_year " => " year " ,
" language_id " => " tinyint unsigned not null " ,
" original_language_id " => " tinyint unsigned " ,
" rental_duration " => " tinyint unsigned not null default '3' " ,
" rental_rate " => " decimal(4,2) not null default '4.99' " ,
" length " => " smallint unsigned " ,
" replacement_cost " => " decimal(5,2) not null default '19.99' " ,
" rating " => " enum('G','PG','PG-13','R','NC-17') default 'G' " ,
" special_features " => " set('Trailers','Commentaries','Deleted Scenes','Behind the Scenes') " ,
" last_update " => " timestamp not null default CURRENT_TIMESTAMP on update CURRENT_TIMESTAMP "
], ' film_id ' ); 예제 (SQLSRV)
$ pdo -> createTable ( ' film ' ,
[
" film_id " => " int NOT NULL IDENTITY(1,1) " ,
" title " => " varchar(255) NOT NULL " ,
" description " => " text(2147483647) DEFAULT (NULL) " ,
" release_year " => " varchar(4) " ,
" language_id " => " tinyint NOT NULL " ,
" original_language_id " => " tinyint DEFAULT (NULL) " ,
" rental_duration " => " tinyint NOT NULL DEFAULT ((3)) " ,
" rental_rate " => " decimal(4,2) NOT NULL DEFAULT ((4.99)) " ,
" length " => " smallint DEFAULT (NULL) " ,
" replacement_cost " => " decimal(5,2) NOT NULL DEFAULT ((19.99)) " ,
" rating " => " varchar(10) DEFAULT ('G') " ,
" special_features " => " varchar(255) DEFAULT (NULL) " ,
" last_update " => " datetime NOT NULL DEFAULT (getdate()) "
],[
" language_id " => " FOREIGN KEY REFERENCES language(language_id) " ,
" original_language_id " => " FOREIGN KEY REFERENCES language(language_id) " ,
" film_id " => " PRIMARY KEY "
]);종속성으로 주문한 테이블 목록을 반환합니다 (의존하지 않고 더 종속적으로)
참고 : 테이블에 원형 참조가있을 수 있으므로이 작업은 완벽하지 않습니다.
$ dao = new PdoOne ( ' sqlsrv ' , " (local)sqlexpress " , " sa " , " abc.123 " , " sakila " );
$ dao -> open ();
echo " <pre> " ;
var_dump ( $ dao -> tableSorted ( 3 , false , true )); // it returns the tables sortered
var_dump ( $ dao -> tableSorted ( 3 , true , true )); // it returns all the tables that can't be sortered
echo " </pre> " ;테이블이 값별로 서명 된 정의와 일치하는 경우 테이블을 확인합니다.
$def=[
"film_id" => "int NOT NULL IDENTITY(1,1)",
"title" => "varchar(255) NOT NULL",
"description" => "text(2147483647) DEFAULT (NULL)",
"release_year" => "varchar(4)",
"language_id" => "tinyint NOT NULL",
"original_language_id" => "tinyint DEFAULT (NULL)",
"rental_duration" => "tinyint NOT NULL DEFAULT ((3))",
"rental_rate" => "decimal(4,2) NOT NULL DEFAULT ((4.99))",
"length" => "smallint DEFAULT (NULL)",
"replacement_cost" => "decimal(5,2) NOT NULL DEFAULT ((19.99))",
"rating" => "varchar(10) DEFAULT ('G')",
"special_features" => "varchar(255) DEFAULT (NULL)",
"last_update" => "datetime NOT NULL DEFAULT (getdate())"
];
$keys=[
"language_id" => "FOREIGN KEY REFERENCES language(language_id)",
"original_language_id" => "FOREIGN KEY REFERENCES language(language_id)",
"film_id" => "PRIMARY KEY"
];
var_dump(PdoOne::validateDefTable(self::getPdoOne(),self::TABLE,$def,$keys));
테이블의 모든 외국 키를 반환합니다.
$ result = $ pdoOne -> foreignKeyTable ( ' actor ' );| Collocal | 태블릿 | Colrem |
|---|---|---|
| customer_id | 고객 | customer_id |
| rental_id | 임대 | rental_id |
| 직원 _id | 직원 | 직원 _id |
절차 쿼리를 구축 할 수도 있습니다.
예:
$ results = $ pdoOne -> select ( " * " )-> from ( " producttype " )
-> where ( ' name=? ' , [ ' Cocacola ' ])
-> where ( ' idproducttype=? ' , [ 1 ])
-> toList (); 반환 할 열을 나타냅니다. 인수는 SQL 명령이므로 기능, 상수, 연산자, 별명 등을 포함하여 데이터베이스가 지원하는 작업이 가능합니다.
$ results = $ pdoOne -> select ( " col1,col2 " ); //...쿼리 생성 : col1, col2를 선택하십시오 ....
$ results = $ pdoOne -> select ( " select * from table " ); //->...쿼리 생성 : 선택 *에서 테이블에서 ....
값 수를 반환하는 쿼리를 생성합니다. Select () 메소드의 매크로입니다.
$ result = $ pdoOne -> count ( ' from table where condition=1 ' ); // select count(*) from table where c..
$ result = $ pdoOne -> count ()-> from ( ' table ' )-> where ( ' condition=? ' ,[ 1 ]); // select count(*) from table where c..
$ result = $ pdoOne -> count ( ' from table ' , ' col1 ' ); // select count(col1) from table
$ result = $ pdoOne -> count ()-> from ( ' table ' ); // select count(*) from table열의 최소값을 반환하는 쿼리를 생성합니다. $ arg가 비어 있으면 열의 이름에 $ sql을 사용합니다.
$ result = $ pdoOne -> min ( ' from table where condition=1 ' , ' col ' ); // select min(col) from table where c..
$ result = $ pdoOne -> min ( ' from table ' , ' col1 ' ); // select min(col1) from table
$ result = $ pdoOne -> min ( '' , ' col1 ' )-> from ( ' table ' ); // select min(col1) from table
$ result = $ pdoOne -> min ( ' col1 ' )-> from ( ' table ' ); // select min(col1) from table열의 최대 값을 반환하는 쿼리를 생성합니다. $ arg가 비어 있으면 열의 이름에 $ sql을 사용합니다.
$ result = $ pdoOne -> max ( ' from table where condition=1 ' , ' col ' ); // select max(col) from table where c..
$ result = $ pdoOne -> max ( ' from table ' , ' col1 ' ); // select max(col1) from table열의 합계 값을 반환하는 쿼리를 생성합니다. $ arg가 비어 있으면 열의 이름에 $ sql을 사용합니다.
$ result = $ pdoOne -> sum ( ' from table where condition=1 ' , ' col ' ); // select sum(col) from table where c..
$ result = $ pdoOne -> sum ( ' from table ' , ' col1 ' ); // select sum(col1) from table열의 평균 값을 반환하는 쿼리를 생성합니다. $ arg가 비어 있으면 열의 이름에 $ sql을 사용합니다.
$ result = $ pdoOne -> avg ( ' from table where condition=1 ' , ' col ' ); // select avg(col) from table where c..
$ result = $ pdoOne -> avg ( ' from table ' , ' col1 ' ); // select avg(col1) from table선택 명령을 생성합니다.
$ results = $ pdoOne -> select ( " col1,col2 " )-> distinct (); //...쿼리 생성 : 별도의 col1, col2를 선택하십시오 ....
참고 : -> CORLET ( '고유') 반환 SELECT SELECT CORITED ..
"From"SQL 명령을 생성합니다.
$ results = $ pdoOne -> select ( " * " )-> from ( ' table ' ); //...쿼리를 생성합니다 : 선택 * 에서 테이블에서
$ 테이블은 단일 테이블 또는 SQL 구조 일 수 있습니다. Examp의 경우 다음 명령이 유효합니다.
$ results = $ pdoOne -> select ( " * " )-> from ( ' table t1 inner join t2 on t1.c1=t2.c2 ' ); //...Where 명령을 생성합니다.
$ results = $ pdoOne -> select ( " * " )
-> from ( ' table ' )
-> where ( ' p1=1 ' ); //...어디서는 다른 방식으로 표현 될 수 있습니다.
다음과 같이 매개 변수가없는 위치를 작성할 수 있습니다.
$ results = $ pdoOne -> select ( " * " )-> from ( ' table ' )-> where ( " p1=1 and p2>2.5 or p3 like '%aa%' " ); $ aa = ' aa ' ;
$ results = $ pdoOne -> select ( " * " )-> from ( ' table ' )-> where ( " p1=? and p2>? or p3 like ? " ,[ 1
, 2.5
, " % $ aa % " ]);또한 작동합니다
// (if there is only a single argument without a type)
$ results = $ pdoOne -> select ( " * " )-> from ( ' table ' )-> where ( " p1=? " ,[ 1 ]); // = where("p1=?",[1]);
// (if we don't define to where to put the value)
$ results = $ pdoOne -> select ( " * " )-> from ( ' table ' )-> where ( " p1 " ,[ 1 ]); // = where("p1=?",[1]); 연관 배열을 사용한 쿼리의 속기 정의입니다. 여기서 키는 열의 이름이고 값은 비교할 값입니다.
평등 (=) 및 논리 연산자 '및' (유형이 자동으로 정의 됨)에서만 작동합니다.
// select * from table where p1='1' and p2='2.5' and p3='aa'
$ results = $ pdoOne -> select ( " * " )-> from ( ' table ' )-> where ([ ' p1 ' => 1
, ' p2 ' => 2.5
, ' p3 ' => ' aa ' ]); 또한 매개 변수 유형을 지정할 수 있습니다.
// select * from table where p1=1 and p2='2.5' and p3='aa'
$ results = $ pdoOne -> select ( " * " )-> from ( ' table ' )-> where ([ ' p1 ' =>[ 1 ]
, ' p2 ' =>[ 2.5 ]
, ' p3 ' =>[ ' aa ' ]]); 연관 배열을 인수로 사용하고 쿼리의 이름이 지정된 매개 변수를 사용할 수도 있습니다.
$ results = $ pdoOne -> select ( " * " )-> from ( " table " )
-> where ( ' condition=:p1 and condition2=:p2 ' ,[ ' p1 ' => ' Coca-Cola ' , ' p2 ' => 1 ])
-> toList ();쿼리를 생성합니다 : 선택 *에서 조건 =? (코카콜라) 및 조건 2 =? (1)
쿼리를 생성합니다 : 테이블에서 p1 = 1을 선택하십시오
참고 : ArrayParameters는 다음과 같이 배열입니다. 유형, 값.
여기서 유형은 i = 정수, d = double, s = string 또는 b = blob입니다. 의심의 경우 "S"를 사용하십시오 (테이블 벨로우 참조)
ArrayParameters의 예 :
[1, 'Hello', 20.3, 'World']]
$ results = $ pdoOne -> select ( " * " )
-> from ( ' table ' )
-> where ( ' p1=? ' ,[ 1 ]); //...쿼리 생성 : p1 =? (1)
$ results = $ pdoOne -> select ( " * " )
-> from ( ' table ' )
-> where ( ' p1=? and p2=? ' ,[ 1 , ' hello ' ]); //...쿼리 생성 : p1 =? (1) 및 p2 =? ( 'hello') 를 선택하십시오.
메모. 중첩 될 수있는 곳.
$ results = $ pdoOne -> select ( " * " )
-> from ( ' table ' )
-> where ( ' p1=? ' ,[ 1 ])
-> where ( ' p2=? ' ,[ ' hello ' ]); //...쿼리 생성 : p1 =? (1) 및 p2 =? ( 'hello') 를 선택하십시오.
당신은 또한 사용할 수 있습니다 :
$ results = $ pdoOne -> select ( " * " )-> from ( " table " )
-> where ([ ' p1 ' => ' Coca-Cola ' , ' p2 ' => 1 ])
-> toList ();쿼리 생성 : p1 =? (코카콜라) 및 p2 =? (1)
주문 명령을 생성합니다.
$ results = $ pdoOne -> select ( " * " )
-> from ( ' table ' )
-> order ( ' p1 desc ' ); //...쿼리 생성 : P1 DESC의 TABLE ORDER를 선택하십시오.
그룹 명령을 생성합니다.
$ results = $ pdoOne -> select ( " * " )
-> from ( ' table ' )
-> group ( ' p1 ' ); //...쿼리 생성 : P1의 Table Group 에서 * 선택 * 선택
while 명령을 생성합니다.
참고 : 여기서와 동일한 매개 변수를 사용합니다.
$ results = $ pdoOne -> select ( " * " )
-> from ( ' table ' )
-> group ( ' p1 ' )
-> having ( ' p1>? ' , array ( 1 )); //...쿼리 생성 : P1> (1)
참고 : ()->가
참고 : 매개 변수가 없을 수 있습니다 ( 'col> 10')
쿼리 생성을 실행하십시오.
참고 returnArray가 true 인 경우 연관 배열을 반환합니다. returnArray가 false 인 경우 mysqli_result를 반환합니다
참고 : 현재 매개 변수를 재설정합니다 (예 : 현재 선택, From, Where 등).
Rungen () 의 매크로입니다. 작업이 실패하면 연관 배열 또는 False를 반환합니다.
$ results = $ pdoOne -> select ( " * " )
-> from ( ' table ' )
-> toList (); 현재 쿼리에서 pdostatement를 반환합니다
참고 : 문을 루프하려면 fetchLoop ()를 사용할 수 있습니다.
예 :
$ stmt = $ pdoOne -> select ( " * " )
-> from ( ' table ' )
-> toPdoStatement ();
while ( $ row = $ stmt -> fetch ()) {
// do something
} 모든 행에 대한 쿼리를 가져옵니다.
이 방법은 모든 정보를 한 번에 읽고 싶지 않을 때 사용할 수 있으므로 각 줄을 별도로 읽고 처리 할 수 있습니다.
예 :
$ this -> select ( ' select id,name from table ' )
-> fetchLoop ( static function ( $ row ) { return ( $ row );}, PDO :: FETCH_ASSOC )쿼리의 각 열에서 메타 코드 (정의)를 반환합니다.
$ results = $ pdoOne -> select ( " * " )
-> from ( ' table ' )
-> toMeta (); 또는
$ results = $ pdoOne -> toMeta ( ' select * from table ' ); 결과:
array(3) {
[0]=>
array(7) {
["native_type"]=>
string(4) "LONG"
["pdo_type"]=>
int(2)
["flags"]=>
array(2) {
[0]=>
string(8) "not_null"
[1]=>
string(11) "primary_key"
}
["table"]=>
string(11) "producttype"
["name"]=>
string(13) "idproducttype"
["len"]=>
int(11)
["precision"]=>
int(0)
}
[1]=>
array(7) {
["native_type"]=>
string(10) "VAR_STRING"
["pdo_type"]=>
int(2)
["flags"]=>
array(0) {
}
["table"]=>
string(11) "producttype"
["name"]=>
string(4) "name"
["len"]=>
int(135)
["precision"]=>
int(0)
}
}
Rungen의 매크로입니다. 첫 번째 열에서 인덱스 배열을 반환합니다
$ results = $ pdoOne -> select ( " * " )
-> from ( ' table ' )
-> toListSimple (); // ['1','2','3','4'] 첫 번째 값이 키이고 두 번째 값은 값 인 연관 배열을 반환합니다.
두 번째 값이 존재하지 않으면 인덱스를 값 (첫 번째 값)으로 사용합니다.
$ results = $ pdoOne -> select ( " cod,name " )
-> from ( ' table ' )
-> toListKeyValue (); // ['cod1'=>'name1','cod2'=>'name2'] Rungen의 매크로입니다. mysqli_result 또는 null을 반환합니다.
$ results = $ pdoOne -> select ( " * " )
-> from ( ' table ' )
-> toResult (); // 쿼리의 첫 번째 스칼라 (1 값)를 반환합니다. $ colname이 null이면 첫 번째 열을 사용합니다.
$ count = $ this -> count ( ' from product_category ' )-> firstScalar ();Rungen의 매크로입니다. 그렇지 않은 경우 첫 번째 행을 반환합니다.
$ results = $ pdoOne -> select ( " * " )
-> from ( ' table ' )
-> first (); Rungen의 매크로입니다. 연관 배열로 마지막 행을 반환합니다 (그렇지 않은 경우 false를 반환합니다).
$ results = $ pdoOne -> select ( " * " )
-> from ( ' table ' )
-> last (); Last ()가 모든 값을 읽기 때문에 Order () 및 First ()를 실행하는 것이 더 효율적입니다.
SQL 명령과 문자열을 반환합니다.
$ sql = $ pdoOne -> select ( " * " )
-> from ( ' table ' )
-> sqlGen ();
echo $ sql ; // returns select * from table
$ results = $ pdoOne -> toList (); // executes the query참고 : 쿼리를 재설정하지 않습니다.
각 명령을 실행하는 4 가지 방법이 있습니다.
값 20 의 열 1 열에 정수를 추가하고 싶다고 가정 해 봅시다.
값 목록을 사용한 스키마 및 값 : 첫 번째 값은 열이면 두 번째 값은 값 유형 (i = 정수, d = double, s = string, b = blob)이며 두 번째 배열에는 값이 포함됩니다.
$ pdoOne -> insert ( " table "
,[ ' col1 ' ]
,[ 20 ]);동일한 목록의 스키마 및 값 : 첫 번째 값은 열이면 두 번째 값은 값 유형 (i = 정수, d = double, s = string, b = blob)이고 세 번째는 값입니다.
$ pdoOne -> insert ( " table "
,[ ' col1 ' , 20 ]);두 개의 연관 배열을 사용한 스키마 및 값 :
$ pdoOne -> insert ( " table "
,[ ' col1 ' ]
,[ ' col1 ' => 20 ]);단일 연관 배열을 사용한 스키마 및 값 : 유형은 자동으로 계산됩니다.
$ pdoOne -> insert ( " table "
,[ ' col1 ' => 20 ]);삽입 명령을 생성합니다.
$ pdoOne -> insert ( " producttype "
,[ ' idproducttype ' , ' name ' , ' type ' ]
,[ 1 , ' cocacola ' , 1 ]);중첩 체인 사용 (단일 배열)
$ pdoOne -> from ( " producttype " )
-> set ([ ' idproducttype ' , 0 , ' name ' , ' Pepsi ' , ' type ' , 1 ])
-> insert ();중첩 체인 다중 세트 사용
$ pdoOne -> from ( " producttype " )
-> set ( " idproducttype=? " ,[ 101 ])
-> set ( ' name=? ' ,[ ' Pepsi ' ])
-> set ( ' type=? ' ,[ 1 ])
-> insert ();또는 (유형은 MySQL에 의해 자동으로 가능한 유형에 정의됩니다)
$ pdoOne -> from ( " producttype " )
-> set ( " idproducttype=? " ,[ 101 ])
-> set ( ' name=? ' , ' Pepsi ' )
-> set ( ' type=? ' , 1 )
-> insert (); $ pdoOne -> insertObject ( ' table ' ,[ ' Id ' => 1 , ' Name ' => ' CocaCola ' ]);중첩 체인 선언 세트 사용
$ pdoOne -> from ( " producttype " )
-> set ( ' (idproducttype,name,type) values (?,?,?) ' ,[ 100 , ' Pepsi ' , 1 ])
-> insert ();쿼리 생성 : producttype (idproducttype, name, type) 값 (?,?,?)에 삽입합니다 . ....
삽입 명령을 생성합니다.
$ pdoOne -> update ( " producttype "
,[ ' name ' , ' type ' ] //set
,[ 6 , ' Captain-Crunch ' , 2 ] //set
,[ ' idproducttype ' ] // where
,[ 6 ]); // where $ pdoOne -> update ( " producttype "
,[ ' name ' => ' Captain-Crunch ' , ' type ' => 2 ] // set
,[ ' idproducttype ' => 6 ]); // where $ pdoOne -> from ( " producttype " )
-> set ( " name=? " ,[ ' Captain-Crunch ' ]) //set
-> set ( " type=? " ,[ 6 ]) //set
-> where ( ' idproducttype=? ' ,[ 6 ]) // where
-> update (); // update또는
$ pdoOne -> from ( " producttype " )
-> set ( " name=? " , ' Captain-Crunch ' ) //set
-> set ( " type=? " , 6 ) //set
-> where ( ' idproducttype=? ' ,[ 6 ]) // where
-> update (); // update쿼리 생성 : update productType set
name=?,type=?idproducttype=? .... ....
삭제 명령을 생성합니다.
$ pdoOne -> delete ( " producttype "
,[ ' idproducttype ' ] // where
,[ 7 ]); // where $ pdoOne -> delete ( " producttype "
,[ ' idproducttype ' => 7 ]); // where쿼리 생성 : uppledtype에서 삭제 된
idproducttype=? .... ....
DQL 빌더 체인을 통해 삭제할 수도 있습니다.
$ pdoOne -> from ( " producttype " )
-> where ( ' idproducttype=? ' ,[ 7 ]) // where
-> delete (); $ pdoOne -> from ( " producttype " )
-> where ([ ' idproducttype ' => 7 ]) // where
-> delete (); 쿼리 생성 : uppledtype에서 삭제 된
idproducttype=? .... ....
쿼리 결과를 선택적으로 캐시 할 수 있습니다. 쿼리 기간은 쿼리에 정의됩니다. 쿼리 결과가 캐시되지 않으면 정상적으로 계산됩니다 (데이터베이스에서 쿼리 실행). 쿼리를 고유 한 것으로 식별하기 위해 시스템은 쿼리, 매개 변수, 메소드 및 작동 유형으로 생성 된 SHA256을 기반으로 한 고유 ID (UID)를 생성합니다.
라이브러리는 캐시 작동을 직접 수행하지 않고 대신 외부 라이브러리를 사용하여 결과를 캐시 할 수 있습니다.
class CacheService implements eftec IPdoOneCache {
public $ cacheData =[];
public $ cacheCounter = 0 ; // for debug
public function getCache ( $ uid , $ family = '' ) {
if ( isset ( $ this -> cacheData [ $ uid ])) {
$ this -> cacheCounter ++;
echo " using cache n" ;
return $ this -> cacheData [ $ uid ];
}
return false ;
}
public function setCache ( $ uid , $ family = '' , $ data = null , $ ttl = null ) {
$ this -> cacheData [ $ uid ]= $ data ;
}
public function invalidateCache ( $ uid = '' , $ family = '' ) {
unset( $ this -> cacheData [ $ uid ]);
}
}
$ cache = new CacheService ();(2) 캐시 서비스를 설정합니다
$ pdoOne = new PdoOne ( " mysql " , " 127.0.0.1 " , " travis " , "" , " travisdb " );
$ cache = new CacheService ();
$ $ pdoOne -> setCacheService ( $ cache );(3) 다음과 같이 캐시를 사용하십시오. 쿼리의 어느 부분에 usecache () 메소드를 추가해야합니다.
$ pdoOne -> select ( ' select * from table ' )
-> useCache ()-> toList (); // cache that never expires
$ pdoOne -> select ( ' select * from table ' )
-> useCache ( 1000 )-> toList (); // cache that lasts 1000ms. class CacheService implements eftec IPdoOneCache {
public function getCache ( $ uid , $ family = '' ) {
return apcu_fetch ( $ uid );
}
public function setCache ( $ uid , $ family = '' , $ data = null , $ ttl = null ) {
apcu_store ( $ uid , $ data , $ ttl );
}
public function invalidateCache ( $ uid = '' , $ family = '' ) {
// invalidate cache
apcu_delete ( $ uid );
}
}
$ cache = new CacheService ();시퀀스는 auto_numeric (Identity) 필드의 대안입니다. 시퀀스를 생성하는 두 가지 방법의 두 가지 방법이 있습니다 : 눈송이 및 시퀀스 . 숫자를 반환하기 때문에 주로 안내서를 만드는 것이 대안입니다 (안내서는 일반적으로 색인 및 저장 비용이 더 비싸다는 문자열입니다).
시퀀스의 목표는 반복되지 않은 고유 한 숫자를 만드는 것입니다.
$ dao -> nodeId = 1 ; // optional
$ dao -> tableSequence = ' snowflake ' ; // optional
$ dao -> createSequence (); // it creates a table (and it could create a store procedure) called snowflake and a function called next_snowflake(). You could create it only once.테이블없이 새 시퀀스를 만들 수 있습니다. 빠르지 만 충돌 문제가있을 수 있습니다.
0.0001 초당 하나 이상의 작업을 수행하지 않는 경우에만 충돌이없는 번호를 보장하지만 의사 임의 숫자 (시간에 따라 0-4095)를 추가하므로 충돌 가능성은 1/4095 (0.0001 초마다 2 개의 작업 당)입니다. 트위터의 눈송이 번호를 기반으로합니다. 즉. 초당 백만 미만의 운영을 수행하는 경우 (기술적으로 : 45 백만) 충돌이 안전합니다 .
$ pdo-> getSequencephp ([예측할 수없는 = 거짓])는 테이블을 사용하지 않고 시퀀스를 반환합니다. 이 순서는 $ dao-> getSequence보다 효율적이지만 충돌을 처리하기 위해 임의의 값을 사용합니다.
Upedictable이 사실이라면 예측할 수없는 숫자를 반환합니다 (일부 숫자를 뒤집습니다).
$ pdo -> getSequencePHP () // string(19) "3639032938181434317" $ dao -> getSequencePHP ( true ) // string(19) "1739032938181434311" $ pdo ->getSequence() // string(19) "3639032938181434317"
$ pdo -> getSequencePHP () // string(19) "3639032938181434317" $ pdo -> getSequence ( true ) // returns a sequence by flipping some values.
$ pdo -> getSequencePHP ( true ) // string(19) "1739032938181434311" | 필드 | 설명 | 예 |
|---|---|---|
| $ prefixbase | 모든 테이블에 접두사를 추가 해야하는 경우 | $ this-> prefixbase = 'example_'; |
| $ internalcachecounter | 내부 캐시의 조회수 카운터. | $ this-> internalcachecounter =; |
| $ nodeid | 시퀀스에 의해 사용됩니다 (눈송이). nodeid 노드의 식별자입니다. 0..1023 사이 여야합니다 | $ this-> nodeid = 3; |
| $ tableSequence | 테이블 시퀀스의 이름 (눈송이) | $ this-> tableSequence = "tableSeq1"; |
| $ masks0 | 예측할 수없는 숫자를 생성하려면 (순서로 사용) | $ this-> masks0 = [0,1,2,3,4]; |
| $ masks1 | 예측할 수없는 숫자를 생성하려면 (순서로 사용) | $ this-> masks1 = [4,3,2,1,0]; |
| $ DatabaseType | 현재 데이터베이스 유형. EL 생성자를 통해 설정됩니다 | echo $ this-> databaseType; |
| $ 서버 | 현재 서버 시스템 | echo $ this-> 서버; |
| $ 사용자 | 현재 사용자 | echo $ this-> user; |
| $ pwd | 현재 비밀번호 | echo $ this-> pwd; |
| $ db | 현재 데이터베이스 또는 스키마 (Oracle 은이 값을 무시합니다) | echo $ this-> db; |
| $ 숯불 | 기본 숯을 설정합니다. 생성자를 통해 설정해야합니다 | echo $ this-> charset; |
| $ ISOPEN | 데이터베이스가 그렇지 않으면 연결되어 있으면 거짓입니다. | if ($ this-> isopen) {…}; |
| $ ThrowOnerror | true (기본값) 인 경우 오류가 발생하면 오류가 발생합니다. 거짓이면 실행이 계속됩니다 | $ this-> strowOnerror = false; |
| $ conn1 | pdo의 인스턴스. 설정하거나 직접 사용할 수 있습니다. | $ this-> conn1-> pdostatement (..); |
| $ transactionOpen | 트랜잭션이 열려 있으면 사실입니다 | if ($ this-> transactionOpen) {…}; |
| $ readonly | 데이터베이스가 읽기 전용 모드에있는 경우 사실이라면 데이터베이스에 쓰지 않아야합니다. | $ this-> readOnly = true; |
| $ logfile | 로그 파일의 전체 파일 이름. 비어 있으면 로그 파일을 저장하지 않습니다. 로그 파일은 1MB로 제한됩니다 | $ this-> logfile = "/folder/file.log"; |
| $ errortext | 마지막 오류를 저장합니다. runget과 thegtry는 그것을 재설정합니다 | echo $ this-> errortext; |
| $ isthrow | TODO | $ this-> isthrow =; |
| $ loglevel | 로그의 현재 레벨을 나타냅니다. 0 = 로그 없음 (생산 용), 3 = 전체 로그 | $ this-> loglevel = 3; |
| $ lastquery | 마지막 쿼리 실행 | echo $ this-> lastquery; |
| $ lastparam | 마지막 매개 변수. 연관 배열입니다 | echo $ this-> lastparam; |
이 라이브러리는 정보의 암호화/암호 해독을 허용합니다.
암호화를 설정하려면 다음 명령을 사용할 수 있습니다.
$ this -> setEncryption ( 12345678 , '' , ' INTEGER ' ); // the type of encryption is integer and it only works with integers. It doesn't use a salt value
$ this -> setEncryption ( ' password ' , ' some-salt ' , ' AES-256-CTR ' ); // the password, the salt and the type of encryption (aes-256-ctr), you can use other methods
$ this -> setEncryption ( ' passwrd ' , '' , ' SIMPLE ' ); // the type of encryption is simple and it only works with primitive values. It doesn't use a salt.그런 다음 사용 값을 암호화하고 해독 할 수 있습니다
$ encrypted = $ this -> encrypt ( $ original ); // encrypt $original
$ original = $ this -> decrypt ( $ encrypted ); // decrypt $encrypted예:
$ this -> setEncryption ( ' 12345 ' , ' salt-1234 ' ); // it will use AES-256-CTR, the password and the salt must be secret.
// create user
$ this -> set ([ ' username ' => 1 , ' password ' => $ this -> encrypt ( $ password )])
-> from ( ' user ' )
-> insert ();
// validate user
$ user = $ this -> select ([ ' username ' , ' password ' ])
-> from ( ' user ' )
-> where ([ ' username ' , ' password ' ],[ 1 , $ this -> encrypt ( $ password )])
-> first ();
// $user= if false or null then the user does not exist or the password is incorrect. 로그 레벨을 3으로 설정할 수 있습니다. 로그 레벨은 작동에 실패하면 로그 레벨이 높아지면 대부분의 정보가 표시됩니다.
$ pdoOne -> logLevel = 3 ; // the highest for debug.기본적으로 PDOONE은 PHP 오류를 던지지 만 Field $ ThrowOnerror를 False로 설정하여 피할 수 있습니다.
$ pdoOne -> throwOnError = false ; // it could be used in production. var_dump ( $ pdoOne -> lastQuery ); // it shows the last query
var_dump ( $ pdoOne -> lastParam ); // and it shows the last parameters.비어 있으면 로그 파일을 생성하지 않습니다 (PHP 로그 파일 사용)
$ pdoOne -> logFile = true ; PDOONE 에는 CLI에서만 사용할 수있는 몇 가지 기능이 있습니다.
다음 줄을 실행하십시오 (Lib 폴더에서)
php pdoonecli.php
(또는 오른쪽 폴더를 가리키는)
Php/var/web/vendor/eftec/lib/pdoonecli
플래그 "-i"를 사용하여 대화식 모드로 들어갈 수 있습니다.
탭 키를 사용하여 자동 완성 값 (있는 경우)을 사용할 수 있습니다.
참고 : 구성을 저장하고로드 할 수도 있습니다.
MySQL에 연결하고 "Actor"테이블에서 CSV를 생성하십시오.
# # via arguments
php pdoonecli --databasetype mysql --server 127.0.0.1 -u root -p abc.123 --database sakila -in actor -out csv
# # via user input (interactive)
php pdoonecli -i -in actor -out csv파일에 구성을 저장하십시오
php pdoonecli --databasetype mysql --server 127.0.0.1 -u root -p abc.123 --database sakila --saveconfig myconfig파일에서 구성을로드하십시오
php pdoonecli --loadconfig myconfig -in actor -out csv플래그 "-cli"를 사용하여 저장소 클래스를 생성 할 수 있습니다.
CLI는 대화식이며 구성을로드하고 저장할 수 있습니다.
기능은 즉시 사용 가능한 저장소 클래스를 생성합니다.
다음 예를 들어 봅시다
mysql :
php pdoone.php -database mysql --server 127.0.0.1:3306 -user root -p abc.123 -db sakila -입력 "액터" -출력 클래스 코드
sqlsrv :
php pdoone.php -database sqlsrv --server pcjc sqlexpress --user sa -p abc.123 -db sakila -입력 "actor" -출력 클래스 코드
데이터베이스 MySQL, IP : 127.0.0.1 및 데이터베이스 Sakila에 연결되며 "Actor"테이블을 읽습니다.
다음 결과를 반환합니다
/**
* Generated by PdoOne Version 1.28
* Class ActorRepo
*/
class ActorRepo
{
const TABLE = ' Actor ' ;
const PK = ' actor_id ' ;
/** @var PdoOne */
public static $ pdoOne = null ;
/**
* It creates a new table<br>
* If the table exists then the operation is ignored (and it returns false)
*
* @param array $definition
* @param null $extra
*
* @return array|bool|PDOStatement
* @throws Exception
*/
public static function createTable ( $ definition , $ extra = null ) {
if (! self :: getPdoOne ()-> tableExist ( self :: TABLE )) {
return self :: getPdoOne ()-> createTable ( self :: TABLE , $ definition , self :: PK , $ extra );
}
return false ; // table already exist
}
// .....
}이 기능은 가장 일반적인 작업과 함께 새 저장소 클래스를 생성합니다. 인서트, 목록, 업데이트, 삭제, 삭제, 카운트, 테이블 작성, 테이블 및 절단 테이블은
왜 수업을 생성해야합니까? (상속 대신)이 CRUD 클래스는 시작점 일뿐입니다. 개발자는 코드를 수정하고, 새 메소드를 추가하고, 이전 방법을 수정하는 등을 수정할 수 있습니다.
클래스를 사용하기 위해 다음 코드를 작성할 수 있습니다.
// 1) option 1, inject an instance of $pdo
ActorRepo:: setPdoOne ( $ pdoOne ); // it inject the current connect to the database
// 2) option 2.
// If the global variable $pdoOne exists, then it is injected. (unless it is defined by using setPdoOne()
$ pdoOne = new PdoOne ( " mysql " , " 127.0.0.1 " , " root " , " abc.123 " , " sakila " , "" );
$ pdoOne -> connect ();
// 3) option 3
// If the global function pdoOne() exists, then it is used for obtain the instance.
function pdoOne () {
global $ pdo ;
if ( $ pdo === null ) {
$ pdo = new PdoOne ( ' mysql ' , ' 127.0.0.1 ' , ' root ' , ' abc.123 ' , ' sakila ' );
}
return $ pdo ;
}
$ actorActorRepo :: get ( 2 ); // it will read the actor with the pk=2 and it will return as an array.
$ actors = $ actorArray =ActorRepo:: select (); // it returns all the rows.또는 다음과 같이 PHP 파일을 자동으로 생성 할 수 있습니다.
php pdoone.php -database mysql -server 127.0.0.1:3306 -user root -pwd abc.123 -db sakila -input "actor"-output classcode> actorrepo.php.
참고 : 코드에는 PHP- 태그, 네임 스페이스 및 사용이 부족하지만 다른 모든 것은 여기에 있습니다.
쿼리가 필요하며 쿼리가 형식으로 포맷 된 PHP 코드를 반환합니다.
예:
php pdoone.php -database mysql -server 127.0.0.1:3306 -user root -pwd abc.123 -db sakila -input "select * from actor" -output selectCode
다음 코드를 생성합니다.
/** @var array $result=array(["actor_id"=>0,"first_name"=>'',"last_name"=>'',"last_update"=>'']) */
$ result = $ pdo
-> select ( " * " )
-> from ( " actor " )
-> toList ();선택한 쿼리 또는 테이블을 기반으로 한 연관 배열 (기본값 포함)을 생성합니다.
php pdoone.php -database mysql -server 127.0.0.1:3306 -user root -pwd abc.123 -db sakila -input "select * from actor" -output arraycode
돌아올 것입니다 :
// ["actor_id"=>0,"first_name"=>'',"last_name"=>'',"last_update"=>'']쿼리 결과를 JSON으로 반환합니다.
php pdoone.php -database mysql -server 127.0.0.1:3306 -user root -pwd abc.123 -db sakila -input "select * from actor"-output json
돌아올 것입니다 :
[{ "actor_id" : " 1 " , "first_name" : " PENELOPE " , "last_name" : " GUINESS " , "last_update" : " 2006-02-15 01:34:33 " }
,{ "actor_id" : " 2 " , "first_name" : " NICK " , "last_name" : " WAHLBERG " , "last_update" : " 2006-02-15 01:34:33 " }
,{ "actor_id" : " 3 " , "first_name" : " ED " , "last_name" : " CHASE " , "last_update" : " 2006-02-15 01:34:33 " }
,{ "actor_id" : " 4 " , "first_name" : " JENNIFER " , "last_name" : " DAVIS " , " last_update " }]쿼리 결과를 JSON으로 반환합니다.
php pdoone.php -database mysql -server 127.0.0.1:3306 -user root -pwd abc.123 -db sakila -input "select * from actor"-output csv
돌아올 것입니다 :
actor_id,first_name,last_name,last_update
1,"PENELOPE","GUINESS","2006-02-15 01:34:33"
2,"NICK","WAHLBERG","2006-02-15 01:34:33"
3,"ED","CHASE","2006-02-15 01:34:33"
4,"JENNIFER","DAVIS","2006-02-15 01:34:33"
또는 CLI에 라이브러리에는 인터페이스 비주얼이 있습니다. CLI의 모든 작동을 수행합니다.
메소드 렌더 ()를 호출하기 만하면
<?php
use eftec PdoOne ;
use mapache_commons Collection ;
include " ../vendor/autoload.php " ;
$ dao = new PdoOne ( " test " , " 127.0.0.1 " , " dummy " , " dummy " , " dummy " ); // we need any connection.
$ dao -> logLevel = 3 ;
$ dao -> render ();폴더 예제/testui.php에 예가 있습니다
다음 명령은 일반적으로 단독으로 실행됩니다 (일련의 방법이 아님)
| 방법 | 설명 | 예 |
|---|---|---|
| createTable () | Repo 내부의 정의를 사용하여 테이블과 색인을 만듭니다. | tablaparentrepo :: createTable (); |
| create foreignkeys () | 테이블의 모든 외국 키를 만듭니다 | tablaparentRepo :: create foreignkeys (); |
| 드롭 테이블 () | 테이블을 떨어 뜨립니다 | tablaparentrepo :: droptable (); |
| 자르기 () | 테이블을 잘라냅니다 | tablaparentRepo :: truncate (); |
| validtable () | 테이블이 변경되지 않았는지 확인하십시오 | $ ok = tablaparentRepo :: validTable (); |
TablaParentRepo:: createTable ();
TablaParentRepo:: createForeignKeys ();
TablaParentRepo:: dropTable ();
TablaParentRepo:: truncate ();
// We don't have a method to alter a table.
$ ok =TablaParentRepo:: validTable (); // it returns true if the table matches with the definition stored into the clas중첩 연산자는 우리의 방법 체인 사이에 있어야하는 방법입니다.
classrepo :: op () :: where () :: finalop ()는 ✅입니다
classrepo :: op () :: op () :: 여기서 ()는 체인을 열어 두는 곳입니다
예를 들어:
// select *
// from table
// inner join table2 on t1=t2
// where col=:arg
// and col2=:arg2
// group by col
// having col3=:arg3
// order by col
// limit 20,30
$ results = $ pdo -> select ( ' * ' )
-> from ( ' table ' )
-> innerjoin ( ' table2 on t1=t2 ' )
-> where ( ' col=:arg and col2:=arg2 ' ,[ 20 , 30 ])
// it also works with ->where('col=:arg',20)->where('col2'=>30)
// it also works with ->where('col=?',20)->where('col2=?'=>30)
-> group ( ' col ' )
-> having ( ' col3=:arg3 ' , 400 )
-> order ( ' col ' )
-> limit ( ' 20,30 ' )
-> toList (); // end of the chain| 방법 | 설명 | 예 |
|---|---|---|
| 어디() | 체인의 위치를 추가합니다 | tablaparentrepo :: 여기서 () |
| 주문하다() | 체인에 주문을 추가합니다 | tablaparentRepo :: order () |
| 그룹() | 체인에 그룹을 추가합니다 | tablaparentRepo :: group () |
| 한계() | 결과를 제한합니다 | tablaparentRepo :: limit () |
| 페이지() | 제한과 비슷하지만 페이지를 사용합니다 | tablaparentRepo :: page () |
| Innerjoin () | 쿼리에 내부 결합을 추가합니다 | tablaparentrepo :: Innerjoin () |
| 왼쪽() | 쿼리에 왼쪽 조인을 추가합니다 | tablaparentrepo :: left () |
| 오른쪽() | 쿼리에 올바른 조인을 추가합니다 | tablaparentRepo :: right () |
데이터베이스에서 DQL (query) 명령을 생성하는 다른 방법이 있습니다.
작업이 실패하면 거짓을 반환하고 예외를 유발할 수 있습니다.
다음 방법은 체인의 끝에 있어야합니다. 예 :
classrepo :: op () :: op () :: tolist ()는 ✅입니다
classrepo :: op () :: tolist () :: op ()는 예외를 트리거합니다
| 명령 | 설명 | 예 |
|---|---|---|
| tolist () | 요소 배열을 반환합니다 | $ data = tablenamerepo :: tolist (); // tableRepo에서 *를 선택하십시오 $ data = tableNamerepo :: 여기서 ( 'a1 =?', [$ value]) :: tolist (); // tableRepo에서 *를 선택하십시오. 여기서 a1 = $ 값 |
| 첫 번째() | 간단한 행을 반환합니다 | $ data = tableNamerepo :: first ($ pk); // tableRepo에서 * 선택 * pk = $ pk (항상 1 또는 0 값을 반환합니다) $ data = tableNamerepo :: 여기서 ( 'a1 =?', [$ value]) :: first (); // 첫 번째 값을 반환합니다 (또는 찾을 수없는 경우 false) |
| 존재하다() | 기본 키가 존재하는 경우 True를 반환합니다 | $ data = tableNamerepo :: endivers ($ pk); // 객체가 존재하면 true를 반환합니다. |
| 세다() | 쿼리의 행 수를 반환합니다 | $ data = tableNamerepo :: count ($ 조건); $ data = tableNamerepo :: 여기서 ( 'a1 =?', [$ value]) :: count (); |
다음 방법을 사용하면 데이터베이스에 값을 삽입, 업데이트 또는 삭제할 수 있습니다.
| 방법 | 설명 | 예 |
|---|---|---|
| 끼워 넣다 | 데이터베이스에 값을 삽입합니다. 정체성을 반환 할 수 있습니다 | $ Identity = tablaparentRepo :: insert ($ obj); |
| 업데이트 | 데이터베이스에 값을 업데이트합니다. | tablaparentRepo :: update ($ obj); |
| 삭제 | 데이터베이스에서 값을 삭제합니다. | tablaparentrepo :: delete ($ obj); |
| 삭제 | 데이터베이스에서 값 (기본 키를 조건으로 사용)을 삭제합니다. | tablaparentrepo :: deletebyid ($ pk); |
// where obj is an associative array or an object, where the keys are the name of the columns (case sensitive)
$ identity =TablaParentRepo:: insert ( $ obj );
TablaParentRepo:: update ( $ obj );
TablaParentRepo:: delete ( $ obj );
TablaParentRepo:: deleteById (id);모델을 검증 할 수 있습니다. 모델은 값의 유형, 길이, 값이 널 허용되는 경우 및 ID 인 경우 (자동 숫자)를 사용하여 데이터베이스의 정보를 사용하여 검증됩니다.
$ obj =[ ' IdUser ' => 1 , ' Name ' ='John Doe'];
UserRepo:: validateModel ( $ obj , false ,[ ' _messages ' ]); // returns true if $obj is a valid User.재귀 배열은 읽거나 얻거나 비교할 수있는 값을 가진 문자열 배열입니다. 예를 들어, 테이블에 조건부에 결합합니다. PDOONE은 직접 사용하지 않지만 _BASEPDOONEREPO를 사용합니다 (_BASEPDOONEROPO는 저장소 서비스 클래스를 자동으로 생성 할 때 사용되는 클래스입니다).
예
$ this -> select ( ' * ' )-> from ( ' table ' )-> recursive ([ ' table1 ' , ' table1.table2 ' ]);
// some operations that involves recursive
if ( $ this -> hasRecursive ( ' table1 ' )) {
$ this -> innerJoin ( ' table1 on table.c=table1.c ' );
}
if ( $ this -> hasRecursive ( ' table1.table2 ' )) {
$ this -> innerJoin ( ' table1 on table1.c=table2.c ' );
}
$ r = $ this -> toList (); // recursive is resetted. 재귀 배열을 설정합니다.
이 값은 체인 메소드가 끝날 때마다 재설정됩니다.
재귀 배열을 얻습니다.
Recursive에 약간의 바늘이 있으면 사실이 반환됩니다.
$ this-> recursive가 [ '*']라면 항상 사실을 반환합니다.
$ this -> select ( ' * ' )-> from ( ' table ' )-> recursive ([ ' * ' ]);
$ this -> hasRecursive ( ' anything ' ); // it always returns true. | 도서관 | 끼워 넣다 | findpk | 수산화 시키다 | ~와 함께 | 시간 |
|---|---|---|---|---|---|
| pdo | 671 | 60 | 278 | 887 | 3,74 |
| pdoone | 774 | 63 | 292 | 903 | 4,73 |
| Lessql | 1413 | 133 | 539 | 825 | 5,984 |
| 이임 | 2260 | 127 | 446 | 1516 | 8,415 |
| YiimwithCache | 1925 | 122 | 421 | 1547 | 7,854 |
| yii2m | 4344 | 208 | 632 | 1165 | 11,968 |
| yii2marrayhydrate | 4114 | 213 | 531 | 1073 | 11,22 |
| yii2mscalarhydrate | 4150 | 198 | 421 | 516 | 9,537 |
| Propel20 | 2507 | 123 | 1373 | 1960 | 11,781 |
| Propel20WithCache | 1519 | 68 | 1045 | 1454 | 8,228 |
| Propel20formatondemand | 1501 | 72 | 994 | 1423 | 8,228 |
| 교리 | 2119 | 250 | 1592 | 1258 | 18,139 |
| 교리위원회 | 2084 | 243 | 1634 | 1155 | 17,952 |
| Doctrinemarrayhydrate | 2137 | 240 | 1230 | 877 | 16,83 |
| 교리 신분화 | 2084 | 392 | 1542 | 939 | 18,887 |
| 문제가있는 교리 | 2119 | 252 | 1432 | 1960 | 19,822 |
| 웅변 | 3691 | 228 | 708 | 1413 | 12,155 |
PDOONE은 PDO보다 약간의 오브 헤드를 추가하지만 PDO에 래퍼는 간단합니다.
그것은 당신이 PDOONE을 업데이트하고 ORM에서 생성 한 하나의 클래스를 사용하고 있음을 의미합니다. 이 클래스는 재생성해야합니다.
간단히 말해서 :
모든 주요 버전은 이전 코드를 끊을 수 있음을 의미합니다. IE 1.0-> 2.0
모든 마이너 버전은 새로운 기능을 추가한다는 것을 의미합니다. 즉, 1.5-> 1.6 (새로운 방법)
모든 소수 버전은 이전 기능을 패치/수정/리팩토링한다는 것을 의미합니다. 즉, 1.5.0-> 1.5.1 (수정)
4.10 2024-09-06
4.9.2 2024-08-20
4.9.1 2024-08-20
4.9 2024-08-02
4.8 2024-07-06
4.7.1 2024-06-07
4.7 2024-06-07
4.6.2 2024-03-02
4.6.1 2024-03-02
4.6 2024-03-02
4.4 2023-12-12
4.3.3 2023-09-05
4.3.2 2023-09-05
4.3.1 2023-09-02
4.3 2023-07-01
4.2 2023-04-07
4.1.2 2023-03-21
4.1.1 2023-03-21
4.1 2023-03-20
4.0.1 2023-03-11
4.00 2023-11-03
3.16 2023-12-02
3.15 2023-02-03
3.14 2023-01-30
3.13 2023-01-26
3.12.2 2022-09-03
3.12.1 2022-08-26
3.12 2022-08-14
3.11.1 2022-07-30
3.11 2022-07-30
3.10 2022-07-30
3.9 2022-07-23
3.8.1 2022-07-23
3.8 2022-07-22
3.7 2022-07-16
3.6 2022-07-07
3.5 2022-07-06
3.3 2022-06-27
3.2 2022-06-27
3.1.6 2022-06-24
3.1.5 2022-06-23
3.1.4 2022-06-21
3.1.3 2022-06-18
3.1.2 2022-06-18
3.1.1 2022-06-17
3.1 2022-06-11
3.0 2022-06-1
2.32 2022-03-20
2.31 2022-03-04
2.30 2022-02-28
2.29 2022-02-20
2.27 2022-02-19
2.26 2022-02-19
2.25 2022-02-01
2.24.1 2022-02-06
2.24 2022-02-06
2.23 2022-02-04
2.22.2 2022-02-01
2.22.1 2022-01-03
2.22 2022-01-30
2.21 2022-01-28
However, it is far from perfect.
2.20 2022-01-04
2.19
2.18
2.16
2.15 2021-07-24
2.14.3 2021-06-15
2.14.2 2021-06-13
2.14.1 2021-06-09
2.14 2021-06-04
_BasePdoOneRepo now works more closely with the class PdoOneQuery , so each query is a different instance.
[fix] PdoOne dateConvertInput() does not crash when the value is not a date.
[fix] PdoOne throwError() does not stack errors but still triggers the last error (if any).
[changes] ❗ PdoOne aggregate functions (sum,min,max,avg) now returns a value instead of generating a query.
$result=$pdo->sum('xxx')->firstScalar(); // before $result=$pdo->sum('xxx'); // 지금
[fix] PdoOne generateCodeArray() used for the generation of classes, returns the correct name when it is set.
[changes] _BasePdoOneRepo : reset(),getQuery(),dropTable(),useCache(),limit(),newQuery(),order(),innerjoin(),left() ,right()
[changes] PdoOneQuery : Multiples changes.
2.13.1 2021-05-22
2.13 2021-04-17
2.12 2021-04-17
2.11.1 2021-04-17
2.11 2021-04-17
2.10.3 2021-04-14
2.10.2 2021-04-06
2.10.1 2021-04-05
2.10 2021-04-04
2.9.4 2021-03-22
2.9.3 2021-02-22
2.9.2 2021-02-18
2.9.1 2021-02-16
2.9 2021-02-16
2.8 2021-02-13
2.7.1 2021-01-21
2.7 2021-01-10
2.6.3 2020-10-16
2.6.2 2020-10-09
2.6.1 2020-09-24
2.6 2020-09-17
2.5 2020-09-13
2.4.1 2020-09-13
2.4 2020-09-06
2.3 2020-09-06
2.2.6 2020-09-03
2.2.5 2020-08-30
2.2.3 2020-08-23
2.2.2 2020-08-17
2.2.1 2020-08-16
2.2 2020-08-14
$ this -> setUseInternalCache ( true );
$ rows = $ this -> select ( ' * ' )-> from ( ' table ' )-> where ([ ' i ' => 1 ])-> toList (); // read from the database
// ...
$ rows2 = $ this -> select ( ' * ' )-> from ( ' table ' )-> where ([ ' i ' => 1 ])-> toList (); // read from memory
// ...
$ rows3 = $ this -> select ( ' * ' )-> from ( ' table ' )-> where ([ ' i ' => 2 ])-> toList (); // read from the database because the query is in
// memory but the parameters are different
echo $ this -> internalCacheCounter ; The internal cache is tested with runRawQuery (if returns an array), toList(), meta() and first()
2.0.1 2020-08-12
2.0 2020-08-11
1.55.1 2020-08-05
1.55 2020-8-05
1.54 2020-8-02
1.53 2020-7-27
1.52 2020-7-19
1.51 2020-7-18
1.50 2020-7-04
1.49 2020-6-19
1.48 2020-6-15
1.47 2020-6-14
1.46 2020-6-13
1.45.1 2020-6-11
1.45 2020-6-7
1.44.2 2020-6-3
1.44.1 2020-6-2
1.44 2020-5-31
1.43 2020-5-31
1.42 2020-5-29
1.41.2 2020-5-29
1.41.1 2020-5-28
1.41 2020-5-28
1.40.1 2020-5-27
1.40 2020-05-21
1.39 2020-05-12
1.38 2020-05-10
1.37 2020-05-03
1.36 2020-05-03
1.35.1 2020-04-30
1.35 2020-04-28
1.34.2 2020-04-27
1.34.1 2020-04-27
1.34 2020-04-27
1.33 2020-04-15
1.32.1 BasePdoOneRepo added version 2.0
1.32 2020-04-12
1.31.1 2020-04-11
1.31 2020-04-11
1.30 2020-04-10
1.29 2020-04-10
1.28.1 2020-04-06
1.28 2020-04-06
1.24 2020-03-26
1.23.1 2020-03-10
1.23 2020-03-10
1.22 2020-02-08
1.21 2020-02-07
1.20 2020-jan-25
1.19 2020-jan-15
1.16 2020-jan-14
1.15 2019-dec-29
1.14 2019-dec-26
1.13 2019-dec-26
1.12 2019-oct-20 Added argument (optional) ->toList($pdomodel) Added method ->toListSimple()
1.11 2019-oct-01 1.11 It is still compatible with php 5.6.Added to composer.json
1.10 2019-oct-01 1.10 Added method dateConvert(). Added trace to the throw.
1.9 2019-aug-10 1.8 republished
1.8 2019-aug-10 Added a date format. Methods dateSql2Text() and dateText2Sql()
1.7 2019-jun-23 Added some benchmark. It also solves a problem with the tags. Now: table.field=? is converted to table . field =?
1.6 2019-jun-22 affected_rows() returns a correct value.
1.5 2019-may-31 some cleanups. columnTable() returns if the column is nullable or not.
1.4 2019-may-30 insertobject()
1.3 2019-may-23 New changes
1.2 2019-may-22 New fixed.
1.1 2019-may-21 Some maintenance
1.0 2019-may-21 First version
