imrgrgs/bioorm

BioOrm 是一个微型的 ORM，同时作为流畅的查询 API 和 CRUD 模型类。

维护者

详细信息

github.com/imrgrgs/bioorm

主页

源代码

问题

安装: 10

依赖项: 0

建议者: 0

安全: 0

星星: 1

观察者: 1

分支: 0

开放问题: 0

dev-master 2019-08-17 23:13 UTC

Requires

  • php: >=5.6

MIT de584af4b89b2fc557891c2b4b276b4a5bfa2fce

  • BitIO <development.woop@bitgroup.com.br>

ormphpmysqlsqlitepostgresqlpdofluent querybitioinforsolutionsbitgroup

This package is auto-updated.

Last update: 2024-09-18 10:39:08 UTC

README

一个简单的微型 ORM，不会干扰你的操作

名称：BioOrm

许可证：MIT

作者：imrgrgs

版本：3.x.x

要求：PHP >= 5.6, PDO

关于 BioOrm！

BioOrm 是一个微型的 ORM，同时作为流畅的查询 API 和 CRUD 模型类。

BioOrm 是基于 PDO 构建的，非常适合小型到中型项目，这些项目强调简单和快速开发，而不是无限灵活性和功能。BioOrm 与表关系轻松工作，并提供获取 SQL 的 API

特性

  • PDO 和预处理语句
  • 流畅查询
  • 关系
  • 连接
  • 聚合
  • 查询调试器和查询分析器
  • 活动记录模式

要求

  • PHP >= 5.5
  • PDO

错误报告

BioOrm 不会升级错误。不存在的表将产生 SQL 错误，由 PDO 根据 PDO::ATTR_ERRMODE 报告。不存在的列将产生与尝试访问数组中不存在的键相同的 E_NOTICE

它不做什么。

我们认为某些事情最好留给开发者去做，比如缓存或数据验证。此外，数据验证可以在数据库级别完成。

  • 没有模型或实体生成
  • 没有数据验证
  • 没有缓存
  • 没有数据库迁移

安装 BioOrm

您可以直接下载 BioOrm，或者与 Composer 一起下载。

要使用 composer 安装，请将以下内容添加到您的 composer.json 文件中的 require 键

"imrgrgs/bioorm": "3.*"

composer.json

{
    "name": "bit-io/myapp",
    "description": "My awesome Bio App",
    "require": {
        "imrgrgs/bioorm": "3.*"
    }
}

使用 BioOrm

new BioOrm( PDO $pdo )

要开始使用 BioOrm，您必须设置 PDO 连接。我们将使用变量 $DB 作为数据库连接，$users 作为本教程中的表，$friends 作为另一个表。

$pdo = new PDO("mysql:host=localhost;dbname=$dbname", $username, $password);
$pdo->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
$DB = new BioOrm($pdo);

BioOrm BioOrm::table( string $tablename )

要连接到表，可以通过调用方法 BioOrm::table() 来实现

$users = $DB->table('users');

您也可以通过调用表作为方法来设置表。上面的代码也可以写成这样

$users = $DB->users();
$friends = $DB->friends();

从那里，您将能够使用 BioOrm 流畅查询界面对表进行任何 CRUD 操作

##数据修改

BioOrm 支持数据修改（插入、更新和删除）。BioOrm 不执行数据验证，但所有数据库错误都通过标准的 PDO 错误报告报告。对于数据验证，我们认为在数据库级别或应用级别进行验证最好

mixed BioOrm::insert( Array $data )

要在表中插入数据，使用 insert(Array $data)，其中 $data 可以是一个一维数组以插入单个条目，或多个数组以进行批量插入。

如果插入了一行，它将返回创建的对象的激活记录。否则，它将返回插入的总条目数

对于单个条目

$user = $users->insert(array(
	 			"name" => "imrgrgs",
				"age" => 30, 
	 			"city" => "Charlotte",
     			"state" => "NC",
				"device" => "mobile",
	 			"timestamp" => $DB->NOW()
			));

