Download the PHP package sanovskiy/simple-object without Composer

SimpleObject 7.x Library Documentation

Introduction

SimpleObject is a PHP library designed to simplify working with database records by providing an intuitive and easy-to-use interface.

Installation

You can install SimpleObject via Composer:

Database Connection Configuration

Before you can start using SimpleObject, you need to configure connections to your database. This involves specifying the database driver, host, user credentials, database name, and other relevant settings. SimpleObject supports MySQL, PostgreSQL, and MSSQL database drivers.

Adding a Connection

You can add a database connection using the ConnectionManager class along with a ConnectionConfig object. Below is an example of how to add a MySQL database connection:

Explanation of Configuration Parameters

• driver: Specifies the database driver (e.g., 'mysql', 'pgsql', 'mssql').
• host: Specifies the host of the database server.
• user: Specifies the username for connecting to the database.
• password: Specifies the password for connecting to the database.
• database: Specifies the name of the database.
• charset: Specifies the character set for the connection.
• port: Specifies the port number (optional).
• path_models: Specifies the path where generated models will be stored.
• models_namespace: Specifies the namespace for the generated models.
• sub_folders_rules: Specifies rules for organizing models into subfolders based on table prefixes (optional).
• base_class_extends: Specifies a custom parent class for generated models. Note that this class must extend ActiveRecordAbstract. (optional).
• read_connection: Specifies a separate read-only connection (not in use so far).
• write_connection: Specifies a separate write-only connection (not in use so far).

Subfolder Rules Configuration

The sub_folders_rules configuration option allows you to organize generated models into subfolders based on table prefixes. This can be useful for structuring your models in a more logical and organized manner, especially in projects with a large number of database tables.

Adding Subfolder Rules

You can specify subfolder rules using an associative array where the keys are table prefixes and the values are arrays containing the folder name and a flag indicating whether to strip the prefix from the model class names.

Example:

In this example:

• Tables with the prefix 'acl_' will have their models stored in the 'Acl' subfolder.
• Tables with the prefix 'shop_' will have their models stored in the 'Shop' subfolder.
• If strip is set to true, the prefix will be removed from the model class names. Otherwise, the prefix will be retained.

Usage Notes

• Subfolder rules are optional, and you can define them according to your project's specific requirements.
• This feature is particularly useful for projects with a large number of tables or where tables can be logically grouped based on their prefixes.
• Ensure that the folder structure specified in the rules matches your project's namespace conventions and organization preferences.

Models Generation

After adding connections and whenever there are changes in the database structure, or during the initial setup of your project, you need to call the reverseEngineerModels() method of the ModelsGenerator class to generate models based on existing database tables.

Ignoring Auto-generated Files

Since the Base folder contains auto-generated code, it's recommended to add it to your project's .gitignore file to avoid versioning generated files unnecessarily.

Example

Suppose you have tables named acl_user, acl_role, shop_product, and shop_order. Using the subfolder rules from the example above would result in the following folder structure:

This organization helps maintain a clear and organized structure within your project's models directory.

This service method is typically executed during project deployment or after modifications to the database structure. If your code is running in normal operation and the models have already been generated, there's no need to call this method.

This will create models corresponding to your database tables, making them ready for use with SimpleObject.

Model properties naming and table primary keys

All models and model properties are named in CamelCase by splitting table name or column by underscores. I.e: field model_id become property ModelId. Column SomeLongFieldName become Somelongfieldname. Limitation: Table PK should be named id to ensure full compatibility with SimpleObject.

Usage

SimpleObject supports basic CRUD operations (Create, Read, Update, Delete) for interacting with database records.

SimpleObject allows you to interact with database records using object-oriented models. Here's a basic example of how to use SimpleObject:

Model names and their properties precisely mirror the names of corresponding database objects but are converted to CamelCase. However, accessing properties by their corresponding database field names is permissible. Although this won't result in an error, these properties are not explicitly defined in the base class as @property and hence may not be recognized by IDEs.

Filter Class Documentation

The Filter class within the SimpleObject library is responsible for constructing SQL queries based on specified conditions. It allows users to filter database records effectively. Below is a detailed explanation of its functionality and the format of the filter array used to construct queries.

Filter Array Format

The filter array passed to the constructor follows a specific format to define conditions for filtering records. Each element of the array corresponds to a filter condition.

The top-level of the filter list is always combined using 'AND' logic.

• Key-Value Pairs:
  • Key: Represents the column name in the database table or an instruction.
  • Value:
    • For simple equality comparison: A scalar value.
    • For comparison with specified operator: An array with two elements: the comparison operator and the value.
    • For logical AND or OR groups: An array containing nested filter conditions.
    • For the order by clause: An array with the column name and the sort direction ('ASC' or 'DESC').
    • For the limit clause: An array containing the limit value (and optionally, the offset value).
    • For the group by clause: A string representing the column name.

Example Usage

