Zacznijmy od struktury
  1. CREATE TABLE `items` (
  2. `Id` int(10) UNSIGNED NOT NULL AUTO_INCREMENT,
  3. `Lang` char(2) NOT NULL,
  4. `Type` varchar(30) NOT NULL,
  5. `Name` varchar(255) DEFAULT NULL,
  6. `CreatedBy` int(10) UNSIGNED DEFAULT NULL,
  7. `CreateDate` datetime NOT NULL,
  8. `EditedBy` int(10) UNSIGNED DEFAULT NULL,
  9. `EditDate` datetime DEFAULT NULL,
  10. `System` enum('Y','N') NOT NULL DEFAULT 'N',
  11. `Published` enum('Y','N') NOT NULL DEFAULT 'N',
  12. `AllowAccess` text,
  13. `DenyAccess` text,
  14. `AllowEdit` text,
  15. `DenyEdit` text,
  16. `AllowDelete` text,
  17. `DenyDelete` text,
  18. PRIMARY KEY (`Id`,`Lang`),
  19. KEY `Type` (`Type`,`Name`,`CreatedBy`,`EditedBy`,`System`,`Published`)
  20. ) ENGINE=InnoDB DEFAULT CHARSET=latin1;
  21.  
  22. CREATE TABLE `docs` (
  23. `Id` int(10) UNSIGNED NOT NULL,
  24. `Lang` char(2) NOT NULL,
  25. `Content` text NOT NULL,
  26. PRIMARY KEY (`Id`,`Lang`)
  27. ) ENGINE=InnoDB DEFAULT CHARSET=latin1;

Docs są jakby uzupełnieniem itemsów. Połączone są wartościami Id i Lang. Chciałbym mieć do tych danych łatwy dostęp (przez jedną tabelę) więc utworzyłem widok:
  1. CREATE VIEW `itemsdocs` AS SELECT
  2. `i`.`Id` AS `Id`,
  3. `i`.`Lang` AS `Lang`,
  4. `i`.`Type` AS `Type`,
  5. `i`.`Name` AS `Name`,
  6. `i`.`CreatedBy` AS `CreatedBy`,
  7. `i`.`CreateDate` AS `CreateDate`,
  8. `i`.`EditedBy` AS `EditedBy`,
  9. `i`.`EditDate` AS `EditDate`,
  10. `i`.`System` AS `System`,
  11. `i`.`Published` AS `Published`,
  12. `i`.`AllowAccess` AS `AllowAccess`,
  13. `i`.`DenyAccess` AS `DenyAccess`,
  14. `i`.`AllowEdit` AS `AllowEdit`,
  15. `i`.`DenyEdit` AS `DenyEdit`,
  16. `i`.`AllowDelete` AS `AllowDelete`,
  17. `i`.`DenyDelete` AS `DenyDelete`,
  18. `d`.`Content` AS `Content`
  19. FROM (`docs` `d` JOIN `items` `i`)
  20. WHERE (`i`.`Id` = `d`.`Id`) AND (`i`.`Lang` = `d`.`Lang`) AND (`i`.`Type` = _latin1'docs');

Teraz sprawa wstawiania//edytowania//usuwania danych. Zwykły insert do widoku nie zadziała ponieważ stworzony jest on z joina. Chciałem utworzyć triggery i przykładowo:
  1. DELIMITER |
  2. CREATE TRIGGER itemsdocs_insert AFTER INSERT ON itemsdocs FOR EACH ROW
  3. BEGIN INSERT INTO `items` (Id, Lang, `Type`, Name, CreatedBy, CreateDate, EditedBy, EditDate, System, Published,
  4. AllowAccess, DenyAccess, AllowEdit, DenyEdit, AllowDelete, DenyDelete)
  5. VALUES (
  6. NEW.Id, NEW.Lang, NEW.`Type`, NEW.Name, NEW.CreatedBy, NEW.CreateDate, NEW.EditedBy,
  7. NEW.EditDate, NEW.System, NEW.Published, NEW.AllowAccess, NEW.DenyAccess, NEW.AllowEdit,
  8. NEW.DenyEdit, NEW.AllowDelete, NEW.DenyDelete);
  9. INSERT INTO `docs` (`Id`, `Lang`, `Content`)
  10. VALUES (NEW.Id, NEW.Lang, NEW.Content);
  11. END;

Odpowiedzialny za wstawianie danych, nie utworzy się ponieważ itemdocs nie jest "BASE TABLE" tzn jest widokiem. Przeskoczę to jakoś na tym systemie bazodanowym? Chodzi o to aby jednym zapytaniem mieć możliwość aktualizowania danych zawartych w tym widoku.