返回此条目的 BioOrm 激活记录实例，您可以使用 $user->name 或 $user->city。我们稍后会做更多。

对于批量插入

$massInserts = $users->insert(array(
					array(
						 "name" => "imrgrgs",
						 "city" => "Charlotte",
					     "state" => "NC",
					     "device" => "mobile",
						 "timestamp" => $DB->NOW()
					),
					array(
						 "name" => "Cesar",
						 "city" => "Atlanta",
					     "state" => "GA",
						 "device" => "mobile",
						 "timestamp" => $DB->NOW()
					),
					array(
						 "name" => "Gaga",
						 "city" => "Port-au-Prince",
					     "state" => "HT",
						 "device" => "computer",
						 "timestamp" => $DB->NOW()
					),
				));

返回插入的总条目数

mixed BioOrm::update( Array $data)

在BioOrm中更新条目有两种方式，1）使用已获取行的活动记录模式，或2）使用where查询来指定更新位置。此外，可以使用BioOrm::set($key, $value)方法在更新之前设置数据。

对于单个条目

$user->update(array(
					"city" => "Raleigh"
				));

与以下相同

$user->city = "Raleigh";
$user->update();

也可以使用save()代替update()

$user->save();

或者使用BioOrm::set(Array $data) 或 BioOrm::set($key, $value)

$user->set('city','Raleigh')->update();

对于多个条目

对于多个条目，我们将使用BioOrm::set()和BioOrm::where()来指定更新位置。

BioOrm::set(Array $data) 或 BioOrm::set($key, $value)

对于批量更新，我们将使用set(Array $data)和where($k, $v)来设置要更新的数据。

$user->set(array(
				"country_code" => "US"
		))
		->where("device", "mobile")
		->update();

*在流畅查询接口下还有更多的where别名

mixed BioOrm::save()

Save()是BioOrm::insert()或BioOrm::update()的快捷方式

要插入新数据

$user = $DB->users();
$user->name = "imrgrgs";
$user->city = "Charlotte";
$user->save();

要更新

$user = $users->findOne(123456);
$user->city = "Atlanta";
$user->save();

int BioOrm::delete()

要删除条目，我们将使用BioOrm::delete()方法

对于单个条目，通过调用delete()方法，它将删除当前条目

$user = $users->reset()->findOne(1234);
$user->delete();

对于多个条目，我们将使用BioOrm::where()方法来指定删除位置

$users->where("city", "Charlotte")->delete();

聚合

BioOrm为您提供了对表中聚合方法的访问

int BioOrm::count()

根据where子句计算所有条目

$allUsers = $users->count();

$count = $voodorm->where($x, $y)->count();

或针对特定列名

$count = $users->where($x, $y)->count($columnName);

float BioOrm::max( string $columnName )

根据where子句获取$columnName的最大值

$max = $users->where($x, $y)->max($columnName);

float BioOrm::min( string $columnName )

根据where子句获取$columnName的最小值

$min = $users->where($x, $y)->min($columnName);

float BioOrm::sum( string $columnName )

根据where子句获取$columnName的总和

$sum = $users->where($x, $y)->sum($columnName);

float BioOrm::avg( string $columnName )

根据where子句获取$columnName的平均值

$avg = $users->where($x, $y)->avg($columnName);

mixed BioOrm::aggregate( string $function )

运行任何聚合函数

$agg = $users->where($x, $y)->aggregate('GROUP_CONCAT $columnName');

查询

BioOrm提供了一个流畅的接口，允许您在不写任何SQL字符的情况下构建简单的查询。

两种方法允许您获取单个条目或多个条目：findOne()和find()。还有fromArray()，它将原始数据加载到对象中。

FindOne

BioOrm BioOrm::findOne()

findOne()如果找到，则返回单个条目的BioOrm实例，否则返回FALSE。

$user = $users->where('id', 1234)
			  ->findOne();

