Hier ein kleiner Spickzettel, wie sich die Doubletten wieder entfernen lassen.

Die Struktur der Testtabelle sieht folgendermaßen aus:

CREATE TABLE `sqltest`.`duplicates` (
  `id` INT(11) UNSIGNED NOT NULL AUTO_INCREMENT,
  `a` VARCHAR(10) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL,
  `b` INT(11) NOT NULL ,
  `c` DATETIME NOT NULL ,
PRIMARY KEY (`id`)
) ENGINE = InnoDB CHARACTER SET utf8 COLLATE utf8_general_ci;

Noch ein paar Daten rein und fertig ist die Spielwiese.

mysql> select * from duplicates;
+----+--------+-----+---------------------+
| id | a      | b   | c                   |
+----+--------+-----+---------------------+
|  1 | Apfel  | 123 | 2011-01-11 17:00:00 |
|  2 | Apfel  | 123 | 2011-01-11 17:00:00 |
|  3 | Banane | 234 | 2011-01-12 17:00:00 |
|  4 | Banane | 234 | 2011-01-12 17:00:00 |
|  5 | Birne  | 456 | 2011-01-15 17:00:00 |
|  6 | Birne  | 456 | 2011-01-15 17:00:00 |
+----+--------+-----+---------------------+
6 rows in set (0.00 sec)

Die erste Abfrage macht einen JOIN auf sich selbst, dafür die Aliasse d1 und d2 und dient zunächst der Prüfung, ob wir die gewünschten Datensätze geliefert bekommen.

SELECT d1.* FROM duplicates d1, duplicates d2
 WHERE d1.id != d2.id
   AND d1.a = d2.a
   AND d1.b = d2.b
   AND d1.c = d2.c
   AND d1.id < d2.id

Das Ergebnis:

+----+--------+-----+---------------------+
| id | a      | b   | c                   |
+----+--------+-----+---------------------+
|  1 | Apfel  | 123 | 2011-01-11 17:00:00 |
|  3 | Banane | 234 | 2011-01-12 17:00:00 |
|  5 | Birne  | 456 | 2011-01-15 17:00:00 |
+----+--------+-----+---------------------+
3 rows in set (0.00 sec)

MySQL kann offensichtlich keine Daten löschen, wenn die Löschaktion auf derselben Tabelle wie die Subquery gemacht wird. Darum schreiben wir die Ids in eine temporäre Tabelle.

CREATE TABLE duplicates_ids AS (
  SELECT d2.id FROM duplicates d1, duplicates d2
   WHERE d1.id != d2.id
     AND d1.a = d2.a
     AND d1.b = d2.b
     AND d1.c = d2.c
     AND d1.id < d2.id
)

Im letzten Schritt löschen wir die zuvor ausgewählten Datensätze und auch die temporäre Tabelle. Je nachdem was wir behalten wollen, noch ggf. ein “NOT” vor das “IN” schreiben.

DELETE FROM duplicates WHERE id [NOT] IN (SELECT * FROM duplicates_ids);
DROP TABLE duplicates_ids;

Achtung! Ich hafte nicht bei Datenverlust oder sonstigen Fehlern. Ein Backup sollte sicherheitshalber vorher gemacht werden.

CREATE TABLE `mails` (
  `id` int(11) NOT NULL auto_increment,
  `parent_id` int(11) NOT NULL,
  `addy` varchar(255) NOT NULL,
  PRIMARY KEY (`id`)
) ENGINE=MyISAM DEFAULT CHARSET=utf8

Jede Emailadresse hat eine Id und eine ParentId. Sind beide Ids identisch, dann ist es die Originaladresse, ansonsten ein Alias.

mysql> select * from mails;
+----+-----------+------------------+
| id | parent_id | addy             |
+----+-----------+------------------+
|  1 |         1 | m1@example.com   |
|  2 |         1 | a1m1@example.com |
|  3 |         3 | m2@example.com   |
|  4 |         1 | a2m1@example.com |
|  5 |         3 | a1m2@example.com |
+----+-----------+------------------+
5 rows in set (0.00 sec)

Mit einem selbstreferenzierenden Join werden die Daten nun wieder aus der Tabelle ausgelesen. Dabei wird die Tabelle ‘mails’ durch Aliasnamen wie zwei Tabellen behandelt. Wir selektieren die ‘addy’ aus der Tabelle ‘m1′ und die gejointen Aliase aus ‘m2′. Durch GROUP_CONCAT() werden die Werte nun kommasepariert in der Spalte ‘aliases’ ausgegeben.

mysql> SELECT m1.addy, GROUP_CONCAT(m2.addy SEPARATOR ', ') AS aliases
 ->   FROM mails m1
 ->   JOIN mails m2 ON m2.parent_id = m1.id
 ->  WHERE m2.id <> m2.parent_id
 ->  GROUP BY m1.id;
+----------------+--------------------------------------+
| addy           | aliases                              |
+----------------+--------------------------------------+
| m1@example.com | a1m1@example.com, a2m1@example.com   |
| m2@example.com | a1m2@example.com                     |
+----------------+--------------------------------------+
2 rows in set (0.00 sec)

