Lançado Adianti Framework 7.6!
Clique aqui para saber mais
menu

Adianti Solutions

API

Adianti, Framework, PHP, MVC, Active record, Front controller, IDE, RAD, Web, multiplataforma, geração de código, desenvolvimento rápido, relatórios, formulários, listagens, datagrids, gráficos, banco de dados, padrões de projeto, design patterns API do Adianti Framework.
API Docs
code
Selecione a classe

Source for file TDatabase.php

Documentation is available at TDatabase.php

  1. <?php
  2. namespace Adianti\Database;
  3.  
  4. use Adianti\Core\AdiantiCoreTranslator;
  5. use Adianti\Database\TTransaction;
  6. use Adianti\Database\TCriteria;
  7. use Adianti\Database\TSqlSelect;
  8. use Adianti\Database\TSqlInsert;
  9. use Adianti\Database\TSqlUpdate;
  10. use Adianti\Database\TSqlDelete;
  11.  
  12. use PDO;
  13. use Exception;
  14. use SplFileObject;
  15. use Closure;
  16.  
  17. /**
  18.  * Database Task manager
  19.  *
  20.  * @version    7.4
  21.  * @package    database
  22.  * @author     Pablo Dall'Oglio
  23.  * @copyright  Copyright (c) 2018 Adianti Solutions Ltd. (http://www.adianti.com.br)
  24.  * @license    http://www.adianti.com.br/framework-license
  25.  */
  26. class TDatabase
  27. {
  28.     /**
  29.      * Drop table
  30.      * 
  31.      * @param $conn     Connection
  32.      * @param $table    Table name
  33.      * @param $ifexists Drop only if exists
  34.      */
  35.     public static function dropTable($conn$table$ifexists false)
  36.     {
  37.         $driver $conn->getAttribute(PDO::ATTR_DRIVER_NAME);
  38.         
  39.         if (in_array($driver['oci''dblib''sqlsrv']))
  40.         {
  41.             $list [];
  42.             $table_upper    strtoupper($table);
  43.             $list['oci']    "SELECT * FROM cat WHERE table_type in ('TABLE', 'VIEW') AND table_name = '{$table_upper}'";
  44.             $list['dblib']  "SELECT * FROM sysobjects WHERE (type = 'U' or type='V') AND name = '{$table}'";
  45.             $list['sqlsrv'$list['dblib'];
  46.             
  47.             if ($ifexists)
  48.             {
  49.                 $sql $list[$driver];
  50.                 $result $conn->query($sql);
  51.                 if (count($result->fetchAll()) 0)
  52.                 {
  53.                     $sql "DROP TABLE {$table}";
  54.                     TTransaction::log($sql);
  55.                     return $conn->query($sql);
  56.                 }
  57.             }
  58.             else
  59.             {
  60.                 $sql "DROP TABLE {$table}";
  61.                 TTransaction::log($sql);
  62.                 return $conn->query($sql);
  63.             }
  64.         }
  65.         else
  66.         {
  67.             $ife $ifexists ' IF EXISTS ' '';
  68.             $sql "DROP TABLE {$ife} {$table}";
  69.             TTransaction::log($sql);
  70.             return $conn->query($sql);
  71.         }
  72.     }
  73.     
  74.     /**
  75.      * Create table
  76.      * 
  77.      * @param $conn     Connection
  78.      * @param $table    Table name
  79.      * @param $columns  Array of columns
  80.      */
  81.     public static function createTable($conn$table$columns)
  82.     {
  83.         $columns_list [];
  84.         foreach ($columns as $column => $type)
  85.         {
  86.             $columns_list["{$column} {$type}";
  87.         }
  88.         
  89.         $sql "CREATE TABLE {$table} (implode(','$columns_list")";
  90.         
  91.         TTransaction::log($sql);
  92.         return $conn->query($sql);
  93.     }
  94.     
  95.     /**
  96.      * Drop column
  97.      * 
  98.      * @param $conn     Connection
  99.      * @param $table    Table name
  100.      * @param $column   Column name
  101.      */
  102.     public static function dropColumn($conn$table$column)
  103.     {
  104.         $sql "ALTER TABLE {$table} DROP COLUMN {$column}";
  105.         TTransaction::log($sql);
  106.         return $conn->query($sql);
  107.     }
  108.     
  109.     /**
  110.      * Add column
  111.      *
  112.      * @param $conn     Connection
  113.      * @param $table    Table name
  114.      * @param $column   Column name
  115.      * @param $type     Column type
  116.      * @param $options  Column options
  117.      */
  118.     public static function addColumn($conn$table$column$type$options)
  119.     {
  120.         $sql "ALTER TABLE {$table} ADD {$column} {$type} {$options}";
  121.         TTransaction::log($sql);
  122.         return $conn->query($sql);
  123.     }
  124.     
  125.     /**
  126.      * Insert data
  127.      * 
  128.      * @param $conn           Connection
  129.      * @param $table          Table name
  130.      * @param $values         Array of values
  131.      * @param $avoid_criteria Criteria to avoid insertion
  132.      */
  133.     public static function insertData($conn$table$values$avoid_criteria null)
  134.     {
  135.         if (!empty($avoid_criteria))
  136.         {
  137.             if (self::countData($conn$table$avoid_criteria0)
  138.             {
  139.                 return;
  140.             }
  141.         }
  142.         
  143.         $sql new TSqlInsert;
  144.         $sql->setEntity($table);
  145.         
  146.         foreach ($values as $key => $value)
  147.         {
  148.             $sql->setRowData($key$value);
  149.         }
  150.         
  151.         TTransaction::log($sql->getInstruction());
  152.         
  153.         $dbinfo TTransaction::getDatabaseInfo()// get dbinfo
  154.         if (isset($dbinfo['prep']AND $dbinfo['prep'== '1'// prepared ON
  155.         {
  156.             $result $conn-> prepare $sql->getInstructionTRUE array(PDO::ATTR_CURSOR => PDO::CURSOR_FWDONLY));
  157.             $result-> execute $sql->getPreparedVars() );
  158.         }
  159.         else
  160.         {
  161.             // execute the query
  162.             $result $conn-> query($sql->getInstruction());
  163.         }
  164.         
  165.         return $result;
  166.     }
  167.  
  168.  
  169.     /**
  170.      * Update data
  171.      * 
  172.      * @param $conn           Connection
  173.      * @param $table          Table name
  174.      * @param $values         Array of values
  175.      * @param $avoid_criteria Criteria to avoid insertion
  176.      */
  177.     public static function updateData($conn$table$values$criteria null)
  178.     {
  179.         $sql new TSqlUpdate;
  180.         $sql->setEntity($table);
  181.         
  182.         if ($criteria)
  183.         {
  184.             $sql->setCriteria($criteria);
  185.         }
  186.         
  187.         foreach ($values as $key => $value)
  188.         {
  189.             $sql->setRowData($key$value);
  190.         }
  191.         
  192.         TTransaction::log($sql->getInstruction());
  193.         
  194.         $dbinfo TTransaction::getDatabaseInfo()// get dbinfo
  195.         if (isset($dbinfo['prep']AND $dbinfo['prep'== '1'// prepared ON
  196.         {
  197.             $result $conn-> prepare $sql->getInstructionTRUE array(PDO::ATTR_CURSOR => PDO::CURSOR_FWDONLY));
  198.             $result-> execute $sql->getPreparedVars() );
  199.         }
  200.         else
  201.         {
  202.             // execute the query
  203.             $result $conn-> query($sql->getInstruction());
  204.         }
  205.         
  206.         return $result;
  207.     }
  208.     
  209.     /**
  210.      * Clear table data
  211.      * 
  212.      * @param $conn     Connection
  213.      * @param $table    Table name
  214.      * @param $criteria Filter criteria
  215.      */
  216.     public static function clearData($conn$table$criteria null)
  217.     {
  218.         $sql new TSqlDelete;
  219.         $sql->setEntity($table);
  220.         if ($criteria)
  221.         {
  222.             $sql->setCriteria($criteria);
  223.         }
  224.         
  225.         TTransaction::log$sql->getInstruction() );
  226.         return $conn->query$sql->getInstruction() );
  227.     }
  228.     
  229.     /**
  230.      * Execute SQL
  231.      * 
  232.      * @param $conn  Connection
  233.      * @param $query SQL
  234.      */
  235.     public static function execute($conn$query)
  236.     {
  237.         TTransaction::log($query);
  238.         return $conn->query($query);
  239.     }
  240.     
  241.     /**
  242.      * Get RAW Data
  243.      * 
  244.      * @param $conn            Connection
  245.      * @param $query           SQL
  246.      * @param $mapping         Mapping between fields
  247.      * @param $prepared_values Parameters for SQL Query
  248.      */
  249.     public static function getData($conn$query$mapping null$prepared_values nullClosure $action null)
  250.     {
  251.         $data [];
  252.         
  253.         $result  $conn->prepare($query);
  254.         $result->execute($prepared_values);
  255.         
  256.         foreach ($result as $row)
  257.         {
  258.             $values [];
  259.             if ($mapping)
  260.             {
  261.                 foreach ($mapping as $map)
  262.                 {
  263.                     $newcolumn $map[1];
  264.                     $values[$newcolumnself::transform($row$map);
  265.                 }
  266.             }
  267.             else
  268.             {
  269.                 $values $row;
  270.             }
  271.             
  272.             if (empty($action))
  273.             {
  274.                 $data[$values;
  275.             }
  276.             else
  277.             {
  278.                 $action($values);
  279.             }
  280.         }
  281.         
  282.         if (empty($action))
  283.         {
  284.             return $data;
  285.         }
  286.     }
  287.     
  288.     /**
  289.      * Count data from table
  290.      * 
  291.      * @param $conn     PDO source connection
  292.      * @param $table    Source table
  293.      * @param $criteria Filter criteria
  294.      */
  295.     public static function countData(PDO $conn$table$criteria null)
  296.     {
  297.         $sql new TSqlSelect;
  298.         $sql->setEntity($table);
  299.         
  300.         if ($criteria)
  301.         {
  302.             $sql->setCriteria($criteria);
  303.         }
  304.         $sql->addColumn('count(*)');
  305.         
  306.         TTransaction::log($sql->getInstruction());
  307.         
  308.         $dbinfo TTransaction::getDatabaseInfo()// get dbinfo
  309.         if (isset($dbinfo['prep']AND $dbinfo['prep'== '1'// prepared ON
  310.         {
  311.             $result $conn-> prepare $sql->getInstructionTRUE array(PDO::ATTR_CURSOR => PDO::CURSOR_FWDONLY));
  312.             $result-> execute $criteria->getPreparedVars() );
  313.         }
  314.         else
  315.         {
  316.             // executes the SELECT statement
  317.             $result$conn-> query($sql->getInstruction());
  318.         }
  319.         
  320.         if ($result)
  321.         {
  322.             $row $result->fetch();
  323.             return (int) $row[0];
  324.         }
  325.         
  326.         return 0;
  327.     }
  328.     
  329.     /**
  330.      * Copy data from table to table
  331.      * 
  332.      * @param $source_conn     PDO source connection
  333.      * @param $target_conn     PDO target connection
  334.      * @param $source_table    Source table
  335.      * @param $target_table    Target table
  336.      * @param $mapping         Mapping between fields
  337.      * @param $criteria        Filter criteria
  338.      * @param $bulk_inserts    Inserts per time
  339.      * @param $auto_commit     Auto commit after x inserts
  340.      */
  341.     public static function copyData(PDO $source_connPDO $target_conn$source_table$target_table$mapping$criteria null$bulk_inserts 1$auto_commit false)
  342.     {
  343.         $driver $target_conn->getAttribute(PDO::ATTR_DRIVER_NAME);
  344.         $bulk_inserts $driver == 'oci' $bulk_inserts;
  345.         
  346.         $source_columns [];
  347.         $target_columns [];
  348.         
  349.         foreach ($mapping as $map)
  350.         {
  351.             if (!empty($map[0]AND substr($map[0],0,4!== 'VAL:')
  352.             {
  353.                 $source_columns[$map[0];
  354.             }
  355.             $target_columns[$map[1];
  356.         }
  357.         
  358.         $sel new TSqlSelect;
  359.         $sel->setEntity($source_table);
  360.         if ($criteria)
  361.         {
  362.             $sel->setCriteria($criteria);
  363.         }
  364.         
  365.         foreach ($source_columns as $source_column)
  366.         {
  367.             $sel->addColumn($source_column);
  368.         }
  369.         
  370.         $result $source_conn->query($sel->getInstruction());
  371.         
  372.         $ins new TSqlMultiInsert;
  373.         $ins->setEntity($target_table);
  374.         $buffer_counter 0;
  375.         $commit_counter 0;
  376.         
  377.         foreach ($result as $row)
  378.         {
  379.             $values [];
  380.             foreach ($mapping as $map)
  381.             {
  382.                 $newcolumn $map[1];
  383.                 $values[$newcolumnself::transform($row$map);
  384.             }
  385.             $ins->addRowValues($values);
  386.             
  387.             $buffer_counter ++;
  388.             $commit_counter ++;
  389.             
  390.             if ($buffer_counter == $bulk_inserts)
  391.             {
  392.                 TTransaction::log$ins->getInstruction() );
  393.                 $target_conn->query($ins->getInstruction());
  394.                 $buffer_counter 0;
  395.                 
  396.                 // restart bulk insert
  397.                 $ins new TSqlMultiInsert;
  398.                 $ins->setEntity($target_table);
  399.                 
  400.                 if ($auto_commit)
  401.                 {
  402.                     if ($commit_counter == $auto_commit)
  403.                     {
  404.                         $target_conn->commit();
  405.                         $target_conn->beginTransaction();
  406.                         TTransaction::log'COMMIT' );
  407.                         $commit_counter 0;
  408.                     }
  409.                 }
  410.             }
  411.         }
  412.         
  413.         if ($buffer_counter 0)
  414.         {
  415.             TTransaction::log$ins->getInstruction() );
  416.             $target_conn->query($ins->getInstruction());
  417.         }
  418.     }
  419.     
  420.     /**
  421.      * Copy data from query to table
  422.      * 
  423.      * @param $source_conn     PDO source connection
  424.      * @param $target_conn     PDO target connection
  425.      * @param $query           SQL Query
  426.      * @param $target_table    Target table
  427.      * @param $mapping         Mapping between fields
  428.      * @param $prepared_values Parameters for SQL Query
  429.      * @param $bulk_inserts    Inserts per time
  430.      * @param $auto_commit     Auto commit after x inserts
  431.      */
  432.     public static function copyQuery(PDO $source_connPDO $target_conn$query$target_table$mapping$prepared_values null$bulk_inserts 1$auto_commit false)
  433.     {
  434.         $driver $target_conn->getAttribute(PDO::ATTR_DRIVER_NAME);
  435.         $bulk_inserts $driver == 'oci' $bulk_inserts;
  436.         
  437.         $target_columns [];
  438.         
  439.         foreach ($mapping as $map)
  440.         {
  441.             $target_columns[$map[1];
  442.         }
  443.         
  444.         $result $source_conn->prepare($query);
  445.         $result->execute($prepared_values);
  446.         
  447.         $ins new TSqlMultiInsert;
  448.         $ins->setEntity($target_table);
  449.         $buffer_counter 0;
  450.         $commit_counter 0;
  451.         
  452.         foreach ($result as $row)
  453.         {
  454.             $values [];
  455.             foreach ($mapping as $map)
  456.             {
  457.                 $newcolumn $map[1];
  458.                 $values[$newcolumnself::transform($row$map);
  459.             }
  460.             $ins->addRowValues($values);
  461.             
  462.             $buffer_counter ++;
  463.             $commit_counter ++;
  464.             
  465.             if ($buffer_counter == $bulk_inserts)
  466.             {
  467.                 TTransaction::log$ins->getInstruction() );
  468.                 $target_conn->query($ins->getInstruction());
  469.                 $buffer_counter 0;
  470.                 
  471.                 // restart bulk insert
  472.                 $ins new TSqlMultiInsert;
  473.                 $ins->setEntity($target_table);
  474.                 
  475.                 if ($auto_commit)
  476.                 {
  477.                     if ($commit_counter == $auto_commit)
  478.                     {
  479.                         $target_conn->commit();
  480.                         $target_conn->beginTransaction();
  481.                         TTransaction::log'COMMIT' );
  482.                         $commit_counter 0;
  483.                     }
  484.                 }
  485.             }
  486.         }
  487.         
  488.         if ($buffer_counter 0)
  489.         {
  490.             TTransaction::log$ins->getInstruction() );
  491.             $target_conn->query($ins->getInstruction());
  492.         }
  493.     }
  494.     
  495.     /**
  496.      * Import data from CSV file
  497.      * @param $filename        CSV File to import
  498.      * @param $target_conn     Target connection
  499.      * @param $target_table    Target table
  500.      * @param $mapping         Mapping between fields
  501.      * @param $separator       Columns separator [,]
  502.      */
  503.     public static function importFromFile($filename$target_conn$target_table$mapping$separator ','$bulk_inserts 1)
  504.     {
  505.         $driver $target_conn->getAttribute(PDO::ATTR_DRIVER_NAME);
  506.         $bulk_inserts $driver == 'oci' $bulk_inserts;
  507.         
  508.         $counter 1;
  509.         
  510.         if (!file_exists($filename))
  511.         {
  512.             throw new Exception(AdiantiCoreTranslator::translate('File not found' ': ' $filename));
  513.         }
  514.         
  515.         if (!is_readable($filename))
  516.         {
  517.             throw new Exception(AdiantiCoreTranslator::translate('Permission denied' ': ' $filename));
  518.         }
  519.         
  520.         $data   file($filename);
  521.         $header str_getcsv($data[0]$separator);
  522.         
  523.         $ins new TSqlMultiInsert;
  524.         $ins->setEntity($target_table);
  525.         $buffer_counter 0;
  526.         
  527.         while (isset($data[$counter]))
  528.         {
  529.             $row str_getcsv($data[$counter ++]$separator);
  530.             foreach ($row as $key => $value)
  531.             {
  532.                 $row$header[$key] ] $value;
  533.             }
  534.             
  535.             $values [];
  536.             foreach ($mapping as $map)
  537.             {
  538.                 $newcolumn $map[1];
  539.                 $values[$newcolumnself::transform($row$map);
  540.             }
  541.             
  542.             $ins->addRowValues($values);
  543.             
  544.             $buffer_counter ++;
  545.             if ($buffer_counter == $bulk_inserts)
  546.             {
  547.                 TTransaction::log$ins->getInstruction() );
  548.                 $target_conn->query($ins->getInstruction());
  549.                 $buffer_counter 0;
  550.                 
  551.                 // restart bulk insert
  552.                 $ins new TSqlMultiInsert;
  553.                 $ins->setEntity($target_table);
  554.             }
  555.         }
  556.         if ($buffer_counter 0)
  557.         {
  558.             TTransaction::log$ins->getInstruction() );
  559.             $target_conn->query($ins->getInstruction());
  560.         }
  561.     }
  562.     
  563.     /**
  564.      * Export data to CSV file
  565.      * @param $source_conn     Source connection
  566.      * @param $source_table    Target table
  567.      * @param $filename        CSV File to import
  568.      * @param $mapping         Mapping between fields
  569.      * @param $criteria        Select criteria
  570.      * @param $separator       Columns separator [,]
  571.      */
  572.     public static function exportToFile($source_conn$source_table$filename$mapping$criteria null$separator ',')
  573.     {
  574.         $source_columns [];
  575.         $target_columns [];
  576.         
  577.         if ( (file_exists($filenameAND !is_writable($filename)) OR (!is_writable(dirname($filename))) )
  578.         {
  579.             throw new Exception(AdiantiCoreTranslator::translate('Permission denied' ': ' $filename));
  580.         }
  581.         
  582.         foreach ($mapping as $map)
  583.         {
  584.             if (!empty($map[0]AND substr($map[0],0,4!== 'VAL:')
  585.             {
  586.                 $source_columns[$map[0];
  587.             }
  588.             $target_columns[$map[1];
  589.         }
  590.         
  591.         $sel new TSqlSelect;
  592.         $sel->setEntity($source_table);
  593.         if ($criteria)
  594.         {
  595.             $sel->setCriteria($criteria);
  596.         }
  597.         
  598.         foreach ($source_columns as $source_column)
  599.         {
  600.             $sel->addColumn($source_column);
  601.         }
  602.         
  603.         $result $source_conn->query($sel->getInstruction());
  604.         
  605.         $file new SplFileObject($filename'w');
  606.         $file->setCsvControl(',');
  607.         $file->fputcsv($target_columns);
  608.         
  609.         foreach ($result as $row)
  610.         {
  611.             $values [];
  612.             foreach ($mapping as $map)
  613.             {
  614.                 $newcolumn $map[1];
  615.                 $values[$newcolumnself::transform($row$map);
  616.             }
  617.             
  618.             $file->fputcsv(array_values($values));
  619.         }
  620.         $file null// close
  621.     }
  622.     
  623.     /**
  624.      * Transform value according to mapping rules
  625.      * @param $row Row values
  626.      * @param $map Array with mapping instruction
  627.      */
  628.     private static function transform($row$map)
  629.     {
  630.         $column   $map[0];
  631.         $callback = isset($map[2]$map[2null;
  632.         $value    (substr($column,0,4)== 'VAL:'substr($column,4$row[$column];
  633.         
  634.         if (is_string($value))
  635.         {
  636.             $value preg_replace('/[[:cntrl:]]/'''$value);
  637.         }
  638.         
  639.         if (is_callable($callback))
  640.         {
  641.             $value call_user_func($callback$value$row);
  642.         }
  643.         
  644.         return $value;
  645.     }
  646. }