> Generally relationships like the one you describe are stored in three
> separate and related tables: Students, Courses, and Enrollment. The
> latter is a n:m association between the first two. The advantage this
> approach has with regard to storage is that it is a sparse matrix.

I've done that and I'm playing around with the last one, this is where the
problem arise. It's a table with two columns, user id & the 'set' that
stores the enroll information. Since SQL doesn't have 'nice set data type'
(MySQL has it but it's restricted to 64 entries, and it's difficult to use),
I need to cover the problem from PHP side.

> Most students will only enroll in a handful of courses. With this
> approach, you only store a row in the Enrollment table if a student is
> enrolled in a course. Otherwise, you don't need to store anything.

Do you mean that, for example, if student A enrolls course x,y,z the table
would be:

user_id | course
    A    |    x
    A    |    y
    A    |    z

Students often forget (or are lazy) to unenroll after they've finished
studying. Wouldn't the database be bloated? And what would be the primary

> And no, 1.2MB is not that big of a deal. A single floppy high-density
> drive could hold that much data 18 years ago!

Yeah, but now I'm also considering the speed. So, I decided to build a class
that implements bitset operations and I'm gonna store the contents in
database as string. Here's the code: 

class bitset {
  private $bits;

  private function index($bit) { return $bit / 32; }
  private function offset($bit) { return $bit % 32; }

  private function binstr() {
    $temp_bits = $this->bits;
    $str = "";
    for ($i=0;$i<32;$i++) {
      $str = strval($temp_bits & 1) . $str;
      $temp_bits >>= 1;
    return $str;

  public function __construct() {
    $this->bits = array(0,0,0,0,0,0,0,0);

  public function tostring() {
    $str = $this->binstr($this->bits[0]);
    for ($i=1;$i<8;$i++)
      $str .= "," . $this->binstr($this->bits[$i]);
    return $str;

  public function set($bit) {
    $index  = $this->index($bit);
    $offset = $this->offset($bit);
    $this->bits[$index] |= 1 << $offset;

  public function clear($bit) {
    $index  = $this->index($bit);
    $offset = $this->offset($bit);
    $this->bits[$index] &= ~(1 << $offset);

  public function test($bit) {
    $index  = $this->index($bit);
    $offset = $this->offset($bit);
    return $this->bits[$index] & (1 << $offset);

little problem: tostring() method always returns 00..001,00..001,..
regardless $bits contents. binstr() has been tested and works fine, what
might be wrong?

View this message in context: 
Sent from the PHP - General mailing list archive at Nabble.com.

PHP General Mailing List (http://www.php.net/)
To unsubscribe, visit: http://www.php.net/unsub.php

Reply via email to