upscheme
1.0.0
애플리케이션의 데이터베이스 스키마를 업데이트하고 버전 간에 데이터를 마이그레이션하기 위해 PHP 패키지를 사용하기 쉽습니다.
composer req aimeos/upscheme목차
마이그레이션은 데이터베이스의 버전 제어와 같습니다. 이를 통해 모든 설치에서 정확히 동일한 상태를 얻을 수 있습니다. Upscheme을 사용하면 다음과 같은 이점을 얻을 수 있습니다.
다음은 테이블 레이아웃을 변경해야 할 때마다 조정할 수 있는 테이블 정의의 예입니다. 그런 다음 Upscheme은 기존 열과 테이블 속성을 자동으로 추가하고 수정합니다(단, 안전상의 이유로 아무것도 삭제하지 않음).
$ this -> db ()-> table ( ' test ' , function ( $ t ) {
$ t -> engine = ' InnoDB ' ;
$ t -> id ();
$ t -> string ( ' domain ' , 32 );
$ t -> string ( ' code ' , 64 )-> opt ( ' charset ' , ' binary ' , [ ' mariadb ' , ' mysql ' ] );
$ t -> string ( ' label ' , 255 );
$ t -> int ( ' pos ' )-> default ( 0 );
$ t -> smallint ( ' status ' );
$ t -> default ();
$ t -> unique ( [ ' domain ' , ' code ' ] );
$ t -> index ( [ ' status ' , ' pos ' ] );
} );관계형 데이터베이스 스키마를 업그레이드하기 위해 현재 Doctrine DBAL과 Doctrine 마이그레이션이라는 두 가지 패키지가 가장 자주 사용됩니다. Doctrine DBAL은 여러 데이터베이스 구현의 차이점을 추상화하는 데 효과적이지만 해당 API에는 많은 코드를 작성해야 합니다. 다른 사이트의 Doctrine 마이그레이션에는 타사 확장을 지원하는 모든 응용 프로그램에서 사용하기 어렵게 만드는 몇 가지 단점이 있습니다.
DBAL의 API는 매우 장황하며 간단한 작업에도 많은 코드를 작성해야 합니다. Upscheme은 Doctrine DBAL을 사용하여 최소한의 코드로 애플리케이션의 데이터베이스 스키마를 업그레이드하기 위한 사용하기 쉬운 API를 제공합니다. 위의 Upscheme 예에서 다음 코드 줄은 마이그레이션의 DBAL과 동일합니다.
$ dbalManager = $ conn -> createSchemaManager ();
$ from = $ manager -> createSchema ();
$ to = $ manager -> createSchema ();
if ( $ to -> hasTable ( ' test ' ) ) {
$ table = $ to -> getTable ( ' test ' );
} else {
$ table = $ to -> createTable ( ' test ' );
}
$ table -> addOption ( ' engine ' , ' InnoDB ' );
$ table -> addColumn ( ' id ' , ' integer ' , [ ' autoincrement ' => true ] );
$ table -> addColumn ( ' domain ' , ' string ' , [ ' length ' => 32 ] );
$ platform = $ conn -> getDatabasePlatform ();
if ( $ platform instanceof Doctrine DBAL Platform MySQLPlatform
|| $ platform instanceof Doctrine DBAL Platform MariaDBPlatform
) {
$ table -> addColumn ( ' code ' , ' string ' , [ ' length ' => 64 , ' customSchemaOptions ' => [ ' charset ' => ' binary ' ]] );
} else {
$ table -> addColumn ( ' code ' , ' string ' , [ ' length ' => 64 ]] );
}
$ table -> addColumn ( ' label ' , ' string ' , [ ' length ' => 255 ] );
$ table -> addColumn ( ' pos ' , ' integer ' , [ ' default ' => 0 ] );
$ table -> addColumn ( ' status ' , ' smallint ' , [] );
$ table -> addColumn ( ' mtime ' , ' datetime ' , [] );
$ table -> addColumn ( ' ctime ' , ' datetime ' , [] );
$ table -> addColumn ( ' editor ' , ' string ' , [ ' length ' => 255 ] );
$ table -> setPrimaryKey ( [ ' id ' ] );
$ table -> addUniqueIndex ( [ ' domain ' , ' code ' ] );
$ table -> addIndex ( [ ' status ' , ' pos ' ] );
foreach ( $ from -> getMigrateToSql ( $ to , $ conn -> getDatabasePlatform () ) as $ sql ) {
$ conn -> executeStatement ( $ sql );
}Doctrine Migration은 특정 순서를 보장하기 위해 생성된 시간에 따라 이름이 지정된 마이그레이션 클래스에 의존합니다. 또한 데이터베이스 테이블에 어떤 마이그레이션이 실행되었는지 저장합니다. 그로부터 발생하는 세 가지 주요 문제는 다음과 같습니다.
down() 사용 시 데이터 손실 애플리케이션이 타사 확장을 지원하는 경우 이러한 확장은 기존 테이블에 열을 추가하고 데이터 자체를 마이그레이션할 가능성이 높습니다. 마이그레이션 간의 종속성을 정의할 방법이 없기 때문에 여러 타사 확장 기능이 있는 애플리케이션에서 충돌 없이 마이그레이션을 실행하는 것이 거의 불가능할 수 있습니다. 이를 방지하기 위해 Upscheme은 작업이 다른 작업에 대한 종속성을 정의할 수 있는 각 마이그레이션 작업에서 사용하기 쉬운 before() 및 after() 메서드를 제공합니다.
Doctrine 마이그레이션은 데이터베이스 테이블을 사용하여 이미 실행된 마이그레이션을 기록하므로 문제가 발생할 경우 이러한 레코드가 쉽게 동기화되지 않을 수 있습니다. 반대로 Upscheme은 실제 스키마에만 의존하므로 이전에 발생한 상황에 관계없이 모든 상태에서 업그레이드가 가능합니다.
Doctrine 마이그레이션은 down() 메서드의 역방향 작업도 지원하므로 Upscheme이 지원하지 않는 마이그레이션을 롤백할 수 있습니다. 경험에 따르면 새 열을 추가한 후, 기존 열의 데이터를 마이그레이션하고 나중에 이전 열을 삭제한 후 마이그레이션을 롤백하는 것이 불가능한 경우가 많습니다. 데이터 마이그레이션이 손실된 경우 down() 메서드에서 동일한 상태를 다시 만들 수 없습니다. 테이블을 떨어뜨린 경우에도 마찬가지입니다. 따라서 Upscheme은 암시적 데이터 손실을 방지하기 위해 체계 업그레이드만 제공하고 다운그레이드는 제공하지 않습니다.
Upscheme은 다양한 데이터베이스 서버 구현을 추상화하기 위해 Doctrine DBAL을 사용합니다. DBAL은 모든 주요 관계형 데이터베이스 관리 시스템(RDBMS)을 지원하지만 사용 가능한 기능에 대한 지원 수준은 다릅니다.
좋은 지원:
제한된 지원:
Composer를 사용하여 aimeos/upscheme 패키지를 설치한 후 Up 클래스를 사용하여 마이그레이션 작업을 실행할 수 있습니다.
$ config = [
' driver ' => ' pdo_mysql ' ,
' host ' => ' 127.0.0.1 ' ,
' dbname ' => ' <database> ' ,
' user ' => ' <dbuser> ' ,
' password ' => ' <secret> '
];
Aimeos Upscheme Up:: use ( $ config , ' src/migrations ' )-> up (); Up::use() 메서드에는 데이터베이스 구성과 마이그레이션 작업 경로라는 두 가지 매개 변수가 필요합니다. 구성의 경우 드라이버 의 배열 키와 값은 Doctrine DBAL에서 지원되어야 합니다. 사용 가능한 드라이버는 다음과 같습니다.
일부 데이터베이스에는 다양한 매개변수가 필요하며, 가장 주목할만한 SQLite 및 Oracle은 다음과 같습니다.
SQLite:
$ config = [
' driver ' => ' pdo_sqlite ' ,
' path ' => ' path/to/file.sq3 '
];신탁:
$ config = [
' driver ' => ' pdo_oci ' ,
' host ' => ' <host or IP> ' ,
' dbname ' => ' <SID or service name (Oracle 18+)> ' ,
' service ' => true , // for Oracle 18 + only
' user ' => ' <dbuser> ' ,
' password ' => ' <secret> '
];이전에 Doctrine DBAL을 사용하지 않은 경우 데이터베이스 구성이 다른 구조를 가지거나 데이터베이스 유형에 대해 다른 값을 사용할 수 있습니다. Upscheme을 사용하면 구성을 유효한 DBAL 설정으로 변환하는 사용자 정의 방법을 등록할 수 있습니다. 예:
Aimeos Upscheme Up:: macro ( ' connect ' , function ( array $ cfg ) {
return Doctrine DBAL DriverManager:: getConnection ( [
' driver ' => $ cfg [ ' adapter ' ],
' host ' => $ cfg [ ' host ' ],
' dbname ' => $ cfg [ ' database ' ],
' user ' => $ cfg [ ' username ' ],
' password ' => $ cfg [ ' password ' ]
] );
} );Upscheme은 또한 키 이름으로 구별할 수 있는 여러 데이터베이스 연결을 지원합니다.
$ config = [
' db ' => [
' driver ' => ' pdo_mysql ' ,
' host ' => ' 127.0.0.1 ' ,
' dbname ' => ' <database> ' ,
' user ' => ' <dbuser> ' ,
' password ' => ' <secret> '
],
' temp ' => [
' driver ' => ' pdo_sqlite ' ,
' path ' => ' /tmp/mydb.sqlite '
]
];
Aimeos Upscheme Up:: use ( $ config , ' src/migrations ' )-> up (); 물론 Up 클래스에 여러 마이그레이션 경로를 전달할 수도 있습니다.
Aimeos Upscheme Up:: use ( $ config , [ ' src/migrations ' , ' ext/migrations ' ] )-> up ();출력을 활성화(디버깅)하려면 verbose() 메서드를 사용하십시오.
Aimeos Upscheme Up:: use ( $ config , ' src/migrations ' )-> verbose ()-> up (); // most important only
Aimeos Upscheme Up:: use ( $ config , ' src/migrations ' )-> verbose ( ' vv ' )-> up (); // more verbose
Aimeos Upscheme Up:: use ( $ config , ' src/migrations ' )-> verbose ( ' vvv ' )-> up (); // debugging 마이그레이션 작업은 up() 메서드 구현만 필요하며 Up 클래스에 전달된 디렉터리 중 하나에 저장되어야 합니다.
<?php
namespace Aimeos Upscheme Task ;
use Aimeos Upscheme Schema Table ;
return new class ( $ this ) extends Base {
public function up ()
{
$ this -> db ()-> table ( ' test ' , function ( Table $ t ) {
$ t -> id ();
$ t -> string ( ' label ' );
$ t -> bool ( ' status ' );
} );
}
}; PHP 파일에서는 항상 namespace 스페이스 문을 먼저 포함하십시오. use 문은 선택 사항이며 클로저 함수 인수에 대한 유형 힌트에 대한 바로 가기로만 필요합니다. 또한 클래스는 "기본" 작업 클래스에서 확장하거나 "Iface" 작업 인터페이스를 구현해야 합니다.
익명 클래스 대신 명명된 클래스를 마이그레이션 작업에 사용할 수 있습니다.
<?php
namespace Aimeos Upscheme Task ;
use Aimeos Upscheme Schema Table ;
class TestTable extends Base
{
public function up ()
{
$ this -> db ()-> table ( ' test ' , function ( Table $ t ) {
$ t -> id ();
$ t -> string ( ' label ' );
$ t -> bool ( ' status ' );
} );
}
} 클래스가 저장된 파일은 클래스 자체와 동일한 이름(대소문자 구분) 및 .php 접미사를 가져야 합니다. 예:
class TestTable -> TestTable.php
마이그레이션 작업 파일의 이름을 지정하는 방법에 대한 엄격한 규칙은 없습니다. 수행하는 작업(예: "CreateTestTable.php"), 작업 대상(예: "TestTable.php") 또는 타임스탬프(예: "20201231_Test.php")를 사용하여 이름을 지정할 수 있습니다.
작업에 종속성이 포함되어 있지 않으면 파일 이름에 따라 알파벳순으로 정렬 및 실행되며 정렬 방법은 다음과 같습니다.
20201231_Test.php
CreateTestTable.php
TestTable.php
다른 마이그레이션 작업에 대한 종속성을 지정하려면 after() 및 before() 메서드를 사용합니다. 작업은 after() 에서 반환된 작업 이후 및 before() 에서 반환된 작업 이전에 실행됩니다.
return new class ( $ this ) extends Base {
public function after () : array
{
return [ ' CreateRefTable ' ];
}
public function before () : array
{
return [ ' InsertTestData ' ];
}
} 작업 이름은 .php 접미사가 없는 작업의 파일 이름입니다. 예제 마이그레이션이 TestTable.php 파일에 저장되어 있는 경우 실행 순서는 다음과 같습니다.
CreateRefTable.php -> TestTable.php -> InsertTestData.php
마이그레이션 작업에서 메시지를 출력하려면 info() 메서드를 사용하세요.
$ this -> info ( ' some message ' );
$ this -> info ( ' more verbose message ' , ' vv ' );
$ this -> info ( ' very verbose debug message ' , ' vvv ' ); 두 번째 매개변수는 자세한 정보 표시 수준이며 없음 또는 v 표준 메시지입니다. vv 더 많은 정보 표시가 필요한 경우에만 표시되는 메시지이고 vvv 메시지 디버깅을 위한 것입니다. 메시지를 들여쓰기 위한 세 번째 매개변수도 있습니다:
$ this -> info ( ' some message ' );
$ this -> info ( ' second level message ' , ' v ' , 1 );
$ this -> info ( ' third level message ' , ' v ' , 2 );다음이 표시됩니다.
some message
second level message
third level message
전제 조건은 Up 클래스의 verbose() 메서드가 이전에 호출되었다는 것입니다.
Aimeos Upscheme Up:: use ( $ config , ' ... ' )-> verbose ()-> up (); up() 메서드에서는 db() 메서드를 사용하여 데이터베이스 스키마에 액세스할 수 있습니다. Up::use() 에 둘 이상의 데이터베이스 구성을 전달한 경우 해당 구성 키를 사용하여 다양한 스키마에 액세스할 수 있습니다.
// $config = [ 'db' => [ ... ] , 'temp' => [ ... ] ] ;
// Aimeos UpschemeUp::use( $config , '...' )->up() ;
$ this -> db ();
$ this -> db ( ' db ' );
$ this -> db ( ' temp ' ); 구성 키를 전달하지 않거나 존재하지 않는 키를 전달하는 경우 첫 번째 구성이 반환됩니다(이 경우 "db"). 데이터베이스 스키마 개체의 사용 가능한 방법을 사용하면 테이블, 열, 인덱스 및 기타 데이터베이스 개체를 추가, 업데이트 또는 삭제할 수 있습니다. 또한 insert() , select() , update() , delete() 및 stmt() 사용하여 테이블의 레코드를 조작할 수 있습니다.
각 마이그레이션 작업 후에 작업에서 수행된 스키마 업데이트가 자동으로 데이터베이스에 적용됩니다. 데이터를 삽입하기 때문에 즉시 변경 사항을 유지해야 하는 경우 $this->db()->up() 직접 호출하세요. up() 메서드는 모든 테이블, 시퀀스 및 열 개체에서 사용할 수 있으므로 어디에서나 up() 호출할 수 있습니다.
SELECT 및 INSERT/UPDATE/DELETE 문을 동시에 실행하기 위해 두 개의 서로 다른 데이터베이스 연결이 필요한 경우 TRUE를 db() 의 두 번째 매개 변수로 전달하여 새 연결을 포함하는 데이터베이스 스키마를 가져옵니다.
$ db1 = $ this -> db ();
$ db2 = $ this -> db ( ' db ' , true );
foreach ( $ db1 -> select ( ' users ' , [ ' status ' => false ] ) as $ row ) {
$ db2 -> insert ( ' oldusers ' , $ row );
}
$ db2 -> delete ( ' users ' , [ ' status ' => false ] ); 모든 스키마 변경 사항은 새 연결이 포함된 스키마가 반환되기 전에 데이터베이스에 적용됩니다. 데이터베이스 서버가 새 연결을 거부할 때까지 데이터베이스 연결이 쌓이는 것을 방지하려면 항상 db( '<name>', true ) 에 의해 생성된 새 연결에 대해 close() 호출하세요.
$ db2 -> close ();데이터베이스 개체에 대한 마이그레이션을 직접 작성하는 대신 다음을 사용하여 자동으로 마이그레이션 파일을 생성할 수 있습니다.
$ config = [
' db ' => [
' driver ' => ' pdo_mysql ' ,
' host ' => ' 127.0.0.1 ' ,
' dbname ' => ' <database> ' ,
' user ' => ' <dbuser> ' ,
' password ' => ' <secret> '
]
];
Aimeos Upscheme Up:: use ( $ config , ' migrations ' )-> create (); 그러면 전달된 디렉터리(이 예에서는 ./migrations/ )의 각 시퀀스, 테이블 및 보기에 대해 하나의 파일이 생성됩니다. 여러 개의 데이터베이스가 있고 모든 데이터베이스에 대한 마이그레이션을 한 번에 생성하려면 구성의 연결 키를 create() 에 전달하세요.
$ config = [
' db ' => [
' driver ' => ' pdo_mysql ' ,
// ...
],
' order ' => [
' driver ' => ' pdo_oci ' ,
// ...
]
];
Aimeos Upscheme Up:: use ( $ config , ' migrations ' )-> create ( [ ' db ' , ' order ' ] ); 스키마 섹션에 설명된 대로 $this->db() 호출하여 작업에서 데이터베이스 스키마 개체를 가져옵니다. 모든 테이블, 시퀀스 및 기타 스키마 개체를 포함하여 데이터베이스 스키마에 대한 전체 액세스 권한을 제공합니다.
$ table = $ this -> db ()-> table ( ' users ' );
$ seq = $ this -> db ()-> sequence ( ' seq_users ' );테이블이나 시퀀스가 존재하지 않으면 생성됩니다. 그렇지 않으면 기존 테이블 또는 시퀀스 개체가 반환됩니다. 두 경우 모두 나중에 개체를 수정하고 테이블에 새 열 등을 추가할 수 있습니다.
$this->db() 에서 반환된 데이터베이스 스키마를 사용하여 테이블, 열, 인덱스, 외래 키 및 시퀀스를 테스트할 수 있습니다.
$ db = $ this -> db ();
if ( $ db -> hasTable ( ' users ' ) ) {
// The "users" table exists
}
if ( $ db -> hasColumn ( ' users ' , ' name ' ) ) {
// The "name" column in the "users" table exists
}
if ( $ db -> hasIndex ( ' users ' , ' idx_name ' ) ) {
// The "idx_name" index in the "users" table exists
}
if ( $ db -> hasForeign ( ' users_address ' , ' fk_users_id ' ) ) {
// The foreign key "fk_users_id" in the " users_address " table exists
}
if ( $ db -> hasSequence ( ' seq_users ' ) ) {
// The "seq_users" sequence exists
}
if ( $ db -> hasView ( ' testview ' ) ) {
// The "testview" view exists
} $this->db() 에 의해 반환된 데이터베이스 객체는 renameTable() , renameColumn() 및 renameIndex() 사용하여 테이블, 열 및 인덱스의 이름을 바꿀 수 있는 가능성을 제공합니다.
$ db = $ this -> db ();
// Renames the table "users" to "accounts"
$ db -> renameTable ( ' users ' , ' account ' );
// Renames the column "label" to "name" in the "users" table
$ db -> renameColumn ( ' users ' , ' label ' , ' name ' );
// Renames the column "idx_label" to "idx_name" in the "users" table
$ db -> renameIndex ( ' users ' , ' idx_label ' , ' idx_name ' ); $this->db() 에 의해 반환된 데이터베이스 개체에는 테이블, 열, 인덱스, 외래 키 및 시퀀스를 삭제하는 메서드도 있습니다.
$ db = $ this -> db ();
// Drops the foreign key " fk_users_id " from the " users_address " table
$ db -> dropForeign ( ' users_address ' , ' fk_users_id ' );
// Drops the " idx_name " index from the " users " table
$ db -> dropIndex ( ' users ' , ' idx_name ' );
// Drops the " name " column from the " users " table
$ db -> dropColumn ( ' users ' , ' name ' );
// Drops the "seq_users" sequence
$ db -> dropSequence ( ' seq_users ' );
// Drops the "users" table
$ db -> dropTable ( ' users ' );
// Drops the "testview" view
$ db -> dropView ( ' testview ' ); 테이블, 열, 인덱스, 외래 키 또는 시퀀스가 존재하지 않으면 자동으로 무시됩니다. 존재 여부를 알아야 하는 경우 "존재 확인" 섹션에 설명된 대로 먼저 hasTable() , hasColumn() , hasIndex() , hasForeign() 및 hasSeqence() 메서드를 사용하세요.
insert() , select() , update() 및 delete() 메서드를 사용하면 테이블의 행을 쉽게 추가, 검색, 수정 및 제거할 수 있습니다.
$ this -> db ()-> transaction ( function ( $ db ) {
$ db2 = $ this -> db ( ' db ' , true );
foreach ( $ db2 -> select ( ' users ' , [ ' status ' => false ] ) as $ row )
{
$ db -> insert ( ' newusers ' , [ ' userid ' => $ row [ ' id ' ], ' status ' => true ] );
$ db -> update ( ' users ' , [ ' refid ' => $ db -> lastId ()], [ ' id ' => $ row [ ' id ' ]] );
}
$ db -> delete ( ' newusers ' , [ ' status ' => false ] );
$ db2 -> close ();
} ); insert() , update() 또는 delete() 와 동시에 select() 사용하는 경우 데이터베이스 서버에 새 명령을 보내는 동안 select() 문이 행을 반환하므로 두 번째 데이터베이스 연결을 생성해야 합니다. 이는 동일한 연결이 아닌 별도의 연결에서만 작동합니다.
모든 삭제/삽입/업데이트 작업을 트랜잭션으로 래핑하려면 데이터베이스 개체의 transaction() 메서드를 사용해야 합니다.
$ this -> db ()-> transaction ( function ( $ db ) {
// $db- > insert ( ... )
// $db- > update ( ... )
// $db- > delete ( ... )
} ); 이렇게 하면 모든 쓰기 작업이 원자적으로 수행되거나 오류가 발생한 경우 전혀 수행되지 않습니다. transaction() 메서드는 익명 함수가 메서드에 제어권을 반환한 후 트랜잭션이 자동으로 커밋되거나 롤백되도록 합니다.
익명 함수 내에 추가 매개변수가 필요한 경우 함수 use 목록에서 해당 매개변수를 전달할 수 있습니다.
$ userid = 123 ;
$ this -> db ()-> transaction ( function ( $ db ) use ( $ userid ) {
$ db -> insert ( ' newusers ' , [ ' userid ' => userid, ' status ' => true ] );
} ); 조건에 대한 간단한 키/값 쌍만 AND로 결합된 메서드에 전달할 수 있습니다. 더 복잡한 쿼리가 필요한 경우 stmt() 대신 사용하세요.
$ db = $ this -> db ();
$ result = $ db -> stmt ()-> select ( ' id ' , ' name ' )
-> from ( ' users ' )
-> where ( ' status != ? ' )
-> setParameter ( 0 , false )
-> executeQuery ();
$ db -> stmt ()-> delete ( ' users ' )
-> where ( ' status != ? ' )
-> setParameter ( 0 , false )
-> executeStatement ();
$ db -> stmt ()-> update ( ' users ' )
-> set ( ' status ' , ' ? ' )
-> where ( ' status != ? ' )
-> setParameters ( [ true , false ] )
-> executeStatement (); stmt() 메서드는 더 고급 문을 작성할 수 있는 DoctrineDBALQueryQueryBuilder 개체를 반환합니다. 자세한 내용은 Doctrine Query Builder 문서를 살펴보시기 바랍니다.
SQL 문에서 직접 값을 사용하려면(가능한 경우 보안상의 이유로 준비된 문을 사용하십시오!) q() 메서드를 사용하여 값을 인용해야 합니다.
$ db = $ this -> db ();
$ result = $ db -> stmt ()-> select ( ' * ' )-> from ( ' products ' )
-> where ( ' status = ' . $ db -> q ( $ _GET [ ' status ' ] ) )-> executeQuery (); 마찬가지로, 스키마에 예약된 키워드(예: 열 이름)가 포함된 경우 qi() 메서드를 사용하여 해당 키워드도 인용해야 합니다.
$ db = $ this -> db ();
$ result = $ db -> stmt ()-> select ( $ db -> qi ( ' key ' ) )-> from ( ' products ' )-> executeQuery (); Doctrine은 SQL 문의 공통 하위 집합만 지원하며 데이터베이스 공급업체가 구현한 모든 가능성을 지원하지는 않습니다. 이러한 제한을 제거하기 위해 Upscheme은 Doctrine DBAL에서 지원하지 않는 사용자 정의 SQL 문을 실행하기 위한 exec() , for() 및 query() 메서드를 제공합니다.
사용자 정의 SQL 쿼리를 실행하려면 반복할 수 있는 결과 집합을 반환하는 query() 메서드를 사용하세요.
$ sql = ' SELECT id, label, status FROM product WHERE label LIKE ? ' ;
$ result = $ this -> db ()-> query ( $ sql , [ ' test% ' ] );
foreach ( $ result -> iterateAssociative () as $ row ) {
// ...
} 다른 모든 SQL 문의 경우 영향을 받은 행 수를 반환하는 exec() 메서드를 사용하세요.
$ sql = ' UPDATE product SET status=? WHERE status=? ' ;
$ num = $ this -> db ()-> exec ( $ sql , [ 1 , 0 ] ); for() 메소드를 사용하면 데이터베이스 플랫폼에 따라 명령문을 실행할 수도 있습니다.
$ this -> db ()-> for ( ' mysql ' , ' CREATE FULLTEXT INDEX idx_text ON product (text) ' );데이터베이스 플랫폼을 지정하는 것은 데이터베이스 구현마다 구문이 다른 특별한 유형의 인덱스를 생성하는 데 매우 유용합니다.
사용자 정의 메소드를 호출하거나 Doctrine 스키마 객체에 알 수 없는 메소드 호출을 전달합니다.
public function __call( string $ method , array $ args )$method 메소드 이름$args 메서드 매개변수예:
Upscheme DB 객체의 클래스 속성에 액세스할 수 있는 사용자 정의 메서드를 등록할 수 있습니다.
Aimeos Upscheme Schema DB :: macro ( ' hasFkIndexes ' , function ( $ val ) {
return $ this -> to -> hasExplicitForeignKeyIndexes ();
} );
$ db -> hasFkIndexes ();
// returns true / false사용 가능한 클래스 속성은 다음과 같습니다.
$this->from : 현재 데이터베이스를 나타내는 원본 Doctrine 데이터베이스 스키마
$this->to : 지금까지 변경된 내용을 포함하는 Doctrine 데이터베이스 스키마
$this->conn : 교리 데이터베이스 연결
$this->up : Upscheme 개체
또한 다음과 같이 Doctrine 스키마 메서드를 직접 호출할 수 있습니다.
$ db -> hasExplicitForeignKeyIndexes ();데이터베이스 연결을 닫습니다.
public function close() : void $this->db( '...', true ) 로 생성된 DB 스키마 객체에 대해서만 close() 호출하세요. 그렇지 않으면 기본 연결이 닫히고 DBAL이 서버에 다시 연결해야 하므로 성능이 저하됩니다!
예:
$ db = $ this -> db ( ' temp ' , true );
$ db -> dropTable ( ' test ' );
$ db -> close ();주어진 테이블에서 레코드를 삭제합니다.
public function delete( string $ table , array $ conditions = [] ) : self$table 테이블 이름$conditions 비교할 열 이름과 값의 키/값 쌍경고: 조건 값은 이스케이프되지만 테이블 이름과 조건 열 이름은 이스케이프되지 않습니다. 테이블 이름과 조건 열 이름에는 고정 문자열만 사용하고 외부 입력은 사용하지 마세요!
예:
$ db -> delete ( ' test ' , [ ' status ' => false , ' type ' => ' old ' ] );
$ db -> delete ( ' test ' ); 두 번째 매개변수에 전달된 여러 조건은 "AND"로 결합됩니다. 더 복잡한 명령문이 필요한 경우 stmt() 메서드를 대신 사용하세요.
존재하는 경우 해당 이름으로 지정된 열을 삭제합니다.
public function dropColumn( string $ table , $ name ) : self$table 해당 열이 속한 테이블 이름$name 열 이름예:
$ db -> dropColumn ( ' test ' , ' oldcol ' );
$ db -> dropColumn ( ' test ' , [ ' oldcol ' , ' oldcol2 ' ] );해당 열 또는 열 중 하나가 존재하지 않으면 자동으로 무시됩니다.
존재하는 경우 이름으로 제공된 외래 키 제약 조건을 삭제합니다.
public function dropForeign( string $ table , $ name ) : self$table 외래 키 제약 조건이 속한 테이블 이름$name 외래 키 제약 조건의 이름예:
$ db -> dropForeign ( ' test ' , ' fk_old ' );
$ db -> dropForeign ( ' test ' , [ ' fk_old ' , ' fk_old2 ' ] );외래 키 제약 조건이나 제약 조건 중 하나가 존재하지 않으면 자동으로 무시됩니다.
존재하는 경우 해당 이름으로 지정된 인덱스를 삭제합니다.
public function dropIndex( string $ table , $ name ) : self$table 인덱스가 속한 테이블 이름$name 인덱스 이름예:
$ db -> dropIndex ( ' test ' , ' idx_old ' );
$ db -> dropIndex ( ' test ' , [ ' idx_old ' , ' idx_old2 ' ] );인덱스 또는 인덱스 중 하나가 존재하지 않으면 자동으로 무시됩니다.
존재하는 경우 이름으로 지정된 시퀀스를 삭제합니다.
public function dropSequence( $ name ) : self$name 시퀀스 이름예:
$ db -> dropSequence ( ' seq_old ' );
$ db -> dropSequence ( [ ' seq_old ' , ' seq_old2 ' ] );해당 시퀀스나 시퀀스 중 하나가 존재하지 않으면 자동으로 무시됩니다.
테이블이 존재하는 경우 이름으로 지정된 테이블을 삭제합니다.
public function dropTable( $ name ) : self$name 테이블 이름예:
$ db -> dropTable ( ' test ' );
$ db -> dropTable ( [ ' test ' , ' test2 ' ] );테이블이나 테이블 중 하나가 존재하지 않으면 자동으로 무시됩니다.
존재하는 경우 이름으로 지정된 뷰를 삭제합니다.
public function dropView( $ name ) : self$name 뷰 이름예:
$ db -> dropView ( ' test ' );
$ db -> dropView ( [ ' test ' , ' test2 ' ] );해당 뷰 또는 뷰 중 하나가 존재하지 않으면 자동으로 무시됩니다.
사용자 정의 SQL 문을 실행합니다.
public function exec( string $ sql , array $ params = [], array $ types = [] ) : int$sql 사용자 정의 SQL 문$params 위치 매개변수 목록 또는 자리 표시자와 매개변수의 연관 목록$types 위치 또는 연관 자리 표시자 매개변수에 대한 DBAL 데이터 유형 목록데이터베이스 변경 사항은 즉시 적용되지 않으므로 사용자 정의 명령문을 실행하기 전에 항상 up()을 호출하여 사용하려는 테이블이 이전에 생성되었는지 확인하세요!
예:
$ sql = ' UPDATE product SET status=? WHERE status=? ' ;
$ num = $ this -> db ()-> exec ( $ sql , [ 1 , 0 ] );데이터베이스가 지정된 유형인 경우 사용자 정의 SQL 문을 실행합니다.
public function for( $ type , $ sql ) : self$type 명령문이 실행되어야 하는 데이터베이스 유형$sql 사용자 정의 SQL 문 또는 문사용 가능한 데이터베이스 플랫폼 유형은 다음과 같습니다.
데이터베이스 변경 사항은 즉시 적용되지 않으므로 사용자 정의 명령문을 실행하기 전에 항상 up() 호출하여 사용하려는 테이블이 이전에 생성되었는지 확인하세요!
예:
$ db -> for ( ' mysql ' , ' CREATE INDEX idx_test_label ON test (label(16)) ' );
$ db -> for ( [ ' mysql ' , ' sqlite ' ], [
' DROP INDEX unq_test_status ' ,
' UPDATE test SET status = 0 WHERE status IS NULL ' ,
] );열이 존재하는지 확인합니다.
public function hasColumn( string $ table , $ name ) : bool$table 해당 열이 속한 테이블 이름$name 열 이름예:
$ db -> hasColumn ( ' test ' , ' testcol ' );
$ db -> hasColumn ( ' test ' , [ ' testcol ' , ' testcol2 ' ] );외래 키 제약 조건이 있는지 확인합니다.
public function hasForeign( string $ table , $ name ) : bool$table 외래 키 제약 조건이 속한 테이블 이름$name 외래 키 제약 조건의 이름예:
$ db -> hasForeign ( ' test ' , ' fk_testcol ' );
$ db -> hasForeign ( ' test ' , [ ' fk_testcol ' , ' fk_testcol2 ' ] );인덱스가 존재하는지 확인
public function hasIndex( string $ table , $ name ) : bool$table 인덱스가 속한 테이블 이름$name 인덱스 이름예:
$ db -> hasIndex ( ' test ' , ' idx_test_col ' );
$ db -> hasIndex ( ' test ' , [ ' idx_test_col ' , ' idx_test_col2 ' ] );시퀀스가 존재하는지 확인합니다.
public function hasSequence( $ name ) : bool$name 시퀀스 이름예:
$ db -> hasSequence ( ' seq_test ' );
$ db -> hasSequence ( [ ' seq_test ' , ' seq_test2 ' ] );테이블이 존재하는지 확인
public function hasTable( $ name ) : bool$name 테이블 이름예:
$ db -> hasTable ( ' test ' );
$ db -> hasTable ( [ ' test ' , ' test2 ' ] );뷰가 존재하는지 확인합니다.
public function hasView( $ name ) : bool$name 뷰 이름예:
$ db -> hasView ( ' test ' );
$ db -> hasView ( [ ' test ' , ' test2 ' ] );주어진 테이블에 레코드를 삽입합니다.
public function insert( string $ table , array $ data ) : self$table 테이블 이름$data 삽입할 열 이름/값의 키/값 쌍예:
$ db -> insert ( ' test ' , [ ' label ' => ' myvalue ' , ' status ' => true ] );데이터베이스 테이블에 마지막으로 삽입된 행의 ID를 반환합니다.
public function lastId() : string주의: Doctrine DBAL은 현재 Oracle IDENTITY 열을 지원하지 않기 때문에 Oracle 플랫폼에서는 작동하지 않습니다.
예:
$ db -> lastId ();데이터베이스의 이름을 반환합니다.
public function name() : string예:
$ db -> name ();값을 인용합니다
public function q( $ value , $ type = Doctrine DBAL ParameterType:: STRING ) : string$value 준비되지 않은 SQL 쿼리에 사용할 값$type DBAL 매개변수 유형예:
$ result = $ db -> stmt ()-> select ( ' * ' )-> from ( ' products ' )
-> where ( ' status = ' . $ db -> q ( $ _GET [ ' status ' ] ) )-> executeQuery ();데이터베이스 식별자를 인용합니다.
public function qi( string $ identifier ) : string$identifier 테이블 또는 열 이름과 같은 식별자예:
$ result = $ db -> stmt ()-> select ( $ db -> qi ( ' key ' ) )-> from ( ' products ' )-> executeQuery ();사용자 정의 SQL 쿼리를 실행합니다.
public function query( string $ sql , array $ params = [], array $ types = [] ) : Doctrine DBAL Result$sql 사용자 정의 SQL 문$params 위치 매개변수 목록 또는 자리 표시자와 매개변수의 연관 목록$types 위치 또는 연관 자리 표시자 매개변수에 대한 DBAL 데이터 유형 목록예:
$ result = $ db -> query ( ' SELECT id, label, status FROM product WHERE label LIKE ? ' , [ ' test% ' ] );
foreach ( $ result -> iterateAssociative () as $ row ) {
// ...
}팁: 자세한 내용은 데이터 검색을 위한 DBAL 메소드를 확인하세요.
열 또는 열 목록의 이름을 바꿉니다.
public function renameColumn( string $ table , $ from , string $ to = null ) : self$table 테이블 이름$from 열 이름 또는 이전/새 열 이름 배열$to 첫 번째 매개변수가 배열인 경우 새 열 이름이 무시됩니다. 열이 아직 존재하지 않으면 메서드는 성공하지만 아무 일도 일어나지 않습니다. up() 을 호출할 필요가 없습니다.
제한 사항
예:
// single column
$ db -> renameColumn ( ' testtable ' , ' test_col ' , ' test_column ' );
// rename several columns at once
$ db -> renameColumn ( ' testtable ' , [ ' tcol ' => ' testcol ' , ' tcol2 ' => ' testcol2 ' ] );열 또는 열 목록의 이름을 바꿉니다.
public function renameIndex( string $ table , $ from , string $ to = null ) : self$table 테이블 이름$from 인덱스 이름 또는 이전/새 인덱스 이름 배열$to 첫 번째 매개변수가 배열인 경우 새 인덱스 이름이 무시됩니다. 인덱스가 아직 존재하지 않으면 메서드는 성공하지만 아무 일도 일어나지 않습니다. up() 을 호출할 필요가 없습니다.
예:
// single index
$ db -> renameIndex ( ' testtable ' , ' idxcol ' , ' idx_column ' );
// rename several indexes at once
$ db -> renameIndex ( ' testtable ' , [ ' idxcol ' => ' idx_column ' , ' idxcol2 ' => ' idx_column2 ' ] );테이블 또는 테이블 목록의 이름을 바꿉니다.
public function renameTable( $ from , string $ to = null ) : self$from 테이블 이름 또는 이전/새 테이블 이름의 배열$to 첫 번째 매개변수가 배열인 경우 새 테이블 이름이 무시됩니다. 테이블이 아직 존재하지 않으면 메서드는 성공하지만 아무 일도 일어나지 않습니다. up() 을 호출할 필요가 없습니다.
예:
// single table
$ db -> renameTable ( ' testtable ' , ' newtable ' );
// rename several tables at once
$ db -> renameTable ( [ ' testtable ' => ' newtable ' , ' oldtable ' => ' testtable2 ' ] );현재 데이터베이스에 대한 실제 Doctrine 스키마를 다시 로드합니다.
public function reset() : self예:
$ db -> reset ();주어진 테이블의 레코드를 반환합니다.
public function select( string $ table , array $ conditions = null ) : array$table 테이블 이름$conditions 비교할 열 이름과 값의 키/값 쌍예:
$ db -> select ( ' test ' , [ ' status ' => false , ' type ' => ' old ' ] );
$ db -> select ( ' test ' ); 두 번째 매개변수에 전달된 여러 조건은 "AND"로 결합됩니다. 더 복잡한 명령문이 필요한 경우 stmt() 메서드를 대신 사용하세요.
주어진 이름에 대한 시퀀스 객체를 반환합니다.
public function sequence( string $ name , Closure $ fcn = null ) : Sequence$name 시퀀스 이름$fcn ($sequence) 매개변수가 있는 익명 함수로 시퀀스 정의 생성 또는 업데이트 시퀀스가 아직 존재하지 않으면 생성됩니다. 데이터베이스의 변경 사항을 유지하려면 up() 호출해야 합니다.
예:
$ sequence = $ db -> sequence ( ' seq_test ' );
$ sequence = $ db -> sequence ( ' seq_test ' , function ( $ seq ) {
$ seq -> start ( 1000 )-> step ( 2 )-> cache ( 100 );
} )-> up ();새 SQL 문에 대한 쿼리 빌더를 반환합니다.
public function stmt() : Doctrine DBAL Query QueryBuilder예:
$ db -> stmt ()-> delete ( $ db -> qi ( ' test ' ) )
-> where ( $ db -> qi ( ' stat ' ) . ' = ? ' )-> setParameter ( 0 , false )
-> executeStatement ();
$ db -> stmt ()-> update ( $ db -> qi ( ' test ' ) )
-> where ( $ db -> qi ( ' stat ' ) . '' , ' ? ' )-> setParameter ( 0 , true )
-> executeStatement ();
$ result = $ db -> stmt ()-> select ( $ db -> qi ( ' id ' ), $ db -> qi ( ' code ' ) )
-> from ( $ db -> qi ( ' test ' ) )
-> where ( $ db -> qi ( ' stat ' ) . ' = 1 ' )
-> executeQuery ();
while ( $ row = $ result -> fetchAssociative () ) {
$ id = $ row [ ' id ' ];
} **주의: ** $db->qi() 메소드를 사용하여 모든 테이블 및 열 이름을 직접 인용해야 합니다!
사용 가능한 Doctrine QueryBuilder 메서드에 대한 자세한 내용은 Doctrine 설명서를 참조하세요.
주어진 이름에 대한 테이블 객체를 반환합니다.
public function table( string $ name , Closure $ fcn = null ) : Table$name 테이블 이름$fcn ($table) 매개변수를 사용하여 테이블 정의를 생성하거나 업데이트하는 익명 함수 테이블이 아직 존재하지 않으면 생성됩니다. 데이터베이스의 변경 사항을 유지하려면 up() 호출해야 합니다.
예:
$ table = $ db -> table ( ' test ' );
$ table = $ db -> table ( ' test ' , function ( $ t ) {
$ t -> id ();
$ t -> string ( ' label ' );
$ t -> bool ( ' status ' );
} )-> up ();트랜잭션 내에서 주어진 클로저를 실행합니다.
public function transaction( Closure $ fcn ) : self예:
$ this -> db ()-> transaction ( function ( $ db ) {
// $db- > insert ( ... )
// $db- > update ( ... )
// $db- > delete ( ... )
} );데이터베이스에서 객체를 배열로 반환합니다.
public function toArray() : array예:
$ this -> db ()-> toArray ();반환된 배열의 구조는 다음과 같습니다.
[
' sequence ' => [
' testseq ' => [
' name ' => ' testseq ' ,
' cache ' => null ,
' start ' => 1000 ,
' step ' => 1
]
],
' table ' => [
' testtable ' => [
' name ' => ' testtable ' ,
' opt ' => [
' engine ' => ' InnoDB ' ,
' collation ' => ' utf8mb4_unicode_ci ' ,
' charset ' => ' utf8mb4 ' ,
' autoincrement ' => 1 ,
' comment ' => ''
],
' col ' => [
' id ' => [
' name ' => ' id ' ,
' type ' => ' integer ' ,
' length ' => null ,
' precision ' => null ,
' scale ' => 0 ,
' null ' => false ,
' seq ' => 1
' default ' => null,
' fixed ' => false ,
' unsigned ' => false ,
' comment ' => '' ,
' opt ' => []
],
' parentid ' => [
' name ' => ' parentid ' ,
' type ' => ' bigint ' ,
' length ' => null ,
' precision ' => null ,
' scale ' => 0 ,
' null ' => false ,
' seq ' => false ,
' default ' => null ,
' fixed ' => false ,
' unsigned ' => false ,
' comment ' => '' ,
' opt ' => []
],
' label ' => [
' name ' => ' label ' ,
' type ' => ' string ' ,
' length ' => 255 ,
' precision ' => null ,
' scale ' => 0 ,
' null ' => false ,
' seq ' => false ,
' default ' => null ,
' fixed ' => false ,
' unsigned ' => false ,
' comment ' => '' ,
' opt ' => [
' charset ' => ' utf8mb4 ' ,
' collation ' => ' utf8mb4_unicode_ci '
]
]
],
' index ' => [
' PRIMARY ' => [
' columns ' => [
0 => ' id '
],
' name ' => ' PRIMARY ' ,
' flags ' => [],
' options ' => [
' lengths ' => [
0 => null
]
],
' unique ' => 1 ,
' primary ' => 1
],
],
' foreign ' => [
' FK_6C73FFCA343B91AE ' => [
' localcol ' => [
0 => ' parentid '
],
' fktable ' => ' test ' ,
' fkcol ' => [
0 => ' id '
],
' name ' => ' FK_6C73FFCA343B91AE ' ,
' onDelete ' => ' CASCADE ' ,
' onUpdate ' => ' CASCADE '
]
]
]
],
' view ' => [
' testview ' => [
' name ' => ' testview ' ,
' sql ' => ' select `testtable`.`id` AS `id`,`testtable`.`label` AS `label` from `testtable` '
]
]
]데이터베이스의 유형을 반환합니다.
public function type() : string가능한 값은 다음과 같습니다.
예:
$ type = $ db -> type ();데이터베이스 스키마에 변경 사항을 적용합니다.
public function up() : self예:
$ db -> up ();주어진 테이블의 레코드를 업데이트합니다.
public function update( string $ table , array $ data , array $ conditions = [] ) : self$table 테이블 이름$data 업데이트할 열 이름/값의 키/값 쌍$conditions 비교할 열 이름과 값의 키/값 쌍예:
$ db -> update ( ' test ' , [ ' status ' => true ] );
$ db -> update ( ' test ' , [ ' status ' => true ], [ ' status ' => false , ' type ' => ' new ' ] ); 두 번째 매개변수에 전달된 여러 조건은 "AND"로 결합됩니다. 더 복잡한 명령문이 필요한 경우 stmt() 메서드를 대신 사용하세요.
아직 존재하지 않는 경우 지정된 이름으로 뷰를 생성합니다.
public function view( string $ name , string $ sql , $ for = null ) : self$name 뷰 이름$sql 뷰를 채우기 위한 SELECT 문$for 이 SQL을 사용해야 하는 데이터베이스 유형("mysql", "mariadb", "postgresql", "sqlite", "sqlserver", "oracle", "db2")뷰가 아직 존재하지 않으면 생성됩니다. 그렇지 않으면 아무 일도 일어나지 않을 것입니다.
예:
$ db -> view ( ' testview ' , ' SELECT * FROM testtable ' );
$ db -> view ( ' testview ' , ' SELECT id, label, status FROM testtable WHERE status = 1 ' );
$ db -> view ( ' testview ' , ' SELECT * FROM `testtable` WHERE `status` = 1 ' , ' mysql ' ); 마이그레이션 작업에서 table() 호출하여 얻는 테이블 구성표 개체는 테이블에 대한 전체 액세스 권한을 제공하며 열, 인덱스 및 외래 키를 추가, 변경 또는 제거할 수 있습니다. 예:
$ this -> db ()-> table ( ' test ' , function ( $ table ) {
$ table -> id ();
$ table -> string ( ' label ' );
$ table -> col ( ' status ' , ' tinyint ' )-> default ( 0 );
} ); 임의 유형의 열을 추가할 수 있는 col() 메소드 외에도 모든 데이터베이스 서버 구현에서 사용할 수 있는 유형에 대한 몇 가지 단축 메소드가 있습니다.
| 열 유형 | 설명 |
|---|---|
| 빅아이드 | 시퀀스/자동 증가 및 기본 키가 할당된 BIGINT 열 |
| 빅인트 | 범위가 −9223372036854775808부터 9223372036854775807까지인 BIGINT 열 |
| 바이너리 | 최대 255바이트의 VARBINARY 열 |
| 얼룩 | 최대 2GB의 BLOB 열 |
| 부울 | BOOLEAN/BIT/NUMBER 열, "부울"의 별칭 |
| 부울 | TRUE/FALSE 응답에 대한 BOOLEAN/BIT/NUMBER 열 0/1 값 |
| 숯 | 고정된 문자 수를 갖는 CHAR 열 |
| 날짜 | 시간 및 시간대가 없는 ISO 날짜 형식("YYYY-MM-DD)의 DATE 열 |
| 날짜시간 | ISO 날짜/시간 형식의 DATETIME 열("YYYY-MM-DD HH:mm:ss") |
| 테이블 날짜 시간 | ISO 날짜/시간 형식이지만 시간대 형식이 다양한 DATETIMETZ 열 |
| 소수 | 고정 소수점 정밀도의 숫자 데이터에 대한 DECIMAL 열(PHP의 문자열) |
| 뜨다 | 8바이트 부동 소수점 정밀도를 갖는 숫자 데이터용 FLOAT 열 |
| 안내 | 36바이트의 전역 고유 식별자 |
| ID | 시퀀스/자동 증가 및 기본 키가 할당된 INTEGER 열 |
| 정수 | INTEGER 열, "정수"의 별칭 |
| 정수 | 범위가 -2147483648부터 2147483647까지인 INTEGER 열 |
| JSON | UTF-8로 인코딩된 JSON 데이터에 대한 JSON 열 |
| 작은 | 범위가 -32768부터 32767까지인 INTEGER 열 |
| 끈 | 최대 255자의 VARCHAR 열 |
| 텍스트 | 최대 2GB 문자를 포함하는 TEXT/CLOB 열 |
| 시간 | 24시간 "HH:MM"의 TIME 열(예: "05:30" 또는 "22:15") |
| uuid | 36바이트의 전역 고유 식별자, "guid"의 별칭 |
MySQL(또는 MariaDB 등)은 테이블의 측면을 정의하는 몇 가지 옵션을 지원합니다. 엔진 옵션은 테이블에 사용되는 스토리지 엔진을 지정합니다.
$ this -> db ()-> table ( ' test ' , function ( $ table ) {
$ table -> opt ( ' engine ' , ' InnoDB ' );
} );단축키로 옵션을 속성으로 설정할 수도 있습니다.
$ this -> db ()-> table ( ' test ' , function ( $ table ) {
$ table -> engine = ' InnoDB ' ;
} );임시 테이블을 만들려면 다음을 사용하세요.
$ this -> db ()-> table ( ' test ' , function ( $ table ) {
$ table -> temporary = true ;
} );문자열 및 텍스트 열에 대한 기본 문자 집합과 데이터 정렬을 설정할 수도 있습니다.
$ this -> db ()-> table ( ' test ' , function ( $ table ) {
$ table -> charset = ' utf8mb4 ' ;
$ table -> collation = ' utf8mb4_unicode_ci ' ;
} ); 참고: 데이터 정렬은 PostgreSQL 및 SQL Server에서도 지원되지만 해당 값은 다릅니다. 따라서 모든 서버 유형에 동일한 값을 사용할 수는 없습니다. 이 문제를 피하려면 opt() 열 메소드를 사용하고 데이터베이스 서버 유형을 세 번째 매개변수로 전달하십시오.
$ this -> db ()-> table ( ' test ' , function ( $ table ) {
$ table -> opt ( ' charset ' , ' utf8mb4 ' , ' mysql ' );
$ table -> opt ( ' collation ' , ' utf8mb4_unicode_ci ' , ' mysql ' );
} );이제 기본 문자 집합과 데이터 정렬은 MySQL 데이터베이스 서버(또는 MariaDB 및 유사한 포크)에 대해서만 설정됩니다.
테이블 옵션의 현재 값을 알아야 하는 경우:
$ this -> db ()-> table ( ' test ' , function ( $ table ) {
// return the used table engine ( only MySQL , MariaDB , etc . )
$ engine = $ table -> engine ;
// returns TRUE if it ' s a temporary table
$ isTemp = $ table -> temporary ;
// return the current charset
$ charset = $ table -> charset ;
// return the current collation
$ collation = $ table -> collation ;
} ); 테이블이 이미 존재하는지 확인하려면 hasTable() 메소드를 사용하십시오.
if ( $ this -> db ()-> hasTable ( ' users ' ) ) {
// The "users" table exists
}한 번에 여러 테이블을 확인할 수도 있습니다.
if ( $ this -> db ()-> hasTable ( [ ' users ' , ' addresses ' ] ) ) {
// The "users" and "addresses" tables exist
} hasTable() 메서드는 모든 테이블이 존재하는 경우에만 TRUE를 반환합니다.
테이블을 생성하고 액세스하는 것 외에도 스키마 개체의 table() 메서드를 사용하여 테이블 스키마를 업데이트할 수도 있습니다. 테이블 스키마 객체를 수신할 테이블 이름과 클로저를 허용합니다.
먼저 세 개의 열을 포함하는 test 라는 테이블을 만들어 보겠습니다.
$ this -> db ()-> table ( ' test ' , function ( $ table ) {
$ table -> id ();
$ table -> string ( ' label ' );
$ table -> col ( ' status ' , ' tinyint ' )-> default ( 0 );
} );이제 코드 열을 추가하고 기존 상태 열의 기본값을 변경하여 다른 마이그레이션에서 테이블을 업데이트하려고 합니다.
$ this -> db ()-> table ( ' test ' , function ( $ table ) {
$ table -> string ( ' code ' );
$ table -> col ( ' status ' , ' tinyint ' )-> default ( 1 );
} ); 변경 사항은 table() 메서드가 반환되자마자 데이터베이스에 유지되므로 나중에 up() 직접 호출할 필요가 없습니다. 사용 가능한 열 유형 및 옵션은 열 섹션을 참조하세요.
$this->db() 에서 반환된 데이터베이스 개체는 renameTable() 메서드를 사용할 때 테이블 이름을 바꿀 수 있습니다.
// Renames the table "users" to "accounts"
$ this -> db ()-> renameTable ( ' users ' , ' account ' );이전 이름과 새 이름을 키/값 쌍으로 지정하는 연관 배열을 전달하면 여러 테이블의 이름을 한 번에 바꾸는 것도 가능합니다.
// Renames the table "users" to "accounts" and "blog" to "posts"
$ this -> db ()-> renameTable ( [ ' users ' => ' account ' , ' blog ' => ' posts ' ] );테이블은 존재하는 경우에만 이름이 변경됩니다. 테이블이 더 이상 존재하지 않으면 오류가 보고되지 않습니다.
$ this -> db ()-> renameTable ( ' notexist ' , ' newtable ' );이 경우 메서드 호출은 성공하지만 아무 일도 일어나지 않습니다.
테이블을 제거하려면 데이터베이스 스키마에서 dropTable() 메서드를 사용해야 합니다.
$ this -> db ()-> dropTable ( ' users ' );목록을 배열로 전달하여 여러 테이블을 한 번에 삭제할 수도 있습니다.
$ this -> db ()-> dropTable ( [ ' users ' , ' addresses ' ] );테이블은 존재하는 경우에만 제거됩니다. 테이블이 더 이상 존재하지 않으면 오류가 보고되지 않습니다.
$ this -> db ()-> dropTable ( ' notexist ' );이 경우 메서드 호출은 성공하지만 아무 일도 일어나지 않습니다.
사용자 정의 메소드를 호출하거나 알 수 없는 메소드 호출을 Doctrine 테이블 객체에 전달합니다.
public function __call( string $ method , array $ args )$method 메소드 이름$args 메서드 매개변수예:
Upscheme Table 개체의 클래스 속성에 액세스할 수 있는 사용자 정의 메서드를 등록할 수 있습니다.
Aimeos Upscheme Schema Table:: macro ( ' addConstraint ' , function ( array $ columns ) {
return $ this -> to -> addUniqueConstraint ( $ columns );
} );
$ table -> addConstraint ( [ ' col1 ' , ' col2 ' ] );사용 가능한 클래스 속성은 다음과 같습니다.
$this->table : 교리 테이블 스키마
$this->up : Upscheme 객체
또한 다음과 같이 Doctrine 테이블 메소드를 직접 호출할 수 있습니다.
$ table -> addUniqueConstraint ( [ ' col1 ' , ' col2 ' ] );주어진 테이블 옵션에 대한 값을 반환합니다.
public function __get( string $ name )$name 테이블 옵션 이름사용 가능한 테이블 옵션 목록은 다음과 같습니다.
예:
$ engine = $ table -> engine ;
// same as
$ engine = $ table -> opt ( ' engine ' );주어진 테이블 옵션에 대한 새 값을 설정합니다.
public function __set( string $ name , $ value )$name 테이블 옵션 이름사용 가능한 테이블 옵션 목록은 다음과 같습니다.
예:
$ table -> engine = ' InnoDB ' ;
// same as
$ table -> opt ( ' engine ' , ' InnoDB ' );"bigint" 유형의 새 ID 열을 생성하거나 기존 열을 반환합니다.
public function bigid( string $ name = null ) : Column$name ID 열 이름열에는 시퀀스(자동 증가)와 기본 키가 자동으로 할당됩니다. 열이 아직 존재하지 않으면 생성됩니다.
예:
$ table -> bigid ();
$ table -> bigid ( ' uid ' );"bigint" 유형의 새 열을 생성하거나 기존 열을 반환합니다.
public function bigint( string $ name ) : Column$name 열 이름열이 아직 존재하지 않으면 생성됩니다.
예:
$ table -> bigint ( ' testcol ' );"바이너리" 유형의 새 열을 생성하거나 기존 열을 반환합니다.
public function binary( string $ name , int $ length = 255 ) : Column$name 열 이름$length 열의 길이(바이트)열이 아직 존재하지 않으면 생성됩니다.
예:
$ table -> binary ( ' testcol ' );
$ table -> binary ( ' testcol ' , 32 );"blob" 유형의 새 열을 생성하거나 기존 열을 반환합니다.
public function blob( string $ name , int $ length = 0x7fff ) : Column$name 열 이름$length 열의 길이(바이트)"blob" 열의 최대 길이는 2GB입니다. 열이 아직 존재하지 않으면 생성됩니다.
예:
$ table -> blob ( ' testcol ' );
$ table -> blob ( ' testcol ' , 0x7fffffff );"부울" 유형의 새 열을 생성하거나 기존 열을 반환합니다.
public function bool( string $ name ) : Column$name 열 이름이 메서드는 boolean()의 별칭입니다. 열이 아직 존재하지 않으면 생성됩니다.
예:
$ table -> bool ( ' testcol ' );"부울" 유형의 새 열을 생성하거나 기존 열을 반환합니다.
public function boolean( string $ name ) : Column$name 열 이름열이 아직 존재하지 않으면 생성됩니다.
예:
$ table -> boolean ( ' testcol ' );고정된 유형으로 "char" 유형의 새 열을 생성하거나 기존 열을 반환합니다.
public function char( string $ name , int $ length ) : Column$name 열 이름$length 열의 길이(문자)열이 아직 존재하지 않으면 생성됩니다.
예:
$ table -> char ( ' testcol ' , 3 );새 열을 생성하거나 기존 열을 반환합니다.
public function col( string $ name , string $ type = null ) : Column$name 열 이름$type 유형열이 아직 존재하지 않으면 생성됩니다.
예:
$ table -> col ( ' testcol ' );
$ table -> col ( ' testcol ' , ' tinyint ' );"날짜"유형의 새 열을 생성하거나 기존 열을 반환합니다.
public function date( string $ name ) : Column$name 열의 이름입니다열이 아직 존재하지 않으면 생성됩니다.
예:
$ table -> date ( ' testcol ' );"dateTime"유형의 새 열을 생성하거나 기존 열을 반환합니다.
public function datetime( string $ name ) : Column$name 열의 이름입니다열이 아직 존재하지 않으면 생성됩니다.
예:
$ table -> datetime ( ' testcol ' );"datetimetz"유형의 새 열을 생성하거나 기존 열을 반환합니다.
public function datetimetz( string $ name ) : Column$name 열의 이름입니다열이 아직 존재하지 않으면 생성됩니다.
예:
$ table -> datetimetz ( ' testcol ' );"Decimal"유형의 새 열을 생성하거나 기존 열을 반환합니다.
public function decimal( string $ name , int $ digits , int $ decimals = 2 ) : Column$name 열의 이름입니다$digits 총 소수점을 포함한 소수점 자릿수 수$decimals 소수점 후 숫자 수열이 아직 존재하지 않으면 생성됩니다.
예:
$ table -> decimal ( ' testcol ' , 10 ); // 10 digits incl . 2 decimals
$ table -> decimal ( ' testcol ' , 10 , 4 ); // 10 digits incl . 4 decimals 존재하는 경우 이름으로 주어진 열을 삭제합니다.
public function dropColumn( $ name ) : self$name 이름 또는 열의 이름 열이나 열 중 하나가 존재하지 않으면 조용히 무시됩니다. 마이그레이션 작업이 끝나거나 up() 호출 될 때까지 변경 사항이 적용되지 않습니다.
예:
$ table -> dropColumn ( ' testcol ' );
$ table -> dropColumn ( [ ' testcol ' , ' testcol2 ' ] );존재하는 경우 이름으로 주어진 색인을 삭제합니다.
public function dropIndex( $ name ) : self$name 인덱스 또는 인덱스의 이름입니다 인덱스 또는 인덱스 중 하나가 존재하지 않으면 조용히 무시됩니다. 마이그레이션 작업이 끝나거나 up() 호출 될 때까지 변경 사항이 적용되지 않습니다.
예:
$ table -> dropIndex ( ' idx_test_col ' );
$ table -> dropIndex ( [ ' idx_test_col ' , ' idx_test_col2 ' ] );존재하는 경우 이름으로 주어진 외래 키 제약 조건을 삭제합니다.
public function dropForeign( $ name ) : self$name 이외의 주요 제약 조건 또는 제약 조건의 이름 외래 키 제약 또는 제약 조건 중 하나가 존재하지 않으면 조용히 무시됩니다. 마이그레이션 작업이 끝나거나 up() 호출 될 때까지 변경 사항이 적용되지 않습니다.
예:
$ table -> dropForeign ( ' fk_test_col ' );
$ table -> dropForeign ( [ ' fk_test_col ' , ' fk_test_col2 ' ] );기본 키가 존재하는 경우 기본 키를 삭제합니다
public function dropPrimary() : self 기본 키가 존재하지 않으면 조용히 무시됩니다. 마이그레이션 작업이 끝나거나 up() 호출 될 때까지 변경 사항이 적용되지 않습니다.
예:
$ table -> dropPrimary ();"float"유형의 새 열을 생성하거나 기존 열을 반환합니다.
public function float( string $ name ) : Column$name 열의 이름입니다열이 아직 존재하지 않으면 생성됩니다.
예:
$ table -> float ( ' testcol ' );새 외국 키를 생성하거나 기존 키를 반환합니다.
public function foreign( $ localcolumn , string $ foreigntable , $ foreigncolumn = ' id ' , string $ name = null ) : Foreign$localcolumn 이름 로컬 열 또는 열의 이름$foreigntable 이름$foreigncolumn 의 참조 열 또는 열의 이름$name 이외의 이름의 이름 및자가 생성 이름에 대한 외국 키 인덱스 또는 NULL 이름외국 키 이름의 길이는 최대의 호환성을 위해 30 자를 초과하지 않아야합니다.
예:
$ table -> foreign ( ' parentid ' , ' test ' );
$ table -> foreign ( ' parentid ' , ' test ' , ' uid ' );
$ table -> foreign ( ' parentid ' , ' test ' , ' id ' , ' fk_test_pid ' );
$ table -> foreign ( [ ' parentid ' , ' siteid ' ], ' test ' , [ ' uid ' , ' siteid ' ] );"GUID"유형의 새 열을 생성하거나 기존 열을 반환합니다.
public function guid( string $ name ) : Column$name 열의 이름입니다열이 아직 존재하지 않으면 생성됩니다.
예:
$ table -> guid ( ' testcol ' );열이 존재하는지 확인합니다
public function hasColumn( $ name ) : bool$name 이름 또는 열의 이름예:
$ table -> hasColumn ( ' testcol ' );
$ table -> hasColumn ( [ ' testcol ' , ' testcol2 ' ] );인덱스가 있는지 확인합니다
public function hasIndex( $ name ) : bool$name 인덱스 또는 인덱스의 이름입니다예:
$ table -> hasIndex ( ' idx_test_col ' );
$ table -> hasIndex ( [ ' idx_test_col ' , ' idx_test_col2 ' ] );외래 키 제약이 존재하는지 확인합니다
public function hasForeign( $ name ) : bool$name 이외의 주요 제약 조건 또는 제약 조건의 이름예:
$ table -> hasForeign ( ' fk_test_col ' );
$ table -> hasForeign ( [ ' fk_test_col ' , ' fk_test_col2 ' ] );"정수"유형의 새 ID 열을 생성하거나 기존 ID 열을 반환합니다.
public function id( string $ name = null ) : Column$name 이름열에는 시퀀스 (AutoinCrement)와 기본 키가 자동으로 할당됩니다. 열이 아직 존재하지 않으면 생성됩니다.
예:
$ table -> id ();
$ table -> id ( ' uid ' );새 인덱스를 생성하거나 기존 색인을 대체합니다
public function index( $ columns , string $ name = null ) : self$columns 색인을 스폰하는 열 또는 열의 이름$name 색인 이름 또는자가 생성 이름에 대한 null최대 호환성을 위해 인덱스 이름의 길이가 30 자를 초과하지 않아야합니다.
예:
$ table -> index ( ' testcol ' );
$ table -> index ( [ ' testcol ' , ' testcol2 ' ] );
$ table ->index( ' testcol ' , 'idx_test_testcol );"정수"유형의 새 열을 생성하거나 기존 열을 반환합니다.
public function int( string $ name ) : Column$name 열의 이름입니다이 방법은 Integer ()의 별칭입니다. 열이 아직 존재하지 않으면 생성됩니다.
예:
$ table -> int ( ' testcol ' );"정수"유형의 새 열을 생성하거나 기존 열을 반환합니다.
public function integer( string $ name ) : Column$name 열의 이름입니다열이 아직 존재하지 않으면 생성됩니다.
예:
$ table -> integer ( ' testcol ' );"JSON"유형의 새 열을 생성하거나 기존 열을 반환합니다.
public function json( string $ name ) : Column$name 열의 이름입니다열이 아직 존재하지 않으면 생성됩니다.
예:
$ table -> json ( ' testcol ' );테이블 이름을 반환합니다
public function name() : string예:
$ tablename = $ table -> name ();사용자 정의 스키마 옵션을 설정하거나 현재 값을 반환합니다.
public function opt( string $ name , $ value = null )$name 테이블 관련 사용자 정의 스키마 옵션의 이름$value 값사용 가능한 사용자 정의 스키마 옵션은 다음과 같습니다.
예:
$ charset = $ table -> opt ( ' charset ' );
$ table -> opt ( ' charset ' , ' utf8 ' )-> opt ( ' collation ' , ' utf8_bin ' );
// Magic methods :
$ charset = $ table -> charset ;
$ table -> charset = ' binary ' ;새 기본 색인을 생성하거나 기존 인덱스를 대체합니다.
public function primary( $ columns , string $ name = null ) : self$columns 색인을 스폰하는 열 또는 열의 이름$name 색인 이름 또는자가 생성 이름에 대한 null최대 호환성을 위해 인덱스 이름의 길이가 30 자를 초과하지 않아야합니다.
예:
$ table -> primary ( ' testcol ' );
$ table -> primary ( [ ' testcol ' , ' testcol2 ' ] );
$ table -> primary ( ' testcol ' , ' pk_test_testcol ' );열 또는 열 목록을 이름 바꾸십시오
public function renameColumn( $ from , string $ to = null ) : self$from 열 이름 또는 이전/새 열 이름의 배열$to new Column Name 이름이 첫 번째 매개 변수 인 경우 무시됩니다.예:
// single column
$ table -> renameColumn ( ' test_col ' , ' test_column ' );
// rename several columns at once
$ table -> renameColumn ( [ ' tcol ' => ' testcol ' , ' tcol2 ' => ' testcol2 ' ] );인덱스 또는 인덱스 목록을 이름 바꾸십시오
public function renameIndex( $ from , string $ to = null ) : self$from (새 인덱스 이름 인 경우 생성됩니다)$to 새 인덱스 이름 또는자가 유전자 이름에 대한 NULL (첫 번째 매개 변수가 배열 인 경우 무시됨)인덱스 이름의 길이는 최대 호환성을 위해 30 자를 초과하지 않아야합니다.
예:
// generate a new name automatically
$ table -> renameIndex ( ' test_col_index ' );
// custom name
$ table -> renameIndex ( ' test_col_index ' , ' idx_test_col ' );
// rename several indexes at once
$ table -> renameIndex ( [ ' test_col_index ' => null , ' test_index ' => ' idx_test_col ' ] );"smallint"유형의 새 열을 생성하거나 기존 열을 반환합니다.
public function smallint( string $ name ) : Column$name 열의 이름입니다열이 아직 존재하지 않으면 생성됩니다.
예:
$ table -> smallint ( ' testcol ' );새 공간 색인을 생성하거나 기존 지수를 대체합니다.
public function spatial( $ columns , string $ name = null ) : self$columns 열 이색 또는 열의 이름을 인덱스를 생성하는 열 이름$name 색인 이름 또는자가 생성 이름에 대한 null최대 호환성을 위해 인덱스 이름의 길이가 30 자를 초과하지 않아야합니다.
예:
$ table -> spatial ( ' testcol ' );
$ table -> spatial ( [ ' testcol ' , ' testcol2 ' ] );
$ table -> spatial ( ' testcol ' , ' idx_test_testcol ' );"String"유형의 새 열을 생성하거나 기존 열을 반환합니다.
public function string( string $ name , int $ length = 255 ) : Column$name 열의 이름입니다$length in 문자 열의 길이이 유형은 최대 255 자까지 사용해야합니다. 더 많은 문자는 "텍스트"유형을 사용하십시오. 열이 아직 존재하지 않으면 생성됩니다.
예:
$ table -> string ( ' testcol ' );
$ table -> string ( ' testcol ' , 32 );"텍스트"유형의 새 열을 생성하거나 기존의 열을 반환합니다.
public function text( string $ name , int $ length = 0xffff ) : Column$name 열의 이름입니다$length in 문자 열의 길이"텍스트"열의 최대 길이는 2GB입니다. 열이 아직 존재하지 않으면 생성됩니다.
예:
$ table -> text ( ' testcol ' );
$ table -> text ( ' testcol ' , 0x7fffffff );"Time"유형의 새 열을 생성하거나 기존 열을 반환합니다.
public function time( string $ name ) : Column$name 열의 이름입니다열이 아직 존재하지 않으면 생성됩니다. 이 데이터 타입은 Oracle 데이터베이스를 사용할 때 사용할 수 없습니다.
예:
$ table -> time ( ' testcol ' );새로운 고유 인덱스를 생성하거나 기존 인덱스를 대체합니다.
public function unique( $ columns , string $ name = null ) : self$columns 열 이색 또는 열의 이름을 인덱스를 생성하는 열 이름$name 색인 이름 또는자가 생성 이름에 대한 null최대 호환성을 위해 인덱스 이름의 길이가 30 자를 초과하지 않아야합니다.
예:
$ table -> unique ( ' testcol ' );
$ table -> unique ( [ ' testcol ' , ' testcol2 ' ] );
$ table -> unique ( ' testcol ' , ' unq_test_testcol ' );"GUID"유형의 새 열을 생성하거나 기존 열을 반환합니다.
public function uuid( string $ name ) : Column$name 열의 이름입니다이 메소드는 guid ()의 별칭입니다. 열이 아직 존재하지 않으면 생성됩니다.
예:
$ table -> uuid ( ' testcol ' );데이터베이스 스키마에 변경 사항을 적용합니다
public function up() : self예:
$ table -> up (); 마이그레이션 작업에서 col() 호출하여 얻는 열 스키마 객체는 모든 열 속성에 액세스 할 수 있습니다. 모든 데이터베이스에서 지원하는 열 유형에 사용할 수있는 바로 가기도 있습니다. 각 열은 하나 이상의 수정 자 메소드로 변경 될 수 있으며 단일 열에 인덱스를 추가 할 수도 있습니다.
$ this -> db ()-> table ( ' test ' , function ( $ table ) {
$ table -> id ()-> unsigned ( true );
$ table -> string ( ' label ' )-> index ();
$ table -> col ( ' status ' , ' tinyint ' )-> default ( 0 );
} );예제는 다음 열을 추가합니다.
모든 데이터베이스 서버 구현에서 사용할 수있는 열 유형에 대한 몇 가지 바로 가기 방법이 있습니다.
| 열 유형 | 설명 |
|---|---|
| 빅아이드 | 시퀀스/자동화 및 기본 키가있는 큰 열 |
| 빅인트 | −9223372036854775808에서 9223372036854775807 범위의 큰 열 |
| 바이너리 | 최대 255 바이트가있는 varbinary 열 |
| 얼룩 | 최대 2GB의 블로브 열 |
| 부울 | 부울/비트/번호 Colum, "부울"에 대한 별칭 |
| 부울 | true/false resp에 대한 부울/비트/번호 Colum. 0/1 값 |
| 숯 | 고정 된 수의 문자가있는 char 열 |
| 날짜 | 시간과 시간대없이 ISO 날짜 형식 ( "yyyy-mm-dd)의 날짜 열 |
| 날짜시간 | ISO 날짜/시간 형식의 DateTime 열 ( "YYYY-MM-DD HH : MM : SS") |
| TablesDateTimetz | ISO 날짜/시간 형식의 DateTimetz 열이지만 다양한 시간대 형식 |
| 소수 | 고정점 정밀도 (PHP의 문자열)를 가진 숫자 데이터의 소수 열 |
| 뜨다 | 8 바이트 부동 소수점 정밀도가있는 숫자 데이터의 플로트 열 |
| 안내 | 36 바이트가있는 전 세계적으로 고유 한 식별자 |
| ID | 시퀀스/자동화 및 기본 키가있는 정수 열 |
| 정수 | 정수 Colum, "정수"를위한 별칭 |
| 정수 | -2147483648에서 2147483647 범위의 정수 콜럼 |
| JSON | UTF-8의 JSON 열은 JSON 데이터를 인코딩했습니다 |
| 작은 | -32768에서 32767 범위의 정수 콜럼 |
| 끈 | 최대 255 자의 Varchar 열 |
| 텍스트 | 최대 2GB 문자 인 텍스트/클로브 열 |
| 시간 | 24 시간 "hh : mm"의 시간 열, 예를 들어 "05:30"또는 "22:15" |
| uuid | 36 바이트가있는 전 세계 고유 식별자, "Guid"에 대한 별칭 |
데이터베이스 특정 열 유형을 추가하려면 col() 메소드를 사용하십시오.
$ this -> db ()-> table ( ' test ' , function ( $ table ) {
$ table -> col ( ' status ' , ' tinyint ' );
} );하나 이상의 열 수정자를 호출하여 열 정의를 변경할 수도 있습니다.
$ this -> db ()-> table ( ' test ' , function ( $ table ) {
$ table -> int ( ' number ' )-> null ( true )-> unsigned ( true );
} );사용 가능한 열 수정 자 방법은 다음과 같습니다.
| 열 수정 자 | 설명 |
|---|---|
| 자동화 (True) | 정수 열을 자동 침입으로 설정합니다 ( seq() 의 별칭) |
| 숯불 ( 'UTF8') | 열 (MySQL)에서 사용하는 문자 세트 |
| Collation ( 'Binary') | 열 collation (mysql/postgresql/sqlite/sqlserver이지만 호환되지 않음) |
| 댓글 ( '코멘트') | 열에 댓글을 추가하십시오 (MySQL/PostgreSQL/Oracle/SQLServer) |
| 기본값 (1) | 값이 지정되지 않은 경우 열의 기본값 (기본값 : NULL ) |
| 고정 (true) | 문자열 또는 이진 열에 고정 된 길이가 있어야하는 경우 |
| 색인 ( 'idx_col') | 열에 색인 추가, 색인 이름은 선택 사항입니다. |
| 길이 (32) | 최대. 문자열과 이진 열의 길이 |
| 널 (True) | 널 값을 열에 삽입 할 수 있습니다 |
| 정밀도 (12) | 최대. 소수점 및 플로트 컬럼에 저장된 숫자 수 십진수 |
| 1 차 ( 'PK_COL') | 열에 기본 키를 추가하면 기본 키 이름은 선택 사항입니다. |
| 척도 (2) | 소수점 및 플로트 컬럼에 사용되는 정확한 소수점 숫자 수 |
| seq (true) | 값이 지정되지 않은 경우 정수 열을 자동 증가로 설정 |
| 공간 ( 'idx_col') | 열에 공간 (GEO) 색인을 추가하고 색인 이름은 선택 사항입니다. |
| 독특한 ( 'unq_col') | 열에 고유 인덱스 추가, 색인 이름은 선택 사항입니다. |
| 부호없는 (참) | 서명되지 않은 정수 값 만 허용 (MySQL) |
열에 대한 사용자 정의 스키마 옵션을 설정하려면 opt() 메소드를 사용하십시오.
$ this -> db ()-> table ( ' test ' , function ( $ table ) {
$ table -> string ( ' code ' )-> opt ( ' collation ' , ' utf8mb4 ' );
} );데이터베이스 유형을 세 번째 매개 변수로 전달하여 특정 데이터베이스 구현의 열 수정자를 설정할 수도 있습니다.
$ this -> db ()-> table ( ' test ' , function ( $ table ) {
$ table -> string ( ' code ' )-> opt ( ' collation ' , ' utf8mb4 ' , ' mysql ' );
} ); 열이 이미 존재하는지 확인하려면 hasColumn() 메소드를 사용하십시오.
if ( $ this -> db ()-> hasColumn ( ' users ' , ' name ' ) ) {
// The "name" column in the "users" table exists
} 한 번에 여러 열을 확인할 수도 있습니다. 이 경우 hasColumn() 메소드는 모든 열이 존재하는 경우에만 true를 반환합니다.
if ( $ this -> db ()-> hasColumn ( ' users ' , [ ' name ' , ' status ' ] ) ) {
// The "name" and "status" columns in the "users" table exists
} 이미 테이블 객체가있는 경우 hasColumn() 도 사용할 수 있습니다.
if ( $ table -> hasColumn ( ' name ' ) ) {
// The "name" column in the table exists
}
if ( $ table -> hasColumn ( [ ' name ' , ' status ' ] ) ) {
// The "name" and "status" columns in the table exists
}열 외에도 열 수정자가 설정되어 있는지 확인하고 어떤 값이 있는지 확인할 수도 있습니다.
if ( $ table -> string ( ' code ' )-> null () ) {
// The "code" columns is nullable
}이 방법을 사용하여 현재 열 수정 자 값을 검색 할 수 있습니다.
| 열 수정 자 | 설명 |
|---|---|
| autoincrement () | 컬럼이 자동 증가 인 경우 true ( seq() 의 별칭) |
| charset () | 중고 캐릭터 세트 (MySQL) |
| 대조() | 중고 collation (mysql/postgresql/sqlite/sqlserver 그러나 호환되지 않음) |
| 논평() | 열과 관련된 주석 (mysql/postgresql/oracle/sqlserver) |
| 기본() | 열의 기본값 |
| 결정된() | 문자열 또는 이진 열에 고정 된 길이가있는 경우 true |
| 길이() | 문자열 또는 이진 열의 최대 길이 |
| null () | 널 값이 허용되는 경우 참입니다 |
| 정도() | 소수점 및 플로트 칼럼에 저장된 최대 숫자 수 십진수 |
| 규모() | 소수점 및 플로트 컬럼에 사용되는 정확한 소수점 숫자 수 |
| seq () | 컬럼이 자동 증가하는 경우 |
| unsigned () | 부호없는 정수 값 만 허용되는 경우 (MySQL) |
비표준 열 수정자를 확인하려면 두 번째 매개 변수가없는 opt() 메소드를 사용하십시오. 그런 다음 열 수정 자의 현재 값을 반환합니다.
if ( $ table -> string ( ' code ' )-> opt ( ' charset ' ) === ' utf8 ' ) {
// The "code" columns uses UTF - 8 charset ( MySQL only)
}문자열 열의 길이와 같이 대부분의 열 수정자를 변경할 수 있습니다.
$ this -> db ()-> table ( ' test ' , function ( $ table ) {
$ table -> string ( ' code ' )-> length ( 64 );
} );일부 방법은 또한 가장 자주 사용되는 수정자를 직접 설정할 수있는 추가 매개 변수를 제공합니다.
$ this -> db ()-> table ( ' test ' , function ( $ table ) {
$ table -> string ( ' code ' , 64 );
} ); 나중에 행을 마이그레이션하려면 열 수정자를 즉시 변경 해야하는 경우 up() 메소드를 사용하여 변경 사항을 지속하십시오.
$ this -> db ()-> table ( ' test ' , function ( $ table ) {
$ table -> string ( ' code ' , 64 )-> null ( true )-> up ();
// modify rows from "test" table
} ); 적절한 유형 또는 col() 메소드에 새 메소드를 사용하여 열 유형을 변경할 수 있습니다.
$ this -> db ()-> table ( ' test ' , function ( $ table ) {
$ table -> text ( ' code ' );
// or
$ table -> col ( ' code ' , ' text ' );
} );모든 열 유형이 다른 유형으로 변경 될 수 있거나 최소한 데이터 손실 없이는 변경할 수있는 것은 아닙니다. 정수 열을 문제없이 큰 열로 변경할 수 있지만 다른 방법은 실패합니다. Varchar 열 (문자열)을 정수 열로 변경하려는 경우에도 마찬가지입니다.
열 이름을 바꾸려면 DB 스키마의 renameColumn() 메소드를 사용하십시오.
// single column
$ this -> db ()-> renameColumn ( ' testtable ' , ' label ' , ' name ' );
// multiple columns
$ this -> db ()-> renameColumn ( ' testtable ' , [ ' label ' => ' name ' , ' stat ' => ' status ' ] ); 테이블 객체를 이미 사용할 수있는 경우 renameColumn() 메소드를 사용하여 하나 이상의 열을 바꿀 수 있습니다.
$ this -> db ()-> table ( ' testtable ' , function ( $ table ) {
// single column
$ table -> renameColumn ( ' label ' , ' name ' );
// multiple columns
$ table -> renameColumn ( [ ' label ' => ' name ' , ' stat ' => ' status ' ] );
} );모든 경우에 열은 존재하는 경우에만 제거됩니다. 테이블에 하나 이상의 열이 존재하지 않으면 오류 가보고되지 않습니다.
열을 삭제하려면 DB 스키마 개체에서 dropColumn() 메소드를 사용하십시오.
$ this -> db ()-> dropColumn ( ' users ' , ' name ' );배열로 삭제하려는 모든 열의 이름을 전달하면 여러 열을 한 번에 삭제할 수 있습니다.
$ this -> db ()-> dropColumn ( ' users ' , [ ' name ' , ' status ' ] ); 이미 테이블 객체가있는 경우 dropColumn() 도 사용할 수도 있습니다.
// single column
$ table -> dropColumn ( ' name ' );
// multiple columns
$ table -> dropColumn ( [ ' name ' , ' status ' ] );모든 경우에 열은 존재하는 경우에만 제거됩니다. 테이블에 하나 이상의 열이 존재하지 않으면 오류 가보고되지 않습니다.
사용자 정의 메소드를 호출하거나 알려지지 않은 메소드 호출을 교리 열 객체로 통과합니다.
public function __call( string $ method , array $ args )$method 이름입니다$args 메소드 매개 변수예:
Upscheme 열 객체의 클래스 속성에 액세스 할 수있는 사용자 정의 메소드를 등록 할 수 있습니다.
Aimeos Upscheme Schema Column:: macro ( ' platform ' , function ( array $ options ) {
return $ this -> to -> setPlatformOptions ( $ options );
} );
$ column -> platform ( [ ' option ' => ' value ' ] );사용 가능한 클래스 속성은 다음과 같습니다.
$this->db : upscheme db 객체
$this->table : 교리 테이블 스키마
$this->column : 교리 열 스키마
또한 교리 칼럼 방법을 직접 호출 할 수 있습니다.
$ column -> setPlatformOptions ( [ ' option ' => ' value ' ] );주어진 열 옵션의 값을 반환합니다
public function __get( string $ name )$name 열 옵션 이름사용 가능한 열 옵션 목록은 다음과 같습니다.
예:
$ charset = $ column -> charset ;
// same as
$ charset = $ column -> opt ( ' charset ' );주어진 열 옵션의 새 값을 설정합니다
public function __set( string $ name , $ value )$name 열 옵션 이름$value 열 옵션 값사용 가능한 열 옵션 목록은 다음과 같습니다.
예:
$ column -> charset = ' utf8 ' ;
// same as
$ column -> opt ( ' charset ' , ' utf8 ' );열을 자동 인정으로 설정하거나 현재 값을 반환합니다.
public function autoincrement( bool $ value = null )$value 새로운 자동 자동화기 플래그 또는 NULL 현재 값을 반환합니다. 이 메소드는 seq() 메소드의 별칭입니다.
예:
$ value = $ column -> autoincrement ();
$ column -> autoincrement ( true );열 숯을 설정하거나 현재 값을 반환합니다
public function charset( string $ value = null )$value 새 열 charset 또는 null to reture current value예:
$ comment = $ column -> charset ();
$ column -> charset ( ' utf8 ' );열 클러케이션을 설정하거나 현재 값을 반환합니다
public function collation( string $ value = null )$value 새 열 collation 또는 null to retud current vare예:
$ comment = $ column -> collation ();
$ column -> collation ( ' binary ' );열 주석을 설정하거나 현재 값을 반환합니다
public function comment( string $ value = null )$value 새 열 댓글 또는 null to retud current Value예:
$ comment = $ column -> comment ();
$ column -> comment ( ' column comment ' );열 기본값을 설정하거나 현재 값을 반환합니다.
public function default( $ value = null )$value 새 열 기본값 또는 null to retud current vary예:
$ value = $ column -> default ();
$ column -> default ( 0 );열 고정 플래그를 설정하거나 현재 값을 반환합니다.
public function fixed( bool $ value = null )$value 새 열 고정 플래그 또는 null 현재 값을 반환합니다.예:
$ value = $ column -> fixed ();
$ column -> fixed ( true );열에 대한 일반 색인을 만듭니다
public function index( string $ name = null ) : self$name 인덱스의 이름 또는 자동으로 생성 할 null예:
$ column -> index ();
$ column -> index ( ' idx_col ' );열 길이를 설정하거나 현재 값을 반환합니다
public function length( int $ value = null )$value 새 열 길이 또는 null 현재 값을 반환합니다.예:
$ value = $ column -> length ();
$ column -> length ( 32 );열의 이름을 반환합니다
public function name() : string예:
$ name = $ column -> name ();열 null 플래그를 설정하거나 현재 값을 반환합니다.
public function null( bool $ value = null )$value 새 열 null 플래그 또는 null 현재 값을 반환합니다.예:
$ value = $ column -> null ();
$ column -> null ( true );열 옵션 값을 설정하거나 현재 값을 반환합니다.
public function opt( string $ option , $ value = null , $ for = null )$option 열 옵션 이름$value 새 열 옵션 값 또는 NULL 현재 값을 반환합니다.$for null $ ( "mysql", "mariadb", "postgresql", "sqlite", "sqlserver", "oracle", "db2")에 사용해야합니다.예:
$ value = $ column -> opt ( ' length ' );
$ column -> opt ( ' length ' , 64 );열 정밀도를 설정하거나 현재 값을 반환합니다
public function precision( int $ value = null )$value 새 열 정밀 값 또는 null 현재 값을 반환합니다.예:
$ value = $ column -> precision ();
$ column -> precision ( 10 );열에 대한 기본 색인을 만듭니다
public function primary( string $ name = null ) : self$name 인덱스의 이름 또는 자동으로 생성 할 null예:
$ column -> primary ();
$ column -> primary ( ' pk_col ' );열 스케일을 설정하거나 현재 값을 반환합니다
public function scale( int $ value = null )$value 새 열 스케일 값 또는 NULL 현재 값을 반환합니다.예:
$ value = $ column -> scale ();
$ column -> scale ( 3 );열을 자동 인정으로 설정하거나 현재 값을 반환합니다.
public function seq( bool $ value = null )$value 새로운 자동 자동화기 플래그 또는 NULL 현재 값을 반환합니다.예:
$ value = $ column -> seq ();
$ column -> seq ( true );열에 대한 공간 색인을 만듭니다
public function spatial( string $ name = null ) : self$name 인덱스의 이름 또는 자동으로 생성 할 null예:
$ column -> spatial ();
$ column -> spatial ( ' idx_col ' );열 유형을 설정하거나 현재 값을 반환합니다
public function type( string $ value = null )$value 새 열 유형 또는 NULL 현재 값을 반환합니다.예:
$ value = $ column -> type ();
$ column -> type ( ' tinyint ' );열에 대한 고유 한 색인을 만듭니다
public function unique( string $ name = null ) : self$name 인덱스의 이름 또는 자동으로 생성 할 null예:
$ column -> unique ();
$ column -> unique ( ' unq_col ' );열이 부호없는 플래그를 설정하거나 현재 값을 반환합니다.
public function unsigned( bool $ value = null )$value 새 열이없는 플래그 또는 null 현재 값을 반환합니다.예:
$ value = $ column -> unsigned ();
$ column -> unsigned ( true );데이터베이스 스키마에 변경 사항을 적용합니다
public function up() : self예:
$ column -> up (); Upscheme은 두 테이블 사이의 데이터의 무결성을 시행하는 외국의 주요 제약 조건에 대한 지원을 제공합니다. 예를 들어, users_address 테이블의 parentid 열이 users 테이블의 id 열을 참조하면 users 테이블에 일치하는 행이없는 users_address 테이블에 행이 없을 수 있습니다. foreign() 메소드를 호출하면 그러한 제약이 생성됩니다.
$ this -> db ()-> table ( ' users ' , function ( $ table ) {
$ table -> id ();
} );
$ this -> db ()-> table ( ' users_address ' , function ( $ table ) {
$ table -> foreign ( ' parentid ' , ' users ' );
} ); 참고 : 열 ( parentid )은 참조 열 ( id )과 동일한 데이터 유형 및 열 수정자를 가져야합니다. foreign() 메소드는 외래 키 제약 조건과 자동으로 이름을 가진 새 인덱스를 확인하고 생성합니다.
users 테이블의 ID 열이 다르게 지명되면 이름으로 이름을 foreign() 번째 매개 변수로 전달하십시오.
$ this -> db ()-> table ( ' users_address ' , function ( $ table ) {
$ table -> foreign ( ' parentid ' , ' users ' , ' uid ' );
} );나중에 외국 키 제약 조건의 이름을 Forth 매개 변수로 전달하는 것이 좋습니다.
$ this -> db ()-> table ( ' users_address ' , function ( $ table ) {
$ table -> foreign ( ' parentid ' , ' users ' , ' id ' , ' fk_test_pid ' );
} );외국 키에 필요한 고유 한 값을 가져 오는 데 필요한 열 이상의 열이 있으면 열 이름을 배열로 전달하십시오.
$ this -> db ()-> table ( ' users_address ' , function ( $ table ) {
$ table -> foreign ( [ ' parentid ' , ' siteid ' ], ' users_address ' , [ ' id ' , ' siteid ' ] );
} ); 외국 테이블의 참조 열이 업데이트 된 경우 외국의 주요 제약 조건이 다른 조치를 수행 할 수 있습니다. 표준 조치는 행을 삭제하거나 참조 된 ID 값을 업데이트하는 것입니다. 동작을 변경하려면 onDelete() 및 onUpdate() 메소드를 사용하십시오.
$ this -> db ()-> table ( ' users_address ' , function ( $ table ) {
$ table -> foreign ( ' parentid ' , ' users ' )-> onDelete ( ' SET NULL ' )-> onUpdate ( ' RESTRICT ' );
} );두 값을 동일한 값으로 설정하려면 바로 가기가 있습니다.
$ this -> db ()-> table ( ' users_address ' , function ( $ table ) {
$ table -> foreign ( ' parentid ' , ' users ' )-> do ( ' SET NULL ' );
} );두 방법 모두에 대한 가능한 값은 다음과 같습니다.
행을 삭제하거나 업데이트 할 때의 기본 조치는 캐스케이드 이므로 외국 키 열의 값이 외래 테이블과 동일한 값으로 업데이트됩니다.
외국 키가 이미 존재하는지 확인하려면 hasForeign() 메소드를 사용하십시오.
if ( $ this -> db ()-> hasForeign ( ' users_address ' , ' fk_usrad_parentid ' ) ) {
// The "fk_usrad_parentid" foreign key in the " users_address " table exists
} 한 번에 여러 외국의 주요 제약 조건을 확인할 수도 있습니다. 그런 다음 hasForeign() 메소드는 첫 번째 인수로 전달 된 테이블에 모든 제약이 존재하는 경우에만 true를 반환합니다.
if ( $ this -> db ()-> hasForeign ( ' users_address ' , [ ' fk_usrad_parentid ' , ' fk_usrad_siteid ' ] ) ) {
// The "fk_usrad_parentid" and "fk_usrad_siteid" foreign keys exist in the "users_address" table
} 테이블 객체를 사용할 수 있으면 대신 테이블의 hasForeign() 메소드를 사용할 수 있습니다.
$ this -> db ()-> table ( ' users_address ' , function ( $ table ) {
$ table -> hasForeign ( ' fk_usrad_parentid ' ) ) {
// The "fk_usrad_parentid" foreign key in the " users_address " table exists
}
} );
$ this -> db ()-> table ( ' users_address ' , function ( $ table ) {
$ table -> hasForeign ( [ ' fk_usrad_parentid ' , ' fk_usrad_siteid ' ] ) ) {
// The "fk_usrad_parentid" and "fk_usrad_siteid" foreign keys exist in the "users_address" table
}
} );기존 제약 조건의 현재 값이 필요한 경우 :
$ this -> db ()-> table ( ' users_address ' , function ( $ table ) {
$ fk = $ table -> foreign ( ' parentid ' , ' users ' );
// returns the name of the constraint
$ name = $ fk -> name ()
// returns the action when deleting rows
$ action = $ fk -> onDelete ;
// returns the action when updating the foreign ID
$ action = $ fk -> onUpdate ;
} ); 테이블에서 외래 키 제약 조건을 제거하려면 dropForeign() 메소드를 사용하고 테이블 이름과 외국 키 이름을 인수로 전달하십시오.
$ this -> db ()-> dropForeign ( ' users_address ' , ' fk_usrad_parentid ' );여러 외국 키 이름을 전달하여 한 번에 삭제할 수도 있습니다.
$ this -> db ()-> dropForeign ( ' users_address ' , [ ' fk_usrad_parentid ' , ' fk_usrad_siteid ' ] ); table() 메소드로 전달 된 익명 함수 내에서 dropForeign() 메소드를 사용할 수도 있습니다.
$ this -> db ()-> table ( ' users_address ' , function ( $ table ) {
$ table -> dropForeign ( ' fk_usrad_parentid ' );
} );
$ this -> db ()-> table ( ' users_address ' , function ( $ table ) {
$ table -> dropForeign ( [ ' fk_usrad_parentid ' , ' fk_usrad_siteid ' ] );
} );사용자 정의 방법을 호출합니다
public function __call( string $ method , array $ args )$method 이름입니다$args 메소드 매개 변수예:
Upscheme 외국 객체의 클래스 속성에 액세스 할 수있는 사용자 정의 메소드를 등록 할 수 있습니다.
Aimeos Upscheme Schema Foreign:: macro ( ' default ' , function () {
$ this -> opts = [ ' onDelete ' => ' SET NULL ' , ' onUpdate ' => ' SET NULL ' ];
} );
$ foreign -> default ();사용 가능한 클래스 속성은 다음과 같습니다.
$this->dbaltable : 교리 테이블 스키마
$this->table : Upscheme 테이블 개체
$this->localcol : 로컬 열 이름 또는 이름
$this->fktable : 외국 테이블 이름
$this->fkcol : 외국 열 이름 또는 이름
$this->name : 외국 키 이름
$this->opts : 외국 핵심 옵션의 연관성 목록 (주로 "Ondelete"및 "OnupDate")
주어진 외국 키 옵션의 값을 반환합니다
public function __get( string $ name )$name 이외 키 옵션 이름사용 가능한 외국 키 옵션 목록은 다음과 같습니다.
두 옵션 모두에 대한 가능한 값은 다음과 같습니다.
예:
$ value = $ foreign -> onDelete ;
// same as
$ value = $ foreign -> opt ( ' onDelete ' );주어진 외국 키 옵션에 대한 새 값을 설정합니다.
public function __set( string $ name , $ value )$name 이외 키 옵션 이름사용 가능한 외국 키 옵션 목록은 다음과 같습니다.
두 옵션 모두에 대한 가능한 값은 다음과 같습니다.
예:
$ foreign -> onDelete = ' SET NULL ' ;
// same as
$ foreign -> onDelete ( ' SET NULL ' );
$ foreign -> opt ( ' onDelete ' , ' SET NULL ' );주어진 외국 키 옵션에 대한 새 값을 설정합니다.
public function do( string $ action ) : self$action 수행 작업가능한 조치는 다음과 같습니다.
예:
$ foreign -> do ( ' RESTRICT ' ); public function name()예:
$ fkname = $ foreign -> name (); public function onDelete( string $ value = null ) @Param String | null $value 수행 된 동작 또는 NULL 현재 값을 반환합니다.
@return self | String 값을 설정하는 동일한 개체, 매개 변수가없는 현재 값
사용 가능한 조치는 다음과 같습니다.
예:
$ value = $ foreign -> onDelete ();
$ foreign -> onDelete ( ' SET NULL ' );
// same as
$ foreign -> onDelete = ' SET NULL ' ;
// same as
$ foreign -> opt ( ' onDelete ' , ' SET NULL ' );
$ foreign -> onDelete ( ' SET NULL ' )-> onUpdate ( ' SET NULL ' ); public function onUpdate( string $ value = null ) @Param String | null $value 수행 된 동작 또는 NULL 현재 값을 반환합니다.
@return self | String 값을 설정하는 동일한 개체, 매개 변수가없는 현재 값
사용 가능한 조치는 다음과 같습니다.
예:
$ value = $ foreign -> onUpdate ();
$ foreign -> onUpdate ( ' SET NULL ' );
// same as
$ foreign -> onUpdate = ' SET NULL ' ;
// same as
$ foreign -> opt ( ' onUpdate ' , ' SET NULL ' );
$ foreign -> onUpdate ( ' SET NULL ' )-> onDelete ( ' SET NULL ' ); public function up() : self예:
$ foreign -> up (); 몇 가지 데이터베이스 구현은 자동 인익/ID 열, 즉 Oracle 및 PostgreSQL 대신 시퀀스를 제공합니다. 시퀀스는 새 행을 삽입 할 때 테이블 열에 적용되는 순차적으로 증가하는 숫자를 생성하는 함수입니다. seq_test 라는 새 시퀀스를 만들려면 sequence() 메소드를 사용하십시오.
$ this -> db ()-> sequence ( ' seq_test ' ); 1 과 다른 시작 값과 단계 너비를 사용하려면 start() 및 step() 메소드를 호출하십시오.
$ this -> db ()-> sequence ( ' seq_test ' , function ( $ seq ) {
$ seq -> start ( 1000 )-> step ( 2 );
} ); 시퀀스가 이미 존재하는지 확인하려면 hasSequence() 메소드를 사용하십시오.
if ( $ this -> db ()-> hasSequence ( ' seq_test ' ) ) {
// The "seq_test" sequence exists
} 한 번에 여러 시퀀스를 확인할 수도 있습니다. 그런 다음 hasSequence() 메소드는 모든 시퀀스가 존재하는 경우에만 true를 반환합니다.
if ( $ this -> db ()-> hasSequence ( [ ' seq_id ' , ' seq_test ' ] ) ) {
// The "seq_id" and "seq_test" sequences exist
}테이블 옵션의 현재 값을 알아야하는 경우 :
$ this -> db ()-> sequence ( ' seq_test ' , function ( $ seq ) {
// returns how many generated numbers are cached
$ cache = $ seq -> cache ;
// returns the number the sequence has started from
$ start = $ seq -> start ;
// returns the step width for newly generated numbers
$ step = $ seq -> step ;
} ); 시퀀스를 제거하려면 dropSequence() 메소드를 사용하고 시퀀스 이름을 인수로 전달하십시오.
$ this -> db ()-> dropSequence ( ' seq_id ' );여러 시퀀스 이름을 전달하여 한 번에 삭제할 수도 있습니다.
$ this -> db ()-> dropSequence ( [ ' seq_id ' , ' seq_test ' ] );사용자 정의 메소드를 호출하거나 알려지지 않은 메소드 호출을 교리 테이블 객체에 전달합니다.
public function __call( string $ method , array $ args )$method 이름입니다$args 메소드 매개 변수예:
Upscheme 시퀀스 객체의 클래스 속성에 액세스 할 수있는 사용자 정의 메소드를 등록 할 수 있습니다.
Aimeos Upscheme Schema Sequence:: macro ( ' default ' , function () {
$ this -> start ( 1 )-> step ( 2 );
} );
$ sequence -> default ();사용 가능한 클래스 속성은 다음과 같습니다.
$this->db : upscheme db 객체
$this->sequence : 교리 시퀀스 스키마
주어진 시퀀스 옵션의 값을 반환합니다
public function __get( string $ name )$name 시퀀스 옵션 이름예:
$ value = $ sequence -> getInitialValue ();
// same as
$ value = $ sequence -> start ();주어진 시퀀스 옵션의 새 값을 설정합니다
public function __set( string $ name , $ value )$name 시퀀스 옵션 이름예:
$ value = $ sequence -> setInitialValue ( 1000 );
// same as
$ value = $ sequence -> start ( 1000 );시퀀스의 캐시 크기를 설정하거나 현재 값을 반환합니다.
public function cache( int $ value = null )$value 클라이언트가 캐시하거나 현재 값을 반환하기 위해 새로운 시퀀스 ids ids예:
$ value = $ sequence -> cache ();
$ sequence -> cache ( 100 );시퀀스의 이름을 반환합니다
public function name() $ name = $ sequence -> name ();시퀀스의 새 시작 값을 설정하거나 현재 값을 반환합니다.
public function start( int $ value = null )$value 시퀀스 또는 null의 새로운 시작 값을 반환합니다. $ value = $ sequence -> start ();
$ sequence -> start ( 1000 );새로운 시퀀스 값의 단계 크기를 설정하거나 현재 값을 반환합니다.
public function step( int $ value = null )$value 새 단계 크기 순서가 증가하거나 감소하여 현재 값을 반환하기 위해 널 감소합니다. $ value = $ sequence -> step ();
$ sequence -> step ( 2 );데이터베이스 스키마에 변경 사항을 적용합니다
public function up() : self $ sequence -> up ();인덱스는 데이터베이스 쿼리 속도를 높이고 쿼리 요구가 올바르게 사용되면 몇 분에서 밀리 초까지 떨어질 수 있습니다. 사용 가능한 몇 가지 인덱스 유형이 있습니다.
모든 인덱스는 하나 이상의 열로 구성 될 수 있지만 인덱스가 쿼리에 사용되는 경우 열의 순서가 큰 영향을 미칩니다.
모든 인덱스는 인덱스 커버 열이 포함 된 테이블에 바인딩됩니다. 단일 열을 통해 인덱스를 만드는 가장 간단한 방법은 열 객체의 index() 메소드를 사용하는 것입니다.
$ this -> db ()-> table ( ' test ' , function ( $ table ) {
$ table -> string ( ' label ' )-> index ();
} ); index() 메소드의 두 번째 매개 변수를 사용하면 인덱스의 사용자 정의 이름을 설정할 수 있습니다.
$ this -> db ()-> table ( ' test ' , function ( $ table ) {
$ table -> string ( ' label ' )-> index ( ' idx_test_label ' );
} );참고 : 다른 데이터베이스 유형 간의 최대 호환성의 경우 인덱스 이름의 길이는 30 자 이하이어야합니다.
1 차, 고유 및 공간 지수에 대해서도 마찬가지입니다.
$ this -> db ()-> table ( ' test ' , function ( $ table ) {
// primary key
$ table -> int ( ' id ' )-> primary ();
$ table -> int ( ' id ' )-> primary ( ' pk_test_id ' ); // ignored by MySQL , MariaDB , etc .
// unique key
$ table -> string ( ' code ' )-> unique ();
$ table -> string ( ' code ' )-> unique ( ' unq_test_code ' );
// spatial index
$ table -> col ( ' location ' , ' point ' )-> spatial ();
$ table -> col ( ' location ' , ' point ' )-> spatial ( ' idx_test_location ' );
} ); 멀티 컬럼 인덱스의 경우 primary() , unique() 및 index() 메소드가 테이블 개체에서 사용할 수 있습니다.
$ this -> db ()-> table ( ' test ' , function ( $ table ) {
// primary composite index
$ table -> primary ( [ ' siteid ' , ' code ' ] );
// unique composite index
$ table -> unique ( [ ' parentid ' , ' type ' ] );
// regular composite index
$ table -> index ( [ ' label ' , ' status ' ] );
} ); 공간 인덱스는 여러 열에 걸쳐있을 수 없지만 테이블 개체의 spatial() 메소드를 사용하여 만들 수도 있습니다.
$ this -> db ()-> table ( ' test ' , function ( $ table ) {
$ table -> spatial ( ' location ' );
} ); 인덱스가 이미 존재하는지 확인하려면 hasIndex() 메소드를 사용하십시오.
if ( $ this -> db ()-> hasIndex ( ' users ' , ' idx_users_name ' ) ) {
// The "idx_users_name" index in the "users" table exists
} 한 번에 여러 인덱스를 확인할 수도 있습니다. 이 경우 hasIndex() 메소드는 모든 인덱스가 존재하는 경우에만 true를 반환합니다.
if ( $ this -> db ()-> hasIndex ( ' users ' , [ ' idx_users_name ' , ' idx_users_status ' ] ) ) {
// The "idx_users_name" and "idx_users_status" indexes in the "users" table exists
} 이미 테이블 객체가있는 경우 hasIndex() 도 사용할 수 있습니다.
if ( $ table -> hasIndex ( ' idx_users_name ' ) ) {
// The "idx_users_name" index in the table exists
}
if ( $ table -> hasIndex ( [ ' idx_users_name ' , ' idx_users_status ' ] ) ) {
// The "idx_users_name" and "idx_users_status" indexes in the table exists
} To rename indexes directly, using the renameIndex() method of the DB schema:
// single index
$ this -> db ()-> renameIndex ( ' testtable ' , ' idx_test_label ' , ' idx_test_name ' );
// multiple indexes
$ this -> db ()-> renameIndex ( ' testtable ' , [ ' idx_test_label ' => ' idx_test_name ' , ' idx_text_stat ' => ' idx_test_status ' ] ); If a table object is already available, you can use its renameIndex() method to rename one or more indexes:
$ this -> db ()-> table ( ' test ' , function ( $ table ) {
// single index
$ table -> renameIndex ( ' idx_test_label ' , ' idx_test_name ' );
// multiple indexes
$ table -> renameIndex ( [ ' idx_test_label ' => ' idx_test_name ' , ' idx_text_stat ' => ' idx_test_status ' ] );
} );In all cases, indexes are only renamed if they exist. No error is reported if one or more indexes doesn't exist in the table.
To drop indexes, use the dropIndex() method from the DB schema object:
$ this -> db ()-> dropIndex ( ' users ' , ' idx_test_name ' );You can drop several indexes at once if you pass the name of all indexes you want to drop as array:
$ this -> db ()-> dropIndex ( ' users ' , [ ' idx_test_name ' , ' idx_test_status ' ] ); If you already have a table object, you can use dropIndex() too:
$ this -> db ()-> table ( ' test ' , function ( $ table ) {
// single index
$ table -> dropIndex ( ' idx_test_name ' );
// multiple indexes
$ table -> dropIndex ( [ ' idx_test_name ' , ' idx_test_status ' ] );
} );In all cases, indexes are only removed if they exist. No error is reported if one or more indexes doesn't exist in the table.
It's not necessary to pass a custom index name when creating new indexes. Then, the index name is generated automatically but their name will consist of a hash that is hard to read. Also, you don't know which columns the indexes span from the index name.
Upscheme allows you to add your own naming function for indexes which is used if not index name is passed to the methods for creating indexes. Before running the migrations, register your nameing function using the macro() method in the table objects:
use Aimeos Upscheme Schema Table ;
Table:: marco ( ' nameIndex ' , function ( string $ table , array $ columns , string $ type ) {
return $ type . ' _ ' . $ table . ' _ ' . join ( ' _ ' , $ columns );
} );
Aimeos Upscheme Up:: use ( $ config , ' ./migrations/ ' )-> up ()For a table "testtable", a column "label" and the type "idx", this will return idx_testtable_label instead of a hash.
Available index types are:
Note: For compatibility to all supported database types, the maximum length of the index names must be not longer than 30 characters!
You can add new methods to all Upscheme objects using the macro() method. Each custom method has access to the class properties and methods of the class it's registered for including the Doctrine DBAL objects.
To register a method named test() in the DB schema object with two parameters $arg1 and $arg2 which has access to the same class properties as the DB __call() method use:
Aimeos Upscheme Schema DB :: marco ( ' test ' , function ( $ arg1 , $ arg2 ) {
// $ this - >conn : Doctrine connection
// $this - >from : Doctrine start schema
// $this - >to : Doctrine current schema
// $ this - >up : Upscheme object
// return $this or a value
} );
$ db -> test ( ' key ' , ' value ' ); Registering a method test() in the Table schema object with one parameter $arg1 which has access to the same class properties as the Table __call() method use:
Aimeos Upscheme Schema Table:: marco ( ' test ' , function ( $ arg1 ) {
// $this - >db : Upscheme DB object
// $this - >table : Doctrine Table object
// return $this or a value
} );
$ table -> test ( ' something ' ); Same for a method test() in the Column schema object with an optional parameter $value which has access to the same class properties as the Column __call() method use:
Aimeos Upscheme Schema Column:: marco ( ' test ' , function ( $ value = null ) {
// $this - >db : Upscheme DB object
// $this - >table : Upscheme Table object
// $this - >column : Doctrine Column object
// return $this or a value
} );
$ column -> test (); To extend the Foreign object for foreign key constraints with a test() method with no parameter having access to the same class properties as the Foreign __call() method use:
Aimeos Upscheme Schema Foreign:: marco ( ' test ' , function () {
// $this - >table : Upscheme Table object
// $this - >dbaltable : Doctrine Table object
// $this - >localcol : Array of local column names
// $this - >fktable : Foreign table name
// $ this - >fkcol : Foreign table column names
// $this - >name : Foreign key name
// $ this - >opts : Array of foreign key options ( "onDelete" and "onUpdate")
// return $this or a value
} );
$ foreign -> test (); Finally, extending the Sequence object with a test() method having no parameters and access to the same class properties as the Sequence __call() method use:
Aimeos Upscheme Schema Sequence:: marco ( ' test ' , function () {
// $this - >db : Upscheme DB object
// $this - >sequence : Doctrine Sequence object
// return $this or a value
} );
$ sequence -> test (); Instead of calling the col() method of the Table object with all parameters and modifiers each time, you can create your own shortcut methods, eg:
Aimeos Upscheme Schema Table:: marco ( ' utinyint ' , function ( string $ name ) {
return $ this -> col ( $ name , ' tinyint ' )-> unsigned ( true );
} );It's also possible to create several columns at once if you want to add them to several tables:
Aimeos Upscheme Schema Table:: marco ( ' defaults ' , function () {
$ this -> id ();
$ this -> datetime ( ' ctime ' );
$ this -> datetime ( ' mtime ' );
$ this -> string ( ' editor ' );
return $ this ;
} );Then, use your custom methods when creating or updating tables:
$ this -> db ()-> table ( ' test ' , function ( $ table ) {
$ table -> defaults ();
$ table -> utinyint ( ' status ' );
} );Version 0.9+ supports Doctrine DBAL 3.x/4.x and dropped support for Doctrine DBAL 2.x.
DB::type() returns mariadb instead of mysql for MariaDDB databaseDB::type() returns sqlserver instead of mssql for Microsoft SQLServer databaseDB::for() , DB::view() and Column::opt require ['mariadb', 'mysql'] to get the same resultsDB::lastId() doesn't require/support passing a sequence name because Doctrine DBAL removed it but doesn't support Oracle IDENTITY columns at the moment