可以在findOne(int $primaryKey)中设置主键，以获取与上述查询相同的结果。这意味着不需要where子句。

$user = $users->findOne(1234);

让我们获取找到的条目

if ($user) {
	echo " Hello $user->name!";

// On a retrieved entry you can perform update and delete
	$user->last_viewed = $users->NOW();
	$suer->save();
}

Find

ArrayIterator BioOrm::find()

find()返回找到的行的ArrayIterator，这些行是BioOrm的实例，否则返回False。

$allUsers = $users->where('gender', 'male')
				  ->find();

foreach ($allUsers as $user) {
	echo "{$user->name}";

// On a retrieved entry you can perform update and delete
	$user->last_viewed = $users->NOW();
	$user->save();
}

find()在迭代中调用时也包含一个快捷方式，例如在foreach中

$allUsers = $users->where('gender', 'male');

foreach ($allUsers as $user) {
	echo "{$user->name}";

// On a retrieved entry you can perform update and delete
	$user->last_viewed = $users->NOW();
	$suer->save();
}

mixed BioOrm::find( Closure $callback )

BioOrm::find()还接受一个闭包作为回调来执行自己的数据处理。执行时，BioOrm将查询中找到的数据传递给闭包函数。

	$users->where('gender', 'male');

	$results = $users->find(function($data){
		$newResults = array();

		foreach ($data as $d) {
			$d["full_name"] = ucwords("{$data["first_name"]} {$data["last_name"]}");
			$newResults[] = $d;
		}

		return $newResults;
	});

FromArray

BioOrm BioOrm::fromArray( Array $data )

与find()和findOne()不同，它们会查询数据库以检索数据，fromArray()加载原始数据并将其作为BioOrm对象返回。它可以是缓存到Redis/Memcached中的数据，但不是直接来自数据库的数据。

$data = [
		"id" => 916,
		"name" => "Jose",
		"last_name" => "Martinez"
		];

$anotherUser = $users->fromArray($data);

现在您可以对其进行操作

$anotherUse->update(
					["name" => "Yolo"]
				);

流畅查询构建器

Select

BioOrm BioOrm::select( $columns = '*' )

用于选择表中的字段。如果省略，BioOrm将获取所有列。

$users->select()

或者使用选定的列

$users->select("name, age")
		->select("last_viewed");

> SELECT name, age, last_viewed

Where

Where 允许您为查询设置 WHERE 子句。下面您将找到许多 where 的别名。

Where 子句与 BioOrm::find()、BioOrm::findOne()、BioOrm::update() 和 BioOrm::delete() 一起工作。

重复调用 where 或任何 where 的别名将使用 AND 运算符将 WHERE 子句附加到前面的 WHERE 子句。要使用 OR 运算符，您必须调用 BioOrm::_or()。更多内容见下文。

BioOrm BioOrm::where( $condition $parameters = array() )

这是主要的 where。它负责所有 WHERE 子句。

$condition 是要使用的条件。它可以包含 ? 或 :name，这些由 PDO 绑定到 $parameters（因此不需要手动转义）。

$parameters 是要绑定到条件的值。它可以是一个数组、一个关联数组或零个或多个标量。

一些示例

$users->where("name", "imrgrgs");
WHERE name = ?

$users->where("age > ?", 25);
WHERE age > ?

$users->where("name in (?, ?, ?)", "Mike", "Jones", "Rich");
WHERE name IN (?, ?, ?)

$users->where("(field1, field2)", array(array(1, 2), array(3, 4)))
WHERE (field1, field2) IN ((?, ?), (?, ?))

但是为了方便任务，BioOrm 包含一些常见操作的别名

BioOrm BioOrm::wherePK( int $primaryKey )

当设置主键时 $users->wherePK(1234);

BioOrm BioOrm::whereNot( $columnName, $value )

$users->whereNot('age', 24);

WHERE age != ?

