public function createColumn(&$column) { $c = new Column(); $c->inflected_name = Inflector::instance()->variablize($column['field']); $c->name = $column['field']; $c->nullable = $column['null'] === 'YES' ? true : false; $c->pk = $column['key'] === 'PRI' ? true : false; $c->auto_increment = $column['extra'] === 'auto_increment' ? true : false; if ($column['type'] == 'timestamp' || $column['type'] == 'datetime') { $c->raw_type = 'datetime'; $c->length = 19; } elseif ($column['type'] == 'date') { $c->raw_type = 'date'; $c->length = 10; } elseif ($column['type'] == 'time') { $c->raw_type = 'time'; $c->length = 8; } else { \preg_match('/^([A-Za-z0-9_]+)(\\(([0-9]+(,[0-9]+)?)\\))?/', $column['type'], $matches); $c->raw_type = \count($matches) > 0 ? $matches[1] : $column['type']; if (\count($matches) >= 4) { $c->length = \intval($matches[3]); } } $c->mapRawType(); $c->default = $c->cast($column['default'], $this); return $c; }
public function create_column($column) { $column['column_name'] = strtolower($column['column_name']); $column['data_type'] = strtolower(preg_replace('/\\(.*?\\)/', '', $column['data_type'])); if ($column['data_default'] !== null) { $column['data_default'] = trim($column['data_default'], "' "); } if ($column['data_type'] == 'number') { if ($column['data_scale'] > 0) { $column['data_type'] = 'decimal'; } elseif ($column['data_scale'] == 0) { $column['data_type'] = 'int'; } } $c = new Column(); $c->inflected_name = Inflector::instance()->variablize($column['column_name']); $c->name = $column['column_name']; $c->nullable = $column['nullable'] == 'Y' ? true : false; $c->pk = $column['pk'] == 'P' ? true : false; $c->length = $column['data_length']; if ($column['data_type'] == 'timestamp') { $c->raw_type = 'datetime'; } else { $c->raw_type = $column['data_type']; } $c->map_raw_type(); $c->default = $c->cast($column['data_default']); return $c; }
public function create_column($column) { $c = new Column(); $c->inflected_name = Inflector::instance()->variablize($column['name']); $c->name = $column['name']; $c->nullable = $column['notnull'] ? false : true; $c->pk = $column['pk'] ? true : false; $c->auto_increment = $column['type'] == 'INTEGER' && $c->pk; $column['type'] = preg_replace('/ +/', ' ', $column['type']); $column['type'] = str_replace(array('(', ')'), ' ', $column['type']); $column['type'] = Utils::squeeze(' ', $column['type']); $matches = explode(' ', $column['type']); if (!empty($matches)) { $c->raw_type = strtolower($matches[0]); if (count($matches) > 1) { $c->length = intval($matches[1]); } } $c->map_raw_type(); if ($c->type == Column::DATETIME) { $c->length = 19; } elseif ($c->type == Column::DATE) { $c->length = 10; } // From SQLite3 docs: The value is a signed integer, stored in 1, 2, 3, 4, 6, // or 8 bytes depending on the magnitude of the value. // so is it ok to assume it's possible an int can always go up to 8 bytes? if ($c->type == Column::INTEGER && !$c->length) { $c->length = 8; } $c->default = $c->cast($column['dflt_value'], $this); return $c; }
public function createColumn(&$column) { $c = new Column(); $c->inflected_name = Inflector::instance()->variablize($column['field']); $c->name = $column['field']; $c->nullable = $column['not_nullable'] ? false : true; $c->pk = $column['pk'] ? true : false; $c->auto_increment = false; if (\substr($column['type'], 0, 9) == 'timestamp') { $c->raw_type = 'datetime'; $c->length = 19; } elseif ($column['type'] == 'date') { $c->raw_type = 'date'; $c->length = 10; } else { \preg_match('/^([A-Za-z0-9_]+)(\\(([0-9]+(,[0-9]+)?)\\))?/', $column['type'], $matches); $c->raw_type = \count($matches) > 0 ? $matches[1] : $column['type']; $c->length = \count($matches) >= 4 ? \intval($matches[3]) : \intval($column['attlen']); if ($c->length < 0) { $c->length = null; } } $c->mapRawType(); if ($column['default']) { \preg_match("/^nextval\\('(.*)'\\)\$/", $column['default'], $matches); if (\count($matches) == 2) { $c->sequence = $matches[1]; } else { $c->default = $c->cast($column['default'], $this); } } return $c; }
public function __construct($source, $dest, $options = null) { $this->source_class = get_class($source); if (isset($options['class_name'])) { $this->dest_class = $options['class_name']; } else { $this->dest_class = \Inflector::classify($dest); } if (isset($options['foreign_key'])) { $this->foreign_key = $options['foreign_key']; } else { $this->foreign_key = \Inflector::foreign_key($this->source_class); } if ( ! class_exists($this->dest_class)) { $this->dest_class = '\\Model\\'.$this->dest_class; } if ( ! class_exists($this->source_class)) { $this->source_class = '\\Model\\'.$this->source_class; } $this->options = $options; }
public function join() { $dest_table = \Inflector::tableize($this->dest_class); $source_table = \Inflector::tableize($this->source_class); $dest_inst = new $this->dest_class(); $columns = $dest_inst->get_columns(); $join = array('table' => $dest_table, 'type' => 'LEFT OUTER', 'on' => array($source_table . '.' . $this->foreign_key, '=', $dest_table . '.' . $dest_inst->get_primary_key())); return array(array($dest_table => $columns), $join); }
/** * Initializes the cache. * * With the $options array it's possible to define: * - expiration of the key, (time in seconds) * - a namespace for the key * * this last one is useful in the case two applications use * a shared key/store (for instance a shared Memcached db) * * Ex: * $cfg_ar = ActiveRecord\Config::instance(); * $cfg_ar->set_cache('memcache://localhost:11211',array('namespace' => 'my_cool_app', * 'expire' => 120 * )); * * In the example above all the keys expire after 120 seconds, and the * all get a postfix 'my_cool_app'. * * (Note: expiring needs to be implemented in your cache store.) * * @param string $url URL to your cache server * @param array $options Specify additional options */ public static function initialize($url, $options = array()) { if ($url) { $url = parse_url($url); $file = ucwords(Inflector::instance()->camelize($url['scheme'])); $class = "ActiveRecord\\{$file}"; require_once __DIR__ . "/cache/{$file}.php"; static::$adapter = new $class($url); } else { static::$adapter = null; } static::$options = array_merge(array('expire' => 30, 'namespace' => ''), $options); }
/** * Runs the validators. * @return Errors the validation errors if any */ public function validate() { $reflection = Reflections::instance()->get(get_class($this->model)); // create array of validators to use from valid functions merged with the static properties $this->validators = array_intersect(array_keys($reflection->getStaticProperties()), self::$VALIDATION_FUNCTIONS); if (empty($this->validators)) { return $this->record; } $inflector = Inflector::instance(); foreach ($this->validators as $validate) { $func = $inflector->variablize($validate); $this->{$func}($reflection->getStaticPropertyValue($validate)); } return $this->record; }
public function load(Model $model) { $keys = []; $inflector = Inflector::instance(); foreach ($this->foreign_key as $key) { $keys[] = $inflector->variablize($key); } if (!($conditions = $this->createConditionsFromKeys($model, $this->primary_key, $keys))) { return null; } $options = $this->unsetNonFinderOptions($this->options); $options['conditions'] = $conditions; $class = $this->class_name; return $class::first($options); }
public function create_column(&$column) { $c = new Column(); $c->inflected_name = Inflector::instance()->variablize($column['field']); $c->name = $column['field']; $c->nullable = $column['nullable'] === 'YES' ? true : false; $c->auto_increment = $column['extra'] === '1' ? true : false; $c->pk = $column['pk'] === 'PRIMARY KEY' ? true : false; $c->raw_type = $column['data_type']; $c->length = $column['length'] ? $column['length'] : $column['radix']; if ($c->raw_type == 'text') { $c->length = null; } if ($c->raw_type == 'datetime') { $c->length = 19; } $c->map_raw_type(); $c->default = $c->cast(preg_replace("#\\(+'?(.*?)'?\\)+#", '$1', $column['data_default']), $this); return $c; }
public function __construct($source, $dest, $options = null) { $this->source_class = get_class($source); if (isset($options['class_name'])) { $this->dest_class = $options['class_name']; } else { $this->dest_class = \Inflector::classify($dest); } if (isset($options['foreign_key'])) { $this->foreign_key = $options['foreign_key']; } else { $this->foreign_key = \Inflector::foreign_key($this->source_class); } $namespace = (\Request::active() ? ucfirst(\Request::active()->module) : '') . '\\'; if (class_exists($dest = $namespace . 'Model_' . $this->dest_class)) { $this->dest_class = $dest; } if (!class_exists($this->source_class)) { $this->source_class = 'Model_' . $this->source_class; } $this->options = $options; }
/** * Get an array containing the key and value of the foreign key for the association * * @param Model $model * @access private * @return array */ private function getForeignKeyForNewAssociation(Model $model) { $this->setKeys($model); $primary_key = Inflector::instance()->variablize($this->foreign_key[0]); return [$primary_key => $model->id]; }
/** * Issue an INSERT sql statement for this model's attribute. * * @see save * @param boolean $validate Set to true or false depending on if you want the validators to run or not * @return boolean True if the model was saved to the database otherwise false */ private function insert($validate = true) { $this->verify_not_readonly('insert'); if ($validate && !$this->_validate()) { return false; } $table = static::table(); $this->invoke_callback('before_create', false); if ($dirty = $this->dirty_attributes()) { $table->insert($dirty); } else { $table->insert($this->attributes); } $this->invoke_callback('after_create', false); $pk = $this->get_primary_key(false); // if we've got an autoincrementing pk set it if (count($pk) == 1 && $table->columns[$pk[0]]->auto_increment) { $inflector = Inflector::instance(); $this->attributes[$inflector->variablize($pk[0])] = $table->conn->insert_id($table->sequence); } $this->__new_record = false; return true; }
public static function human_attribute($attr) { $inflector = Inflector::instance(); $inflected = $inflector->variablize($attr); $normal = $inflector->uncamelize($inflected); return ucfirst(str_replace('_', ' ', $normal)); }
public function classify($class_name, $singularize = false) { if ($singularize) { $class_name = Utils::singularize($class_name); } $class_name = Inflector::instance()->camelize($class_name); return \ucfirst($class_name); }
/** * Generate a "slug" from the given string * * @param string $string The string to generate a slug from * @access public * @return string */ public function generateSlug($string) { $slug = Inflector::instance()->underscorify($string); return strtoupper($slug); }
private function set_table_name() { if (($table = $this->class->getStaticPropertyValue('table', null)) || ($table = $this->class->getStaticPropertyValue('table_name', null))) { $this->table = $table; } else { // infer table name from the class name $this->table = Inflector::instance()->tableize($this->class->getName()); // strip namespaces from the table name if any $parts = explode('\\', $this->table); $this->table = $parts[count($parts) - 1]; } if (($db = $this->class->getStaticPropertyValue('db', null)) || ($db = $this->class->getStaticPropertyValue('db_name', null))) { $this->db_name = $db; } }
public function join() { $dest_table = \Inflector::tableize($this->dest_class); $source_table = \Inflector::tableize($this->source_class); $source_inst = new $this->source_class(); $dest_inst = new $this->dest_class(); $columns = $dest_inst->get_columns(); if (isset($dest_inst->table_name)) { $dest_table = $dest_inst->table_name; } if (!isset($this->options['through']) || !$this->options['through']) { $join = array('table' => $dest_table, 'type' => 'LEFT OUTER', 'on' => array($dest_table . '.' . $this->foreign_key, '=', $source_table . '.' . $source_inst->get_primary_key())); } else { $through_foreign_key = array_key_exists('through_foreign_key', $this->options) ? $this->options['through_foreign_key'] : \Inflector::foreign_key($this->dest_class); $join = array(array('table' => $this->options['through'], 'type' => 'LEFT OUTER', 'on' => array($this->options['through'] . '.' . $this->foreign_key, '=', $source_table . '.' . $source_inst->get_primary_key())), array('table' => $dest_table, 'type' => 'LEFT OUTER', 'on' => array($dest_table . '.' . $dest_inst->get_primary_key(), '=', $this->options['through'] . '.' . $through_foreign_key))); } return array(array($dest_table => $columns), $join); }
/** * Eagerly loads relationships for $models. * * This method takes an array of models, collects PK or FK (whichever is needed for relationship), then queries * the related table by PK/FK and attaches the array of returned relationships to the appropriately named relationship on * $models. * * @param Table $table * @param $models array of model objects * @param $attributes array of attributes from $models * @param $includes array of eager load directives * @param $query_keys -> key(s) to be queried for on included/related table * @param $model_values_keys -> key(s)/value(s) to be used in query from model which is including * @return void */ protected function queryAndAttachRelatedModelsEagerly(Table $table, $models, $attributes, $includes = [], $query_keys = [], $model_values_keys = []) { $values = []; $options = $this->options; $inflector = Inflector::instance(); $query_key = $query_keys[0]; $model_values_key = $model_values_keys[0]; // foreach ($attributes as $column => $value) original foreach ($attributes as $value) { $values[] = $value[$inflector->variablize($model_values_key)]; } $values = [$values]; $conditions = SQLBuilder::createConditionsFromUnderscoredString($table->conn, $query_key, $values); if (isset($options['conditions']) && \strlen($options['conditions'][0]) > 1) { $utils->addCondition($options['conditions'], $conditions); } else { $options['conditions'] = $conditions; } if (!empty($includes)) { $options['include'] = $includes; } if (!empty($options['through'])) { // save old keys as we will be reseting them below for inner join convenience $pk = $this->primary_key; $fk = $this->foreign_key; $this->setKeys($this->getTable()->class->getName(), true); if (!isset($options['class_name'])) { $class = classify($options['through'], true); if (isset($this->options['namespace']) && !\class_exists($class)) { $class = $this->options['namespace'] . '\\' . $class; } $through_table = $class::table(); } else { $class = $options['class_name']; $relation = $class::table()->getRelationship($options['through']); $through_table = $relation->getTable(); } $options['joins'] = $this->constructInnerJoinSql($through_table, true); $query_key = $this->primary_key[0]; // reset keys $this->primary_key = $pk; $this->foreign_key = $fk; } $options = $this->unsetNonFinderOptions($options); $class = $this->class_name; $related_models = $class::find('all', $options); $used_models = []; $model_values_key = $inflector->variablize($model_values_key); $query_key = $inflector->variablize($query_key); foreach ($models as $model) { $matches = 0; $key_to_match = $model->{$model_values_key}; foreach ($related_models as $related) { if ($related->{$query_key} == $key_to_match) { $hash = \spl_object_hash($related); if (\in_array($hash, $used_models)) { $model->setRelationshipFromEagerLoad(clone $related, $this->attribute_name); } else { $model->setRelationshipFromEagerLoad($related, $this->attribute_name); } $used_models[] = $hash; $matches++; } } if (0 === $matches) { $model->setRelationshipFromEagerLoad(null, $this->attribute_name); } } }
/** * Set an attribute of the object * * @see \ActiveRecord\Model::__set() * @param string $name * @param mixed $value The value of the field * @return mixed */ public function __set($name, $value) { // Camelize the name $camelized_name = Inflector::instance()->camelize($name); // Check for setter if (method_exists($this, "set_{$name}")) { $name = "set_{$name}"; return $this->{$name}($value); } elseif (method_exists($this, "set{$camelized_name}")) { $name = "set{$camelized_name}"; return $this->{$name}($value); } // Otherwise, just use our parent's magic setter return parent::__set($name, $value); }
public function setUp() { $this->inflector = Inflector::instance(); }
private function set_table_name() { if (($table = $this->class->getStaticPropertyValue('table', null)) || ($table = $this->class->getStaticPropertyValue('table_name', null))) { $this->table = $table; } else { // infer table name from the class name $this->table = Inflector::instance()->tableize($this->class->getName()); } if (($db = $this->class->getStaticPropertyValue('db', null)) || ($db = $this->class->getStaticPropertyValue('db_name', null))) { $this->db_name = $db; } }