Das funktioniert natürlich auch mit den Ids der Alias-Adressen. In diesem Fall muss dann aber der Rückgabewert von GROUP_CONCAT() gecastet werden, da sonst entweder nur die erste Id oder [BLOB] in der Ausgabe stehen würde.

mysql> SELECT m1.addy,
 ->           CAST(GROUP_CONCAT(m2.id SEPARATOR ', ') AS char) AS alias_ids
 ->   FROM mails m1
 ->   JOIN mails m2 ON m2.parent_id = m1.id
 ->  WHERE m2.id <> m2.parent_id
 ->  GROUP BY m1.id;
+----------------+-----------+
| addy           | alias_ids |
+----------------+-----------+
| m1@example.com | 2, 4      |
| m2@example.com | 5         |
+----------------+-----------+
2 rows in set (0.00 sec)

Die Funktion kann nicht nur gruppieren und mit beliebigen Trennzeichen aufzählen, es ist auch möglich, eine Sortierrichtung mit anzugeben. Mehr dazu im MySQL-Manual.

$image = 'bild.jpg'; $mimeType = mime_content_type($image); $content = file_get_contents($image); $url = 'http://developer:5984/database/document/path?rev=xx-xxxxx'; $client = new Zend_Http_Client(); $response = $client->setUri($url) ->setMethod('PUT') ->setHeaders(array('Content-Type' => $mimeType)) ->setRawData($content, $mimeType) ->request() 

Die Anhänge könnten auch mit dem Dokument im JSON-Format übertragen werden. Dafür müsste $content dann aber erst base64_encoded werden. Hierbei werden bestehende Anhänge aber gelöscht!

PHP verhält sich an der Stelle wie man es wahrscheinlich erwartet hätte und ruft die jeweilige Methode für jeden Parameter einmal auf. Es sind also keine besonderen Bedingungen innerhalb der Logik notwendig.

Hier ein Beispiel zum Ausprobieren:

<?php
class myArray implements ArrayAccess
{
  function offsetExists($key)
  {
    echo __METHOD__ . print_r($key, true);
    return true;
  }

  function offsetUnset($key)
  {
    echo __METHOD__ . print_r($key, true);
  }

  function offsetGet($key) { return; }
  function offsetSet($key, $value) {}
}

$t = new myArray();
unset($t['tick'], $t['trick'], $t['track']); echo '<br/>';
isset($t['tick'], $t['trick'], $t['track']);

Zeitlich war das wie erwartet locker drin, nur leider klappte das mit dem Inline aufgrund der Funktion sort() nicht, da diese das zu sortierende Array als Referenz verarbeitet.

Kleine Spielerei aber vielleicht braucht ja mal jemand den Schipsel.

<?php
$file = 'pfad/zur/datei.csv';
$lines = file($file);
sort($lines);
file_put_contents($file, implode('', $lines));

Einmal ausgeführt und aus

"test","test"
"bla","blubber"
"apfel","apfel"

wird

"apfel","apfel"
"bla","blubber"
"test","test"

mysqldump -u[USERNAME] -p[PASSWORD] -r path/to/dumpfile.sql --databases [DATABASENAME]

Dump einspielen

mysql -u[USERNAME] -p[PASSWORD] < path/to/dumpfile.sql

oder auch mit mysqlimport.

Diverse Werte

<?php $storeId = Mage::app()->getStore()->getId(); $storeName = Mage::app()->getStore()->getName(); $storeCode = Mage::app()->getStore()->getCode(); $groupId = Mage::app()->getStore()->getGroupID(); $groupName = Mage::app()->getStore()->getGroup()->getName(); $websiteName = Mage::app()->getWebsite()->getName();

Session

<?php
$sessionId  = Mage::getModel('core/session')->getSessionId();
$customerId = Mage::getModel('customer/session')->getCustomerId();
$vistitorId = Mage::getModel('core/session')->getVisitorId();

Models

<?php $customer = Mage::getModel('customer/customer'); $order = Mage::getModel('sales/order'); $product = Mage::getModel('catalog/product'); 

Produkt-Model

$product    = Mage::getModel('catalog/product')->load($productId);
$categories = $product->getCategoryCollection();

Konfiguration

auslesen

$value = Mage::getStoreConfig('[MODULE]/[SECTION]/[FIELD]', $storeId);

und wieder schreiben

// Wert für Store 1 setzen
Mage::getConfig()->saveConfig('path/to/config/value', 12343, 'stores', 1);

// oder als Defaultwert
Mage::getConfig()->saveConfig('path/to/config/value', 12343);

Blocks

<?php $block = Mage::app()->getLayout()->createBlock('log/...');

Helpers

<?php
$helper = Mage::helper('helper');

Logging

<?php Mage::log('Schreibe das ins Logfile');

Sonstiges

Store-Umgebung simulieren

Mage::app()->getLocale()->emulate($storeId);

Events auslösen

Mage::dispatchEvent($eventName);

Es geht weiter…