BioOrm BioOrm::whereLike( $columnName, $value )

$users->whereLike('name', 'w%');

WHERE name LIKE ?

BioOrm BioOrm::whereNotLike( $columnName, $value )

$users->whereNotLike('name', 'r%');

WHERE name NOT LIKE ?

BioOrm BioOrm::whereGt( $columnName, $value )

$users->whereGt('age', 21);

WHERE age > ?

BioOrm BioOrm::whereGte( $columnName, $value )

$users->whereGte('age', 21);

WHERE age >= ?

BioOrm BioOrm::whereLt( $columnName, $value )

$users->whereLt('age', 21);

WHERE age < ?

BioOrm BioOrm::whereLte( $columnName, $value )

$users->whereLte('age', 21);

WHERE age <= ?

BioOrm BioOrm::whereIn( $columnName, Array $value )

$users->whereIn('city', array('Charlotte', 'Atlanta'));

WHERE city IN (?,?)

BioOrm BioOrm::whereNotIn( $columnName, Array $value )

$users->whereNotIn('city', array('Chicago', 'Miami'));

WHERE city NOT IN (?,?)

BioOrm BioOrm::whereNull( $columnName )

$users->whereNull('city');

WHERE city IS NULL

BioOrm BioOrm::whereNotNull( $columnName )

$users->whereNotNull('name');

WHERE city NOT NULL

使用 OR 和 AND 的 WHERE

在构建查询时，您希望在 WHERE 子句中添加 AND 和 OR 运算符。为此，请使用与任何 where 别名链式连接的 BioOrm::_and() 和 BioOrm::_or()。

BioOrm BioOrm::_and()

在 WHERE 查询中添加 AND 运算符。默认情况下，如果未调用 _and()，BioOrm 将默认添加。

$users->where("city", "Charlotte")->_and()->whereGte("age", 21);

WHERE city = ? AND age >= ?

BioOrm BioOrm::_or()

在 WHERE 查询中添加 OR 运算符。

$users->where("city", "Charlotte")->_or()->whereGte("age", 21)->_or()->where("gender", "female");

WHERE city = ? OR age >= ? OR gender = ?

使用 Wrap() 的 WHERE

当构建包含多个 WHERE 组的复杂查询时，BioOrm::wrap() 将 WHERE 子句组合在一起，用括号括起来。

BioOrm BioOrm::wrap()

$users->where("city", "Charlotte")->whereGte("age", 21)->wrap()
	  ->where("gender", "female")->where("city", "Atlanta");

WHERE (city = ? AND age >= ?) AND (gender = ? AND city = ?)

BioOrm BioOrm::wrap()->_and()

wrap()->_and() 使用 AND 运算符与另一个分组 WHERE 进行联合。

$users->where("city", "Charlotte")->whereGte("age", 21)->wrap()->_and()
	  ->where("gender", "female")->where("city", "Atlanta");

WHERE (city = ? AND age >= ?) AND (gender = ? AND city = ?)

BioOrm BioOrm::wrap()->_or()

wrap()->_or() 使用 OR 运算符与另一个分组 WHERE 进行联合。

$users->where("city", "Charlotte")->whereGte("age", 21)->wrap()->_or()
	  ->where("gender", "female")->where("city", "Atlanta");

WHERE (city = ? AND age >= ?) OR (gender = ? AND city = ?)

在同一个查询中使用 wrap()->_and() 和 wrap()->_or()

$users->where("id",1)->where("city","charlotte")->wrap()
      ->where("gender","female")->where("country","US")->wrap()
      ->_or()->where("city",array("Charlotte","Atlanta"))->wrap()
      ->_or()->whereLt('age',21)->whereGte("name","imrgrgs")->wrap();

WHERE (id = ? AND city = ?) 
	  AND (gender = ? AND country = ?) 
      OR ((city IN (?, ?))) 
      OR (age < ? AND name >= ?)

排序、分组、限制、偏移量

