Download the PHP package corneltek/lazyrecord without Composer
On this page you can find all versions of the php package corneltek/lazyrecord. It is possible to download/install these versions without Composer. Possible dependencies are resolved automatically.
Download corneltek/lazyrecord
More information about corneltek/lazyrecord
Files in corneltek/lazyrecord
Package lazyrecord
Short Description The Fast PHP ORM
License MIT
Homepage https://github.com/c9s/LazyRecord
Informations about the package lazyrecord
LazyRecord
LazyRecord is an open-source Object-Relational Mapping (ORM) for PHP5.
LazyRecord uses code generator to generate static code, which reduces runtime costs, therefore it's pretty lightweight and fast.
It allows you to access your database very easily by using ActiveRecord pattern API.
LazyRecord is not like PropelORM, it doesn't use ugly XML as its schema or config file, LazyRecord uses simpler YAML format config file and it compiles YAML to pure PHP code to improve the performance of config loading.
With the simple schema design, you can define your model schema very easily and you can even embed closure in your schema classes.
See also
Automatic Migration Demonstration
Feature
- Fast & Simple
- Configuration based on YAML format and compiled into PHP
- PDO, MySQL, Pgsql, SQLite support.
- Multiple data sources.
- Mix-in model.
- Powerful Migration Generator
- Upgrade & Downgrade of course.
- Automatic Migration: generate migration SQL automatically based on the schema diff.
- Schema/Database diff
Design Concept
-
Function calls in PHP are very slow, so the model schema data will be built statically, LazyRecord converts all definitions (default value, validator, filter, valid value builder) into classes and static PHP array, this keeps these model classes very lightweight and fast.
-
In the runtime, all the same model objects use the same schema object, and we can reuse the prebuild data from the static schema class.
- We keep base model class constructor empty, so when you are querying data from database, these model objects can be created with zero effort.
Installation
Please see the details on Wiki
Getting Started
Configuring Database
Change directory to your project, run init
command to initialize
your database settings.
If you prefer something new, you can require "dev-master"
Then create your config file:
Suppose your application code is located in src/
directory,
then you should provide your schema path in following format:
In the above config file, the auto_id
means an id column with auto-increment
integer primary key is automatically inserted into every schema class, so you
don't need to declare an primary key id column in your every schema file.
Writing Model Schema
Next, write your model schema file:
Put the content into your file:
Building Static Schema Files
Then run build-schema
command to build static schema files:
Creating Database
If you are using postgresql or mysql, you can create your database with
create-db
command:
Building SQL From Model Schemas
Now you need to build SQL schema into your database, simply run build-sql
,
-d
is for debug mode, which prints all generated SQL statements:
Writing Application Code
Now you can write your application code, But first you need to write your lazyrecord config loader code:
The init
method initializes data sources to ConnectionManager, but it won't
create connection unless you need to operate your models.
Sample Code Of Operating The User Model Object
Now append your application code to the end of app.php
file:
Please check doc/
directory for more details.
Basic Usage
Model Accessor
LazyRecord's BaseModel class provides a simple way to retrieve result data from the __get
magic method,
by using the magic method, you can retrieve the column value and objects from relationship.
The __get
method is dispatching to get
method, if you don't want to use the magic method,
The magic method calls value inflator, which can help you inflate values like DateTime objects, it might be slower, if you want performance, you can simply do:
BaseModel also supports iterating, so you can iterate the data values with foreach:
Model Operation
To create a model record:
To find record:
To find record with (static):
To find record with primary key:
To update record:
To update record (static):
Collection
To create a collection object:
To make a query (the Query syntax is powered by SQLBuilder):
Or you can do:
Iterating a Collection
Model Schema
Defining Schema Class
Simply extend class from LazyRecord\Schema
, and define your model columns
in the schema
method, e.g.,
Defining Column Types
Text:
Boolean:
Integer:
Timestamp:
Datetime:
Defining Mixin Method
Then you can use the fooMethod
on your model object:
Defining Model Relationship
Belongs to
belongsTo(accessor_name, foreign_schema_class_name, foreign_schema_column_name, self_column_name = 'id')
Has One
one(accessor_name, self_column_name, foreign_schema_class_name, foreign_schema_column_name)
Has Many
many(accessor_name, foreign_schema_class_name, foreign_schema_column_name, self_column_name )
To define many to many relationship:
Usage:
Do Some Preparation When Model Is Ready
If you want to do something after the schmea is created into a database, you can define a
bootstrap
method in your schema class:
The bootstrap method is triggerd when you run:
lazy sql
Using Multiple Data Source
You can define specific data source for different model in the model schema:
Or you can specify for both (read and write):
Defining BaseData Seed
The basedata seed script is executed after you run build-sql
, which means
all of your tables are ready in the database.
To define a basedata seed script:
Then update your config file by adding the class name of the data seed class:
Migration
If you need to modify schema code, like adding new columns to a table, you can use the amazing migration feature to migrate your database to the latest change without pain.
Once you modified the schema code, you can execute lazy diff
command to compare
current exisiting database table:
$ lazy diff
+ table 'authors' tests/tests/Author.php
+ table 'addresses' tests/tests/Address.php
+ table 'author_books' tests/tests/AuthorBook.php
+ table 'books' tests/tests/Book.php
+ table 'users' tests/tests/User.php
+ table 'publishers' tests/tests/Publisher.php
+ table 'names' tests/tests/Name.php
+ table 'wines' tests/tests/Wine.php
As you can see, we added a lot of new tables (schemas), and LazyRecord parses the database tables to show you the difference to let you know current status.
Currently LazyRecord supports SQLite, PostgreSQL, MySQL table parsing.
now you can generate the migration script or upgrade database schema directly.
to upgrade database schema directly, you can simply run:
$ lazy migrate auto
to upgrade database schema through a customizable migration script, you can generate a new migration script like:
$ lazy migrate diff AddUserRoleColumn
Loading schema objects...
Creating migration script from diff
Found 10 schemas to compare.
Found schema 'TestApp\AuthorSchema' to be imported to 'authors'
Found schema 'TestApp\AddressSchema' to be imported to 'addresses'
Found schema 'TestApp\AuthorBookSchema' to be imported to 'author_books'
Found schema 'TestApp\BookSchema' to be imported to 'books'
Found schema 'TestApp\UserSchema' to be imported to 'users'
Found schema 'TestApp\PublisherSchema' to be imported to 'publishers'
Found schema 'TestApp\NameSchema' to be imported to 'names'
Found schema 'TestApp\Wine' to be imported to 'wines'
Migration script is generated: db/migrations/20120912_AddUserRoleColumn.php
now you can edit your migration script, which is auto-generated:
vim db/migrations/20120912_AddUserRoleColumn.php
the migration script looks like:
The built-in migration generator not only generates the upgrade script, but also generates the downgrade script, you can modify it to anything as you want.
After the migration script is generated, you can check the status of current database and waiting migration scripts:
$ lazy migrate status
Found 1 migration script to be executed.
- AddUserColumn_1347451491
now you can run upgrade command to upgrade database schema through the migration script:
$ lazy migrate up
If you regret, you can run downgrade migrations through the command:
$ lazy migrate down
But please note that SQLite doesn't support column renaming and column dropping.
To see what migration script could do, please check the documentation of SQLBuilder package.
Mix-In Schema
...
Collection Filter
The Built-in Collection Filter provide a powerful feature that helps you connect the backend collection filtering with your front-end UI by defining filter types, valid values from backend:
The generated SQL statement is like below:
Basedata Seed
Setting up QueryDriver for SQL syntax
A More Advanced Model Schema
Documentation
For the detailed content, please take a look at the doc/
directory.
Contribution
Everybody can contribute to LazyRecord. You can just fork it, and send Pull Requests.
You have to follow PSR Coding Standards and provides unit tests as much as possible.
Hacking
Setting Up Environment
Use Composer to install the dependency:
composer install --prefer-source
To deploy a testing environment, you need to install dependent packages.
Run script and make sure everything is fine:
php bin/lazy
Database configuration is written in phpunit.xml
file, the
following steps are based on the default configuration. you may also take a look at .travis.yml
for example.
Unit Testing with MySQL database
To test with mysql database:
mysql -uroot -p
Enter the SQL to initialize a database:
create database testing charset utf8;
create user 'testing'@'localhost';
grant all privileges on testing.* to 'testing'@'localhost';
--- if you want password
grant all privileges on testing.* to 'testing'@'localhost' identified by 'testing';
--- if you want to remove password for root user
SET PASSWORD FOR root@localhost=PASSWORD('');
--- for mysql 5.7, you should run
SET PASSWORD FOR root@localhost='';
Unit Testing with PostgreSQL database
To test with pgsql database, you need to prepare database:
sudo -u postgres createdb -E=utf8 testing
If you want to use a separated user, use the command below to create the pgsql user:
sudo -u postgres createuser --no-createrole --no-superuser --no-password testing
sudo -u postgres createdb -E=utf8 --owner=testing testing
If you've set password accidentally, remove user password by running the command below:
> alter role postgres password null;
To connect pgsql with PDO, you need to configure your DSN for postgresql through socket like this:
pgsql:host=localhost;dbname=testing
Command-line testing
To test sql builder from command-line, please copy the default testing config
$ cp db/config/database.testing.yml db/config/database.yml
Customize your phpunit.xml configuration:
$ cp phpunit.xml.dist phpunit.xml
Build config
$ php bin/lazy build-conf db/config/database.yml
Build Schema files
php bin/lazy schema build
We've already defined 3 data sources, they were named as 'mysql', 'pgsql', 'sqlite' , now you can insert schema sqls into these data sources:
bin/lazy sql --rebuild -D=mysql
bin/lazy sql --rebuild -D=pgsql
bin/lazy sql --rebuild -D=sqlite
Run PHPUnit
$ phpunit
Profiling
$ phpunit --group profile
Manipulating Schema Objects
To get the model class name from a schema:
To get the table name of a schema:
To iterate the column objects, you may call getColumns
, which returns the
column objects in an associative array:
PROFILING
$ scripts/run-xhprof
OR
$ phpunit -c phpunit-xhprof.xml
$ cd xhprof_html
$ php -S localhost:8888
LICENSE
BSD License
All versions of lazyrecord with dependencies
corneltek/sqlbuilder Version ^3.2
corneltek/cliframework Version ^3.0
corneltek/class-template Version ^3.0
corneltek/serializerkit Version ^1
corneltek/validationkit Version ^1
symfony/yaml Version ^2.8
doctrine/inflector Version ~1.0
corneltek/configkit Version ^1
corneltek/cascading-attribute Version ^1.2
pimple/pimple Version ^3.0
cypresslab/gitelephant Version ^1.0