Download the PHP package cradlephp/storm without Composer

Storm

A Search Collection Model Kind of SQL Client

• Install
• Introduction
• Basic Querying
• Data Manipulation
• Searching
• Model
• Collection
• Putting it Together
• Contributing

Install

composer install cradlephp/storm

Introduction

Welcome to Storm, a different kind of ORM. Complete functionality from low level queries to Search, Collections and Models. Designed for novices and enthusiasts alike.

Figure 1. Usage

This pattern allows Storm to work easier with other ORM platforms. SqlFactory will make a determination of what database class to use. Currently MySQL, MariaDB, PostGreSQL and SQLite are supported (Create an issue if you would like to see another SQL type database supported).

Basic Querying

On a very low level can call raw queries as in Figure 2.

Figure 2. Raw Query

It's recommended you bind incoming variables contributed by the end user. Still on a low level, this can be acheived as in Figure 3.

Figure 3. Raw Binding

The above figure sets $query to a string with bound place holders :user_name and :user_active. $bind has the actual values these placeholders and should be replaced with during execution of the query. We encourage this method because binding values prevents database injections.

Note: Bound variables must start with a colon(:).

Data Manipulation

If you prefer the wrapper way to save data Figure 4 provides several method examples on how to achieve this.

Figure 4. Data Manipulation

Inserting data is pretty trivial. We included 2 ways to insert data. Like getRow(), there's no need to worry about bound data because Storm will do this for you. Figure 4 shows the 2 kind of inserts mentioned.

Figure 4. Two ways to insert

So obviously insertRow() should be used if you just want to insert one row. Inserting two or more rows at the same time, you should use insertRows(). This method expects an array of arrays, or an array table.

Note: A common error is using insertRows() instead of insertRow().

Note: Using models and collections, you don't really need to worry about this method because it's covered in the save() method in a collection or model object. We'll go over models and collections later in this section.

Updating is about as easy as inserting. There's only one method you need to know.

Figure 5. Updating

A common scenario is when you need to insert if a column value is not found and update if it is. We added an extra method called setRow() to simply to save you some lines of redundancy.

Figure 6. Insert or update

Figure 6 basically says, in user table, if [email protected] exists in the user_email column, then update that row. If not then insert. Removing data is simple enough as well.

Figure 7. Remove

Searching

A better way to build complex queries is with using the search object. An overview example can be found in Figure 8.

Figure 8. MySQL Search

In the figure above there's a few methods being powered with magic, but we'll just start going down the line. First off, to instantiate the search object you simply need to call search() passing the name of the table as the argument. Secondly we call setColumns(). This call is optional, but if used, can either accept an array of columns or an argument separated list of columns, ie. setColumns('user_id', 'user_name'). Next, innerJoinOn() is the new way we accept joins. There are eight methods dedicated to different kinds of joins.

Kinds of Join methods

No matter what methods you choose from above there are two arguments you need to add. The first argument is the name of the table you would like to join and the second one is the how they relate to each other.

The first magic powered method is called filterByUserName(). There is no actual method called filterByUserName() in the library. Instead when this function is called it will parse out the name of the method and recognize that UserName is the name of a column and convert that into addFilter('user_name=%s', 'Chris') as in Figure 8.

addFilter() generally accepts two arguments. The first argument is the filter clause. If you notice in our filter example in Figure 8 we use %s to delimit a binded value. You can have as many bound values per filter as you like. The following arguments need to include the bound values in order of when they occur in the filter clause.

The second magic powered method is called sortByUserId('ASC').There is no actual method called sortByUserId('ASC') in the library. Instead when this function is called it will parse out the name of the method and recognize that UserId is the name of a column and convert that into addSort('user_id', 'ASC') as in Figure 8.

There are three kinds of pagination methods also available

Pagination Methods

It's important if you are going to use setPage(1) to call setRange(75) first because the underlying function simply calculates the start index based on the range. Two other methods that are not covered by Figure 8 are the ability to group and to set the table to something else.

Figure 9. Other Useful methods

Getting Results

When your happy with your query you can retrieve the results in 3 ways as described in Figure 0.

Figure 10. Retrieving Results

Figure 10 shows three ways to get the results, the first way getTotal(), will retrieve the total number and does not consider pagination elements. getRows() will simply return a raw array. getCollection() will return you an object with the results for further manipulation.

Collections

Collections do exactly the same thing as models except it manipulates multiple models instead. Collections can be iterable and access as arrays as well. Collections only hold model objects so if you wanted to use your own extended model, you would need to call setModel('Your_Model').

Figure 11. MySQL Collections

Some other utility methods not covered by the above examples are date formatting and copying from one column to another. Figure 12, show how we would go about doing these things.

Figure 12. Utility methods

Models

We managed to loosely define models which takes off the restrictiveness of a normal ORM and adds scalability as an end result. First off, what we did was define a generic, yet powerful model class that can be extended, but also can be used as is. Our model class is already powerful enough to solve for a lot of use cases, you might not need to extend it. We played around with the concept of "loosely defined" and here's what we came up with.

Figure 13. Database Model (Extends Array)

So model properties can be accessed by method, object or array. The preference we leave up to you. With our model, you can put extra key values in the object, even if it has nothing to do with the intended database table. When you call save(), this is when you need to specify the table your saving to. This method is really powerful, in that it will first check to see what columns exist in the table then compares it with your model. It will only save columns that have the matching column name in your object. Lastly it will auto determine whether if we should insert or update that row.

A common example is when you have an array table that comprises of joined data. You can leave that array as is then call save() for each table as in Figure 14.

Figure 14. Two tables

Note: You can also save to different databases as in save('post', $db2)

Putting it all together

So a common scenario would be retrieving data, manipulating the results and sending back to the database. Let's see with search, collection and model objects how we can achieve this.

Figure 15. The Coolest Thing Ever!