BioOrm BioOrm::orderBy( $columnName, $ordering )

$users->orderBy('name', 'DESC');

ORDER BY name DESC

BioOrm BioOrm::groupBy( $columnName )

$users->groupBy('city');

GROUP BY city

BioOrm BioOrm::limit( int $limit )

$users->limit(10);

LIMIT 10

BioOrm BioOrm::offset( int $offset )

$users->offset(10);

OFFSET 10

连接

BioOrm BioOrm::join( $tablename, $constraint, $table_alias , $join_operator )

$users->join('friends', 'f.user_id = u.id', 'f')

JOIN friends AS f ON f.user_id = u.id

BioOrm BioOrm::leftJoin( $tablename, $constraint, $table_alias )

$users->leftJoin('friends', 'f.user_id = u.id', 'f')

LEFT JOIN friends AS f ON f.user_id = u.id

关系

这就是杀手锏！

BioOrm 的杀手级功能之一是关系。通过将表作为对象上的方法调用，默认情况下在引用表上创建一对一关系。

在这个例子中，我们将有两个表：user（id, name, dob）和friend（id, user_id, friend_id）。

friend.user_id是user表的外键。而friend.friend_id是朋友的user.id的外键。

让我们获取所有用户及其朋友

$allUsers = $users->find();

foreach ($allUsers as $user) {
    /**
    * Connect to the 'friend' table = $user->friend();
    * In the back, it does a ONE To MANY relationship 
    * SELECT * FROM friend WHERE friend.user_id = user.id 
    */
    $allFriends = $user->friend();
    foreach ($allFriends as $friend) {
        echo "{$friend->friend_id} : ";

        /**
        * We got the friend's entry, we want to go back in the user table
        * So we link back the friend table to the user table
        * SELECT * FROM user WHERE user.id = friend.friend_id LIMIT 1 
        * It will do a ONE to One relationship
        */
        echo $friend->user(["relationship" => biorm\BioOrm::HAS_ONE, 
                            "localKey" => "friend_id"
                            "foreignKey" => "id"])->name;

        echo "\n";
    }
}

// Same as above but with just one user
$user = $users->findOne($userId);
if($user) {

    foreach ($user->friend() as $friend) {

        echo "{$friend->friend_id} : ";

        echo $friend->user(biorm\BioOrm::REL_HASONE, "friend_id")->name;

        echo "\n";
    }
}

这就是整体情况。在一个对象上调用参考表作为方法将执行关系。

关系：一对一

一对一关系在用户和朋友的例子中，意味着一个用户可以有一个或多个朋友。但每个friend.friend_id都与一个user.id相关联。此类关系将返回一个或多个条目。

user（单值）和friend（多值）之间的关系是一对多关系。

在上面的例子中，我们在朋友的表中执行了一对多关系

$allFriends = $user->friend();

关系常量

BioOrm预先定义了常量，允许您选择执行一种关系类型

CONST::HAS_MANY (2)

$allFriends = $user->friend(["relationship" => biorm\BioOrm::HAS_MANY]);

这更快。它通过获取所有数据并将其保存在内存中来执行预加载。它只执行一个查询。默认情况下使用。

关系：一对一

一对一关系在两个方向上都是单值的。在朋友的表中，friend.friend_id与user.id相关联

$allFriends = $user->friend();

关系常量

CONST::HAS_ONE (1)

$friendUser = $friend->user(biorm\Core\BioOrm::REL_HASONE, "friend_id");
echo $friendUser->name;

它通过获取所有数据并将其保存在内存中来执行预加载。它只执行一个查询。默认情况下使用。

CONST::REL_LAZYONE (-1)

$friendUser = $friend->user(biorm\BioOrm::REL_LAZYONE, "friend_id");
echo $friendUser->name;

这更慢。它通过在请求时获取数据来进行懒加载。它将执行1+N个查询。

关系：多对多

尚未实现。这很复杂……找不到一个适合所有情况的案例...

关系参数