• In this example, the filter array defines conditions to retrieve active users from either the USA with an age of 18 or older or from Japan with an age of 21 or older. The results are ordered by the creation date in descending order, and only 5 records are fetched, starting from the 10th record.
• The Filter class constructs the SQL query and retrieves the bind values, which can then be used in executing the query.

You typically do not need to directly instantiate the Filter class. Instead, you can pass a filter array to the static methods ::find(array $filterArray), ::one(array $filterArray), or ::getCount(array $filterArray) of the relevant model class."

Automatic Data Transformation in SimpleObject Library

The SimpleObject Library provides a mechanism for automatic data transformation, which ensures validation and conversion of data when reading from and writing to a database. Below is detailed information about this functionality.

Goal

The goal of automatic data transformation is to validate and convert data from the database format to a format convenient for working in PHP, and vice versa. This includes converting date strings to DateTime class objects, as well as other data types such as numbers, strings, and JSON.

Built-in Data Types

The SimpleObject Library provides built-in transformers for various data types:

• BooleanTransformer: Converts values to booleans.
• DateTimeTransformer: Converts date strings to DateTime class objects.
• EnumTransformer: Converts ENUM values to corresponding PHP values.
• FloatTransformer: Converts values to floats.
• IntegerTransformer: Converts values to integers.
• JsonTransformer: Converts JSON strings to PHP arrays or objects.
• UUIDTransformer: Converts UUIDs to the appropriate format.

Usage

You can add your own custom transformers and bind them to models using the setDataTransformRule() method of the model class. For example:

If a field already has a transformer, it will be overwritten by the new one.

Transformer methods are automatically called when reading from the database or writing to it, ensuring automatic data conversion.

Examples

Example of using the built-in DateTimeTransformer in a base model:

This code binds the DateTimeTransformer transformer to the created_at and updated_at fields, allowing automatic conversion of date values when reading and writing to the database.

Advantages

• Ensures data validation when reading from and writing to the database.
• Allows conversion of data to a convenient format for working in PHP.
• Provides flexible configuration for binding custom transformers to model fields.

Limitations

• Transformers must be properly configured to meet the requirements of your application.
• Additional settings may be required to handle special cases of data transformation.
• Try to avoid adding excessive logic to the methods of your custom transformers, as they are invoked every time data is read from or written to the database.

Automatic Relationships between Models

Automatic relationships between models in the SimpleObject library are limited to one-to-many and one-to-one relationships. If a table has a defined foreign key, it will be processed during model generation, and corresponding methods will be created.

One-to-Many Relationship

In a one-to-many relationship, if a table has a foreign key pointing to another table, the SimpleObject library automatically generates a method in the referencing model to retrieve related records.

For example, consider tables person and shop_order, where shop_order has a foreign key person_id referencing person(id). In the base model Person, the library automatically generates a method:

This method retrieves all shop orders associated with the person. You can optionally pass filters to narrow down the result set.

One-to-One Relationship

Similarly, in a one-to-one relationship, if a table has a foreign key pointing to another table, the SimpleObject library generates a method in the referenced model to retrieve the associated record.

Continuing with the example of tables person and shop_order, suppose shop_order has a foreign key person_id referencing person(id). In the base model ShopOrder, the library automatically generates a method:

This method retrieves the associated person for the shop order.

Usage

These automatically generated methods provide convenient access to related records without the need for manual coding. You can use them to streamline your database queries and simplify your application logic.

Note

These automatic relationships are based on foreign key constraints defined in the database schema. Ensure that your database schema accurately reflects the intended relationships between tables for the SimpleObject library to generate these methods correctly.

Caching with Runtime Cache

SimpleObject supports caching models data using runtime cache. This means that data is stored only during script execution and is not preserved between different requests to the application.

Caching Implementation

Examples of the load, save, and delete methods in the ActiveRecordAbstract class demonstrate caching when performing data operations. Here's how it works:

Method load: When loading a record from the database, the existence of the record in the cache is checked first. If the record already exists in the cache, it is retrieved from there, and no database query is executed. If the record is not found in the cache or a forced load is required ($forceLoad = true), then a database query is executed to load the record, and the retrieved data is cached for subsequent use.

Method save: When saving a record to the database, the data is also stored in the cache. If the record already exists in the database, its data is updated in both the database and the cache. If the record is inserted into the database for the first time, its data is also added to the cache.

Method delete: When deleting a record from the database, it is also removed from the cache.

Example Usage of Caching

Important Note

• Caching with runtime cache in SimpleObject provides efficient cache management to enhance your application's performance.
• Applying caching is recommended for data operations that are frequently performed and can be cached for reuse.

Contributing

We welcome contributions to SimpleObject! If you find any issues or have suggestions for improvements, please feel free to open an issue or submit a pull request on GitHub.

Thanks

Special thanks to ChatGPT for help with routine tasks.

License

SimpleObject is distributed under the MIT License with Custom Conditions. See the LICENSE file for more information.

Directory structure