BioOrm关系接受4种类型的参数，可以放在任何地方

$user->friend(NUMBER, STRING, ARRAY, CALLBACK);

数字：通常是关系常量 REL_HASONE = 1，REL_LAZYONE = -1，RE_HASMANY = 2，REL_LAZYMANY = -2;

$user->friend(biorm\BioOrm::REL_HASMANY);

字符串：将字符串作为参数使用时，将用作外键名称

$user->friend("friend_id");

数组：数组将用作WHERE条件。数组必须是与表字段匹配的键/值匹配

$user->friend(array(
	"friendship_start_time >= " => date("Y-m-d")
));

回调：回调是一个在结果上运行的函数

$user->friend(function($data){

	$tableData = array();

	foreach($data as $d) {
		$tableData[] = array_merge(
							$data,
							array("visits_count"=>$d[visits_count] + 1)
						); 
	}
	return $tableData;
});

现在进行拼凑！

$user->friend(biorm\BioOrm::REL_HASONE, 

				"friend_id", 

				array("friendship_start_time >= " => date("Y-m-d"),

				function($data){
				
						$tableData = array();
				
						foreach($data as $d) {
							$tableData[] = array_merge(
												$data,
												array("visits_count"=>$d[visits_count] + 1)
											); 
						}
						return $tableData;
					}			
));



$user->friend(NUMBER, STRING, ARRAY, CALLBACK);

表结构

表结构允许在数据库中定义表结构。它在构造函数上设置

new BioOrm($PDO, $primaryKey = 'id', $foreignKey = '%s_id')

PRIMARYKEY：默认设置为id，但可以是任何内容

FOREIGNKEY：是外键。默认情况下设置为%s_id，其中%s是表名。所以一个用户表，在朋友表中，外键将是user_id

您也可以使用setStructure($primaryKey, $foreignKey)来设置结构。

$DB = new BioOrm($PDO);
$DB->setStructure("id", "%s_id");

设置表结构很重要，这样BioOrm可以识别关系的唯一键和外键。

其他方法

以下代码

$users = $DB->table('users');

string BioOrm::getPrimaryKeyName()

$users->getPrimaryKeyName();

返回主键名称。大多数情况下将是id

string BioOrm::getForeignKeyName()

$users->getForeignKeyName();

返回外键名称。根据上面的表结构，它将是user_id

string BioOrm::getTableName()

返回表名

$tableName = $users->getTableName();

BioOrm BioOrm::tableAlias( string $alias )

将名称设置为表的别名

$users->tableAlias("user");

string BioOrm::getTableAlias()

返回表别名名称

$alias = $users->getTableAlias();

Array BioOrm::getStructure()

返回设置的架构

$structure = $users->getStructure();

Bool BioOrm::isSingleRow()

判断一个条目是否为单行返回true或false

$user = $users->findOne(123);

if ($user->isSingleRow()) {
	// do something here
}

String BioOrm::NOW()

它返回当前日期时间：Y-M-D H:i:s

将BioOrm扩展到您的模型中

以下是一个示例，说明如何在现实世界的应用程序中使用BioOrm设置模型。我们将设置模型，并使用MVC应用程序中的控制器检索它们。该应用程序基于Voodoo，这是一个精简的模块化MVC框架。

Lib/Model/BaseModel.php

基本模型包含对数据库的连接，可以添加额外的方法。BaseModel将在模型类中扩展

<?php

namespace Model;

use biorm;

abstract class BaseModel extends biorm\BioOrm
{
	private static $pdo = null;

	// setup the DB connection
	public function __construct()
	{
		if (! self::$pdo) {
			self::$pdo = new PDO("mysql:host=localhost;dbname=$dbname", $username, $password);
		    self::$pdo->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);				
		}

		parent::__construct(self::$pdo);
        $instance = parent::table($this->tableName);
        $this->table_name = $instance->getTablename();			
	}
}

Lib/Model/Diskoteka/Artist.php

<?php

namespace Model\Diskoteka;

use Lib\Model;

class Artist extends Model\BaseModel
{
	protected $tableName = "artist";

	// We concat the first and last name
	public function getName()
	{
		return $this->first_name." ".$this->last_name; 
	}
}

Lib/Model/Diskoteka/Album.php

<?php

namespace Model\Diskoteka;

use Lib\Model;

class Album extends Model\BaseModel
{
	protected $tableName = "album";

	// Returns the BioOrm object to do more in the query
	public function getSongs()
	{
		return (new Song)->where("album_id", $this->getPK());
	}
}

Lib/Model/Diskoteka/Song.php

<?php

namespace Model\Diskoteka;

use Lib\Model,
	Closure;

class Song extends Model\BaseModel
{
	protected $tableName = "song";

	public function getArtistName()
	{
		return $this->artist_first_name;
	}

	public function getAlbumTitle()
	{
		return $this->album_title;
	}

	// We modify the find() to join this table to album and artist tables
	public function find(Closure $callback = null) 
	{
		$this->tableAlias("song")
			->select("song.*")
			->select("album.title As album_title")
			->select("artist.first_name AS artist_first_name")
			->leftJoin(new Artist, "artist.id = song.artist_id", "artist")
			->leftJoin(new Album, "album.id = song.album_id", "album");

		retun parent::find($callback);
	}
}

App/Www/Main/Controller/Index.php

使用Voodoo，我们将创建一个控制器来使用这些模型

<?php

namespace App\Www\Main\Controller;

use Voodoo,
	Lib\Model\Diskoteka;

class Index extends Voodoo\Core\Controller
{
	/**
	 * List all songs, which will include the the artist name and album name
	 * http://the-url/
	 */
	public function actionIndex()
	{
		$allSongs = (new Diskoteka\Song);
		$allSongs->orderBy("title", "ASC");

		$songs = [];
		foreach ($allSongs as $song) {
			$songs[] = [
				"id" => $song->getPK()
				"title" => $song->title,
				"albumTitle" => $song->getAlbumTitle(),
				"artistName" => $song->getArtistName()
			];				
		}
		$this->view()->assign("songs", $songs);
	}

	/**
	 * Simply get the Artist info
	 * http://the-url/artist/59
	 */
	public function actionArtist()
	{
		$id = $this->getSegment(1); // -> 59
		$artist = (new Diskoteka\Artist)->findOne($id);	
		$countAlbums = (new Diskoteka\Album)
									->where("artist_id", $id)
									->count();

		$this->view()->assign([
			"name" => $artist->getName(),
			"countAlbums" => $countAlbums
		]);	
	}


	/**
	 * Get the song info, with album basic info
	 * http://the-url/song/1637
	 */
	public function actionSong()
	{
		$id = $this->getSegment(1); // -> 1637
		$song = (new Diskoteka\Song)->findOne($id);

		if ($song) {
			$this->view()->assign([
				"id" => $song->getPK()
				"title" => $song->title,
				"albumTitle" => $song->getAlbumTitle(),
				"artistName" => $song->getArtistName()
			]);
		}
	}

	/**
	 * Get the album info including all songs
	 * http://your-url.com/album/437
	 */
	public function actionAlbum()
	{
		$id = $this->getSegment(1);
		$album = (new Diskoteka\Album)->findOne($id);
		
		$allSongs = $album->getSongs();
		$albumSongs = [];
		foreach ($allSongs as $song) {
			$albumSongs[] = [
				"id" => $song->getPK(),
				"title" => $song->title
			];
		}
		$this->view()->assign([
			"album" => [
				"id" => $album->getPK(),
				"title" => $album->title
			],
			"songs" => $albumSongs
		]);
	}

}

贡献者

感谢您对BioOrm感兴趣。

如果您想做出贡献，请发起一个pull request。

BioOrm严格遵守PSR-2

(c) 今年imrgrgs :)