developer.jelix.org is not used any more and exists only for history. Post new tickets on the Github account.
developer.jelix.org n'est plus utilisée, et existe uniquement pour son historique. Postez les nouveaux tickets sur le compte github.

Ticket #871: t871_v1.1.patch

File t871_v1.1.patch, 175.1 KB (added by laurentj, 12 years ago)

patch v1.1

  • build/manifests/testapp.mn

     
    148148  core.soap.html.php
    149149  core.urls_generation.html.php
    150150  core.urls_parsing.html_cli.php
     151  daotests.lib.php
    151152  events.simple_test.html_cli.php
    152153  jacl.main_api.html_cli.php
    153154  jacl.manager.html_cli.php
     
    171172  jdb.mysql.html_cli.php
    172173  jdb.pgsql.html_cli.php
    173174  jdb.sqlite.html_cli.php
     175  jdbtools.html_cli.php
    174176  jdbtools.mysql.html_cli.php
    175177  jforms.html_cli.php
    176178  jforms.check_datas.html_cli.php
  • testapp/modules/jelix_tests/tests/jdao.generator.html_cli.php

     
    99* @licence     GNU Lesser General Public Licence see LICENCE file or http://www.gnu.org/licenses/lgpl.html
    1010*/
    1111
    12 require_once(JELIX_LIB_PATH.'dao/jDaoCompiler.class.php');
     12require_once(dirname(__FILE__).'/daotests.lib.php');
    1313
    14 require_once(JELIX_LIB_PATH.'plugins/db/mysql/mysql.daobuilder.php');
    15 require_once(JELIX_LIB_PATH.'plugins/db/pgsql/pgsql.daobuilder.php');
    16 require_once(JELIX_LIB_PATH.'plugins/db/oci/oci.daobuilder.php');
    17 require_once(JELIX_LIB_PATH.'plugins/db/sqlite/sqlite.daobuilder.php');
    1814
    19 
    20 class testMysqlDaoGenerator extends mysqlDaoBuilder {
    21 
    22     function GetPropertiesBy ($captureMethod){
    23         return $this->_getPropertiesBy ($captureMethod);
    24     }
    25 
    26     function BuildSimpleConditions (&$fields, $fieldPrefix='', $forSelect=true){
    27         return $this->_buildSimpleConditions ($fields, $fieldPrefix, $forSelect);
    28     }
    29 
    30     function BuildConditions($cond, $fields, $params=array(), $withPrefix=true, $groupby='') {
    31         return $this->_buildConditions ($cond, $fields, $params, $withPrefix, $groupby);
    32     }
    33 
    34     function BuildSQLCondition ($condition, $fields, $params, $withPrefix){
    35         return $this->_buildSQLCondition ($condition, $fields, $params, $withPrefix, true);
    36     }
    37 
    38     function GetPreparePHPValue($value, $fieldType, $checknull=true){
    39         return $this->_preparePHPValue($value, $fieldType, $checknull);
    40     }
    41 
    42     function GetPreparePHPExpr($expr, $fieldType, $checknull=true, $forCondition=''){
    43         return $this->_preparePHPExpr($expr, $fieldType, $checknull, $forCondition);
    44     }
    45     function GetEncloseName($name){
    46         return $this->_encloseName($name);
    47     }
    48 }
    49 
    50 
    51 class testPgsqlDaoGenerator extends pgsqlDaoBuilder {
    52 
    53     function GetPropertiesBy ($captureMethod){
    54         return $this->_getPropertiesBy ($captureMethod);
    55     }
    56 
    57     function BuildSimpleConditions (&$fields, $fieldPrefix='', $forSelect=true){
    58         return $this->_buildSimpleConditions ($fields, $fieldPrefix, $forSelect);
    59     }
    60 
    61     function BuildSQLCondition ($condition, $fields, $params, $withPrefix){
    62         return $this->_buildSQLCondition ($condition, $fields, $params, $withPrefix, true);
    63     }
    64 
    65     function GetPreparePHPValue($value, $fieldType, $checknull=true){
    66         return $this->_preparePHPValue($value, $fieldType, $checknull);
    67     }
    68 
    69     function GetPreparePHPExpr($expr, $fieldType, $checknull=true, $forCondition=''){
    70         return $this->_preparePHPExpr($expr, $fieldType, $checknull, $forCondition);
    71     }
    72     function GetEncloseName($name){
    73         return $this->_encloseName($name);
    74     }
    75 }
    76 
    77 
    78 class testOciDaoGenerator extends ociDaoBuilder {
    79 
    80     function GetPropertiesBy ($captureMethod){
    81         return $this->_getPropertiesBy ($captureMethod);
    82     }
    83 
    84     function BuildSimpleConditions (&$fields, $fieldPrefix='', $forSelect=true){
    85         return $this->_buildSimpleConditions ($fields, $fieldPrefix, $forSelect);
    86     }
    87 
    88     function BuildSQLCondition ($condition, $fields, $params, $withPrefix){
    89         return $this->_buildSQLCondition ($condition, $fields, $params, $withPrefix, true);
    90     }
    91 
    92     function GetPreparePHPValue($value, $fieldType, $checknull=true){
    93         return $this->_preparePHPValue($value, $fieldType, $checknull);
    94     }
    95 
    96     function GetPreparePHPExpr($expr, $fieldType, $checknull=true, $forCondition=''){
    97         return $this->_preparePHPExpr($expr, $fieldType, $checknull, $forCondition);
    98     }
    99     function GetEncloseName($name){
    100         return $this->_encloseName($name);
    101     }
    102 }
    103 
    104 class testSqliteDaoGenerator extends sqliteDaoBuilder {
    105 
    106     function GetPropertiesBy ($captureMethod){
    107         return $this->_getPropertiesBy ($captureMethod);
    108     }
    109 
    110     function BuildSimpleConditions (&$fields, $fieldPrefix='', $forSelect=true){
    111         return $this->_buildSimpleConditions ($fields, $fieldPrefix, $forSelect);
    112     }
    113 
    114     function BuildSQLCondition ($condition, $fields, $params, $withPrefix){
    115         return $this->_buildSQLCondition ($condition, $fields, $params, $withPrefix, true);
    116     }
    117 
    118     function GetPreparePHPValue($value, $fieldType, $checknull=true){
    119         return $this->_preparePHPValue($value, $fieldType, $checknull);
    120     }
    121 
    122     function GetPreparePHPExpr($expr, $fieldType, $checknull=true, $forCondition=''){
    123         return $this->_preparePHPExpr($expr, $fieldType, $checknull, $forCondition);
    124     }
    125     function GetEncloseName($name){
    126         return $this->_encloseName($name);
    127     }
    128 }
    129 
    130 
    131 class testDaoProperty {
    132     public $datatype;
    133     public $defaultValue=null;
    134 }
    135 
    136 
    13715class UTDao_generator extends jUnitTestCase {
    13816    protected function getSimpleGenerator(){
    13917        $doc ='<?xml version="1.0"?>
     
    14725      <property name="price" fieldname="price" datatype="float"/>
    14826   </record>
    14927</dao>';
    150         $parser = new jDaoParser ();
    151         $parser->parse(simplexml_load_string($doc));
    152         return new testMysqlDaoGenerator('cDao_foo_Jx_bar_Jx_mysql', 'cDaoRecord_foo_Jx_bar_Jx_mysql', $parser);
     28        $parser = new jDaoParser ($this->_selector);
     29        $parser->parse(simplexml_load_string($doc), $this->_tools);
     30        return new testMysqlDaoGenerator($this->_selector, $this->_tools, $parser);
    15331    }
    15432
    155 
     33    protected $_selector;
     34    protected $_tools;
     35   
    15636    function setUp() {
    157         jDaoCompiler::$daoId ='';
    158         jDaoCompiler::$daoPath = '';
    159         jDaoCompiler::$dbType='mysql';
     37        $this->_selector = new fakejSelectorDao('foo','bar','mysql');
     38        $this->_tools= new mysqlDbTools(null);
    16039    }
    16140
    162     function testEncloseName(){
    163         $doc ='<?xml version="1.0"?>
    164 <dao xmlns="http://jelix.org/ns/dao/1.0">
    165    <datasources>
    166       <primarytable name="product_test" primarykey="id" />
    167    </datasources>
    168    <record>
    169       <property name="id"   fieldname="id" datatype="autoincrement" required="true" />
    170       <property name="name" fieldname="name" datatype="string"  required="true"/>
    171       <property name="price" fieldname="price" datatype="float"/>
    172    </record>
    173 </dao>';
    174         $parser = new jDaoParser ();
    175         $parser->parse(simplexml_load_string($doc));
    17641
    177         $generator= new testMysqlDaoGenerator('cDao_foo_Jx_bar_Jx_mysql', 'cDaoRecord_foo_Jx_bar_Jx_mysql', $parser);
    178         $result = $generator->GetEncloseName('foo');
    179         $this->assertEqualOrDiff('`foo`',$result);
    180 
    181         $generator= new testPgsqlDaoGenerator('cDao_foo_Jx_bar_Jx_pgsql', 'cDaoRecord_foo_Jx_bar_Jx_pgsql', $parser);
    182         $result = $generator->GetEncloseName('foo');
    183         $this->assertEqualOrDiff('"foo"',$result);
    184 
    185         $generator= new testOciDaoGenerator('cDao_foo_Jx_bar_Jx_oci', 'cDaoRecord_foo_Jx_bar_Jx_oci', $parser);
    186         $result = $generator->GetEncloseName('foo');
    187         $this->assertEqualOrDiff('foo',$result);
    188 
    189         $generator= new testSqliteDaoGenerator('cDao_foo_Jx_bar_Jx_sqlite', 'cDaoRecord_foo_Jx_bar_Jx_sqlite', $parser);
    190         $result = $generator->GetEncloseName('foo');
    191         $this->assertEqualOrDiff('foo',$result);
     42    protected $_generator;
     43    function _getProp($type, $expr, $checknull, $op='') {
     44        $u = $this->_tools->getTypeInfo($type);
     45        $prop = new testDaoProperty();
     46        $prop->datatype = $type;
     47        $prop->unifiedType = $u[1];
     48        $prop->autoIncrement = $u[6];
     49        return $this->_generator->GetPreparePHPExpr($expr, $prop, $checknull,$op);
    19250    }
    19351
    19452    function testPreparePHPExpr(){
    195         $generator=$this->getSimpleGenerator();
    196         $prop = new testDaoProperty();
     53        $this->_generator = $this->getSimpleGenerator();
    19754
    19855        // with no checknull
    199         $prop->datatype='int';
    200         $result = $generator->GetPreparePHPExpr('$foo', $prop, false);
    201         $this->assertEqualOrDiff('intval($foo)',$result);
    202         $prop->datatype='integer';
    203         $result = $generator->GetPreparePHPExpr('$foo', $prop, false);
    204         $this->assertEqualOrDiff('intval($foo)',$result);
    205         $prop->datatype='autoincrement';
    206         $result = $generator->GetPreparePHPExpr('$foo', $prop, false);
    207         $this->assertEqualOrDiff('intval($foo)',$result);
    208         $prop->datatype='string';
    209         $result = $generator->GetPreparePHPExpr('$foo', $prop, false);
    210         $this->assertEqualOrDiff('$this->_conn->quote($foo)',$result);
    211         $prop->datatype='double';
    212         $result = $generator->GetPreparePHPExpr('$foo', $prop, false);
    213         $this->assertEqualOrDiff('doubleval($foo)',$result);
    214         $prop->datatype='float';
    215         $result = $generator->GetPreparePHPExpr('$foo', $prop, false);
    216         $this->assertEqualOrDiff('doubleval($foo)',$result);
    217         $prop->datatype='numeric';
    218         $result = $generator->GetPreparePHPExpr('$foo', $prop, false);
    219         $this->assertEqualOrDiff('(is_numeric ($foo) ? $foo : intval($foo))',$result);
    220         $prop->datatype='bigautoincrement';
    221         $result = $generator->GetPreparePHPExpr('$foo', $prop, false);
    222         $this->assertEqualOrDiff('(is_numeric ($foo) ? $foo : intval($foo))',$result);
    22356
     57        $this->assertEqualOrDiff('intval($foo)',$this->_getProp('int','$foo', false));
     58        $this->assertEqualOrDiff('intval($foo)',$this->_getProp('integer','$foo', false));
     59        $this->assertEqualOrDiff('intval($foo)',$this->_getProp('autoincrement','$foo', false));
     60        $this->assertEqualOrDiff('$this->_conn->quote($foo)',$this->_getProp('string','$foo', false));
     61        $this->assertEqualOrDiff('(is_numeric ($foo) ? $foo : floatval($foo))',$this->_getProp('double','$foo', false));
     62        $this->assertEqualOrDiff('doubleval($foo)',$this->_getProp('float','$foo', false));
     63        $this->assertEqualOrDiff('(is_numeric ($foo) ? $foo : floatval($foo))',$this->_getProp('numeric','$foo', false));
     64        $this->assertEqualOrDiff('(is_numeric ($foo) ? $foo : floatval($foo))',$this->_getProp('bigautoincrement','$foo', false));
     65
    22466        // with checknull
    225         $prop->datatype='integer';
    226         $result = $generator->GetPreparePHPExpr('$foo', $prop, true);
    227         $this->assertEqualOrDiff('($foo === null ? \'NULL\' : intval($foo))',$result);
    228         $prop->datatype='autoincrement';
    229         $result = $generator->GetPreparePHPExpr('$foo', $prop, true);
    230         $this->assertEqualOrDiff('intval($foo)',$result);
    231         $prop->datatype='string';
    232         $result = $generator->GetPreparePHPExpr('$foo', $prop, true);
    233         $this->assertEqualOrDiff('($foo === null ? \'NULL\' : $this->_conn->quote($foo,false))',$result);
    234         $prop->datatype='double';
    235         $result = $generator->GetPreparePHPExpr('$foo', $prop, true);
    236         $this->assertEqualOrDiff('($foo === null ? \'NULL\' : doubleval($foo))',$result);
    237         $prop->datatype='float';
    238         $result = $generator->GetPreparePHPExpr('$foo', $prop, true);
    239         $this->assertEqualOrDiff('($foo === null ? \'NULL\' : doubleval($foo))',$result);
    240         $prop->datatype='numeric';
    241         $result = $generator->GetPreparePHPExpr('$foo', $prop, true);
    242         $this->assertEqualOrDiff('($foo === null ? \'NULL\' : (is_numeric ($foo) ? $foo : intval($foo)))',$result);
    243         $prop->datatype='bigautoincrement';
    244         $result = $generator->GetPreparePHPExpr('$foo', $prop, true);
    245         $this->assertEqualOrDiff('(is_numeric ($foo) ? $foo : intval($foo))',$result);
     67        $this->assertEqualOrDiff('($foo === null ? \'NULL\' : intval($foo))',$this->_getProp('integer','$foo', true));
     68        $this->assertEqualOrDiff('($foo === null ? \'NULL\' : intval($foo))',$this->_getProp('autoincrement','$foo', true));
     69        $this->assertEqualOrDiff('($foo === null ? \'NULL\' : $this->_conn->quote($foo,false))',$this->_getProp('string','$foo', true));
     70        $this->assertEqualOrDiff('($foo === null ? \'NULL\' : (is_numeric ($foo) ? $foo : floatval($foo)))',$this->_getProp('double','$foo', true));
     71        $this->assertEqualOrDiff('($foo === null ? \'NULL\' : doubleval($foo))',$this->_getProp('float','$foo', true));
     72        $this->assertEqualOrDiff('($foo === null ? \'NULL\' : (is_numeric ($foo) ? $foo : floatval($foo)))',$this->_getProp('numeric','$foo', true));
     73        $this->assertEqualOrDiff('($foo === null ? \'NULL\' : (is_numeric ($foo) ? $foo : floatval($foo)))',$this->_getProp('bigautoincrement','$foo', true));
    24674
    24775        // with checknull and operator =
    248         $prop->datatype='integer';
    249         $result = $generator->GetPreparePHPExpr('$foo', $prop, true,'=');
    250         $this->assertEqualOrDiff('($foo === null ? \'IS NULL\' : \'=\'.intval($foo))',$result);
    251         $prop->datatype='autoincrement';
    252         $result = $generator->GetPreparePHPExpr('$foo', $prop, true,'=');
    253         $this->assertEqualOrDiff('\'=\'.intval($foo)',$result);
    254         $prop->datatype='string';
    255         $result = $generator->GetPreparePHPExpr('$foo', $prop, true,'=');
    256         $this->assertEqualOrDiff('($foo === null ? \'IS NULL\' : \'=\'.$this->_conn->quote($foo,false))',$result);
    257         $prop->datatype='double';
    258         $result = $generator->GetPreparePHPExpr('$foo', $prop, true,'=');
    259         $this->assertEqualOrDiff('($foo === null ? \'IS NULL\' : \'=\'.doubleval($foo))',$result);
    260         $prop->datatype='float';
    261         $result = $generator->GetPreparePHPExpr('$foo', $prop, true,'=');
    262         $this->assertEqualOrDiff('($foo === null ? \'IS NULL\' : \'=\'.doubleval($foo))',$result);
    263         $prop->datatype='numeric';
    264         $result = $generator->GetPreparePHPExpr('$foo', $prop, true,'=');
    265         $this->assertEqualOrDiff('($foo === null ? \'IS NULL\' : \'=\'.(is_numeric ($foo) ? $foo : intval($foo)))',$result);
    266         $prop->datatype='bigautoincrement';
    267         $result = $generator->GetPreparePHPExpr('$foo', $prop, true,'=');
    268         $this->assertEqualOrDiff('\'=\'.(is_numeric ($foo) ? $foo : intval($foo))',$result);
     76        $this->assertEqualOrDiff('($foo === null ? \'IS NULL\' : \'=\'.intval($foo))',$this->_getProp('integer','$foo', true,'='));
     77        $this->assertEqualOrDiff('($foo === null ? \'IS NULL\' : \'=\'.intval($foo))',$this->_getProp('autoincrement','$foo', true,'='));
     78        $this->assertEqualOrDiff('($foo === null ? \'IS NULL\' : \'=\'.$this->_conn->quote($foo,false))',$this->_getProp('string','$foo', true,'='));
     79        $this->assertEqualOrDiff('($foo === null ? \'IS NULL\' : \'=\'.(is_numeric ($foo) ? $foo : floatval($foo)))',$this->_getProp('double','$foo', true,'='));
     80        $this->assertEqualOrDiff('($foo === null ? \'IS NULL\' : \'=\'.doubleval($foo))',$this->_getProp('float','$foo', true,'='));
     81        $this->assertEqualOrDiff('($foo === null ? \'IS NULL\' : \'=\'.(is_numeric ($foo) ? $foo : floatval($foo)))',$this->_getProp('numeric','$foo', true,'='));
     82        $this->assertEqualOrDiff('($foo === null ? \'IS NULL\' : \'=\'.(is_numeric ($foo) ? $foo : floatval($foo)))',$this->_getProp('bigautoincrement','$foo', true,'='));
    26983
    27084        // with checknull with default value and operator =
    27185        /*$prop->defaultValue=34;
     
    295109        $prop->defaultValue = null;*/
    296110
    297111        // with checknull and operator <>
    298         $prop->datatype='integer';
    299         $result = $generator->GetPreparePHPExpr('$foo', $prop, true,'<>');
     112        $result = $this->_getProp('integer','$foo', true,'<>');
    300113        $this->assertEqualOrDiff('($foo === null ? \'IS NOT NULL\' : \'<>\'.intval($foo))',$result);
    301         $prop->datatype='autoincrement';
    302         $result = $generator->GetPreparePHPExpr('$foo', $prop, true,'<>');
    303         $this->assertEqualOrDiff('\'<>\'.intval($foo)',$result);
    304         $prop->datatype='string';
    305         $result = $generator->GetPreparePHPExpr('$foo', $prop, true,'<>');
     114       
     115        $result = $this->_getProp('autoincrement','$foo', true,'<>');
     116        $this->assertEqualOrDiff('($foo === null ? \'IS NOT NULL\' : \'<>\'.intval($foo))',$result);
     117        $result = $this->_getProp('string','$foo', true,'<>');
    306118        $this->assertEqualOrDiff('($foo === null ? \'IS NOT NULL\' : \'<>\'.$this->_conn->quote($foo,false))',$result);
    307         $prop->datatype='double';
    308         $result = $generator->GetPreparePHPExpr('$foo', $prop, true,'<>');
     119        $result = $this->_getProp('double','$foo', true,'<>');
     120        $this->assertEqualOrDiff('($foo === null ? \'IS NOT NULL\' : \'<>\'.(is_numeric ($foo) ? $foo : floatval($foo)))',$result);
     121        $result = $this->_getProp('float','$foo', true,'<>');
    309122        $this->assertEqualOrDiff('($foo === null ? \'IS NOT NULL\' : \'<>\'.doubleval($foo))',$result);
    310         $prop->datatype='float';
    311         $result = $generator->GetPreparePHPExpr('$foo', $prop, true,'<>');
    312         $this->assertEqualOrDiff('($foo === null ? \'IS NOT NULL\' : \'<>\'.doubleval($foo))',$result);
    313         $prop->datatype='numeric';
    314         $result = $generator->GetPreparePHPExpr('$foo', $prop, true,'<>');
    315         $this->assertEqualOrDiff('($foo === null ? \'IS NOT NULL\' : \'<>\'.(is_numeric ($foo) ? $foo : intval($foo)))',$result);
    316         $prop->datatype='bigautoincrement';
    317         $result = $generator->GetPreparePHPExpr('$foo', $prop, true,'<>');
    318         $this->assertEqualOrDiff('\'<>\'.(is_numeric ($foo) ? $foo : intval($foo))',$result);
     123        $result = $this->_getProp('numeric','$foo', true,'<>');
     124        $this->assertEqualOrDiff('($foo === null ? \'IS NOT NULL\' : \'<>\'.(is_numeric ($foo) ? $foo : floatval($foo)))',$result);
     125        $result = $this->_getProp('bigautoincrement','$foo', true,'<>');
     126        $this->assertEqualOrDiff('($foo === null ? \'IS NOT NULL\' : \'<>\'.(is_numeric ($foo) ? $foo : floatval($foo)))',$result);
    319127
    320128        // with checknull and other operator <=
    321         $prop->datatype='integer';
    322         $result = $generator->GetPreparePHPExpr('$foo', $prop, true,'<=');
     129        $result = $this->_getProp('integer','$foo', true,'<=');
    323130        $this->assertEqualOrDiff('\'<=\'.intval($foo)',$result);
    324         $prop->datatype='autoincrement';
    325         $result = $generator->GetPreparePHPExpr('$foo', $prop, true,'<=');
     131        $result = $this->_getProp('autoincrement','$foo', true,'<=');
    326132        $this->assertEqualOrDiff('\'<=\'.intval($foo)',$result);
    327         $prop->datatype='string';
    328         $result = $generator->GetPreparePHPExpr('$foo', $prop, true,'<=');
     133        $result = $this->_getProp('string','$foo', true,'<=');
    329134        $this->assertEqualOrDiff('\'<=\'.$this->_conn->quote($foo)',$result);
    330         $prop->datatype='double';
    331         $result = $generator->GetPreparePHPExpr('$foo', $prop, true,'<=');
     135        $result = $this->_getProp('double','$foo', true,'<=');
     136        $this->assertEqualOrDiff('\'<=\'.(is_numeric ($foo) ? $foo : floatval($foo))',$result);
     137        $result = $this->_getProp('float','$foo', true,'<=');
    332138        $this->assertEqualOrDiff('\'<=\'.doubleval($foo)',$result);
    333         $prop->datatype='float';
    334         $result = $generator->GetPreparePHPExpr('$foo', $prop, true,'<=');
    335         $this->assertEqualOrDiff('\'<=\'.doubleval($foo)',$result);
    336         $prop->datatype='numeric';
    337         $result = $generator->GetPreparePHPExpr('$foo', $prop, true,'<=');
    338         $this->assertEqualOrDiff('\'<=\'.(is_numeric ($foo) ? $foo : intval($foo))',$result);
    339         $prop->datatype='bigautoincrement';
    340         $result = $generator->GetPreparePHPExpr('$foo', $prop, true,'<=');
    341         $this->assertEqualOrDiff('\'<=\'.(is_numeric ($foo) ? $foo : intval($foo))',$result);
     139        $result = $this->_getProp('numeric','$foo', true,'<=');
     140        $this->assertEqualOrDiff('\'<=\'.(is_numeric ($foo) ? $foo : floatval($foo))',$result);
     141        $result = $this->_getProp('bigautoincrement','$foo', true,'<=');
     142        $this->assertEqualOrDiff('\'<=\'.(is_numeric ($foo) ? $foo : floatval($foo))',$result);
    342143    }
    343144
    344     function testPreparePHPValue(){
    345         $generator=$this->getSimpleGenerator();
    346 
    347         // with no checknull
    348         $result = $generator->GetPreparePHPValue('5', 'int',false);
    349         $this->assertEqualOrDiff(5,$result);
    350         $result = $generator->GetPreparePHPValue('5', 'integer',false);
    351         $this->assertEqualOrDiff(5,$result);
    352         $result = $generator->GetPreparePHPValue('5', 'autoincrement',false);
    353         $this->assertEqualOrDiff(5,$result);
    354         $result = $generator->GetPreparePHPValue('$foo', 'string',false);
    355         $this->assertEqualOrDiff('\\\'$foo\\\'',$result);
    356         $result = $generator->GetPreparePHPValue('$f\'oo', 'string',false);
    357         $this->assertEqualOrDiff('\'.$this->_conn->quote(\'$f\\\'oo\').\'',$result);
    358         $result = $generator->GetPreparePHPValue('5.63', 'double',false);
    359         $this->assertEqualOrDiff(5.63,$result);
    360         $result = $generator->GetPreparePHPValue('5.63', 'float',false);
    361         $this->assertEqualOrDiff(5.63,$result);
    362         $result = $generator->GetPreparePHPValue('565465465463', 'numeric',false);
    363         $this->assertEqualOrDiff('565465465463',$result);
    364         $result = $generator->GetPreparePHPValue('565469876543139798641315465463', 'numeric',false);
    365         $this->assertEqualOrDiff('565469876543139798641315465463',$result);
    366         $result = $generator->GetPreparePHPValue('565469876543139798641315465463', 'bigautoincrement',false);
    367         $this->assertEqualOrDiff('565469876543139798641315465463',$result);
    368 
    369         // with checknull
    370         $result = $generator->GetPreparePHPValue('5', 'integer',true);
    371         $this->assertEqualOrDiff(5,$result);
    372         $result = $generator->GetPreparePHPValue('5', 'autoincrement',true);
    373         $this->assertEqualOrDiff(5,$result);
    374         $result = $generator->GetPreparePHPValue('$foo', 'string',true);
    375         $this->assertEqualOrDiff('\\\'$foo\\\'',$result);
    376         $result = $generator->GetPreparePHPValue('5.28', 'double',true);
    377         $this->assertEqualOrDiff(5.28,$result);
    378         $result = $generator->GetPreparePHPValue('5.26', 'float',true);
    379         $this->assertEqualOrDiff(5.26,$result);
    380         $result = $generator->GetPreparePHPValue('565469876543139798641315465463', 'numeric',true);
    381         $this->assertEqualOrDiff('565469876543139798641315465463',$result);
    382         $result = $generator->GetPreparePHPValue('565469876543139798641315465463', 'bigautoincrement',true);
    383         $this->assertEqualOrDiff('565469876543139798641315465463',$result);
    384 
    385     }
    386 
     145 
    387146    function testBuildSQLCondition(){
    388147        $doc ='<?xml version="1.0" encoding="UTF-8"?>
    389148<dao xmlns="http://jelix.org/ns/dao/1.0">
     
    470229        </method>
    471230    </factory>
    472231</dao>';
    473         $parser = new jDaoParser ();
    474         $parser->parse(simplexml_load_string($doc));
    475         $generator = new testMysqlDaoGenerator('cDao_foo_Jx_bar_Jx_mysql', 'cDaoRecord_foo_Jx_bar_Jx_mysql', $parser);
     232        $parser = new jDaoParser ($this->_selector);
     233        $parser->parse(simplexml_load_string($doc), $this->_tools);
     234        $generator = new testMysqlDaoGenerator($this->_selector, $this->_tools, $parser);
    476235
    477         $methods=$parser->getMethods();
     236        $methods = $parser->getMethods();
    478237
    479238        $where = $generator->BuildSQLCondition ($methods['method1']->getConditions()->condition, $parser->getProperties(),
    480239                                                $methods['method1']->getParameters(), false);
     
    589348        </method>
    590349    </factory>
    591350</dao>';
    592         $parser = new jDaoParser ();
    593         $parser->parse(simplexml_load_string($doc));
    594         $generator = new testMysqlDaoGenerator('cDao_foo_Jx_bar_Jx_mysql', 'cDaoRecord_foo_Jx_bar_Jx_mysql', $parser);
     351        $parser = new jDaoParser ($this->_selector);
     352        $parser->parse(simplexml_load_string($doc), $this->_tools);
     353        $generator = new testMysqlDaoGenerator($this->_selector, $this->_tools, $parser);
    595354
    596355        $methods=$parser->getMethods();
    597356
     
    642401      <property name="ownerlogin" fieldname="ownerlogin" datatype="string" />
    643402    </record>
    644403</dao>';
    645         $parser = new jDaoParser ();
    646         $parser->parse(simplexml_load_string($doc));
    647         $generator = new testMysqlDaoGenerator('cDao_foo_Jx_bar_Jx_mysql', 'cDaoRecord_foo_Jx_bar_Jx_mysql', $parser);
     404        $parser = new jDaoParser ($this->_selector);
     405        $parser->parse(simplexml_load_string($doc), $this->_tools);
     406        $generator = new testMysqlDaoGenerator($this->_selector, $this->_tools, $parser);
    648407
    649408        $pkFields=$generator->GetPropertiesBy('PkFields');
    650409        $this->assertTrue(count($pkFields) ==1);
     
    700459        </method>
    701460    </factory>
    702461</dao>';
    703         $parser = new jDaoParser ();
    704         $parser->parse(simplexml_load_string($doc));
    705         $generator = new testMysqlDaoGenerator('cDao_foo_Jx_bar_Jx_mysql', 'cDaoRecord_foo_Jx_bar_Jx_mysql', $parser);
     462        $parser = new jDaoParser ($this->_selector);
     463        $parser->parse(simplexml_load_string($doc), $this->_tools);
     464        $generator = new testMysqlDaoGenerator($this->_selector, $this->_tools, $parser);
    706465
    707466        $methods = $parser->getMethods();
    708467
     
    726485                                                $methods['method4']->getParameters(), false, $methods['method4']->getGroupBy());
    727486        $this->assertEqualOrDiff(' 1=1  GROUP BY `id_aclgrp`, `parent_id`, `name` ORDER BY `name` asc', $sql);
    728487
    729 
    730 
    731488        $sql = $generator->BuildConditions ($methods['method1']->getConditions(), $parser->getProperties(),
    732489                                                $methods['method1']->getParameters(), true,  $methods['method1']->getGroupBy());
    733490        $this->assertEqualOrDiff(' `grp`.`grouptype` = 1', $sql);
  • testapp/modules/jelix_tests/tests/jdao.parser_update.html_cli.php

     
    44* @subpackage  jelix_tests module
    55* @author      Jouanneau Laurent
    66* @contributor
    7 * @copyright   2006-2007 Jouanneau laurent
     7* @copyright   2006-2009 Jouanneau laurent
    88* @link        http://www.jelix.org
    99* @licence     GNU Lesser General Public Licence see LICENCE file or http://www.gnu.org/licenses/lgpl.html
    1010*/
    1111
    12 require_once(JELIX_LIB_PATH.'dao/jDaoCompiler.class.php');
     12require_once(dirname(__FILE__).'/daotests.lib.php');
    1313
     14
    1415class UTDao_parser_update extends jUnitTestCase {
    1516
     17    protected $_selector;
    1618    function setUp() {
    17         jDaoCompiler::$daoId ='';
    18         jDaoCompiler::$daoPath = '';
     19        if (!$this->_selector) {
     20          $this->_selector = new fakejSelectorDao("foo", "bar", "mysql");
     21        }
    1922    }
    2023
    2124    protected $methDatas=array(
     
    218221  </record>
    219222</dao>';
    220223
    221         $parser = new jDaoParser();
    222         $parser->parse(simplexml_load_string($dao),1);
     224        $parser = new testjDaoParser($this->_selector);
     225        $xml = simplexml_load_string($dao);
     226        $tools = new mysqlDbTools(null);
     227        $parser->testParseDatasource($xml);
     228        $parser->testParseRecord($xml,$tools);
    223229
    224230        foreach($this->methDatas as $k=>$t){
    225231            //$this->sendMessage("test good method ".$k);
     
    241247      array('<?xml version="1.0"?>
    242248          <method name="foo" type="update">
    243249          </method>',
    244           'jelix~daoxml.method.values.undefine', array('','','foo')
     250          'jelix~daoxml.method.values.undefine', array('foo~bar','','foo')
    245251          ),
    246252      array('<?xml version="1.0"?>
    247253          <method name="foo" type="update">
     
    249255                <value  value="" />
    250256            </values>
    251257          </method>',
    252           'jelix~daoxml.method.values.property.unknow', array('','','foo','')
     258          'jelix~daoxml.method.values.property.unknow', array('foo~bar','','foo','')
    253259          ),
    254260      array('<?xml version="1.0"?>
    255261          <method name="foo" type="update">
     
    257263                <value property="plop" value="" />
    258264            </values>
    259265          </method>',
    260           'jelix~daoxml.method.values.property.unknow', array('','','foo','plop')
     266          'jelix~daoxml.method.values.property.unknow', array('foo~bar','','foo','plop')
    261267          ),
    262268      array('<?xml version="1.0"?>
    263269          <method name="foo" type="update">
     
    265271                <value property="author_firstname" value="" />
    266272            </values>
    267273          </method>',
    268           'jelix~daoxml.method.values.property.bad', array('','','foo','author_firstname')
     274          'jelix~daoxml.method.values.property.bad', array('foo~bar','','foo','author_firstname')
    269275          ),
    270276      array('<?xml version="1.0"?>
    271277          <method name="foo" type="update">
     
    273279                <value property="id" value="" />
    274280            </values>
    275281          </method>',
    276           'jelix~daoxml.method.values.property.pkforbidden', array('','','foo','id')
     282          'jelix~daoxml.method.values.property.pkforbidden', array('foo~bar','','foo','id')
    277283          ),
    278284      array('<?xml version="1.0"?>
    279285          <method name="foo" type="update">
     
    281287                <value property="subject" value="abc" expr="\'abs\'"/>
    282288            </values>
    283289          </method>',
    284           'jelix~daoxml.method.values.valueexpr', array('','','foo','subject')
     290          'jelix~daoxml.method.values.valueexpr', array('foo~bar','','foo','subject')
    285291          ),
    286292
    287293    );
     
    303309  </record>
    304310</dao>';
    305311
    306         $parser = new jDaoParser();
    307         $parser->parse(simplexml_load_string($dao),1);
     312        $parser = new testjDaoParser($this->_selector);
     313        $xml = simplexml_load_string($dao);
     314        $tools = new mysqlDbTools(null);
     315        $parser->testParseDatasource($xml);
     316        $parser->testParseRecord($xml,$tools);
    308317
    309318        foreach($this->badmethDatas as $k=>$t){
    310319            //$this->sendMessage("test bad method ".$k);
     
    333342  </record>
    334343</dao>';
    335344
    336         $parser = new jDaoParser();
    337         $parser->parse(simplexml_load_string($dao),1);
     345        $parser = new testjDaoParser($this->_selector);
     346        $xml = simplexml_load_string($dao);
     347        $tools = new mysqlDbTools(null);
     348        $parser->testParseDatasource($xml);
     349        $parser->testParseRecord($xml,$tools);
    338350
    339351        //$this->sendMessage("test bad update method ");
    340352        $xml= simplexml_load_string('<?xml version="1.0"?>
     
    350362            $this->fail("Pas d'exception survenue !");
    351363        }catch(jDaoXmlException $e){
    352364            $this->assertEqual($e->getLocaleKey(), 'jelix~daoxml.method.update.forbidden');
    353             $this->assertEqual($e->getLocaleParameters(), array('','','tryupdate'));
     365            $this->assertEqual($e->getLocaleParameters(), array('foo~bar','','tryupdate'));
    354366        }catch(Exception $e){
    355367            $this->fail("Exception inconnue : ".$e->getMessage());
    356368        }
  • testapp/modules/jelix_tests/tests/jdbtools.html_cli.php

     
     1<?php
     2/**
     3* @package     testapp
     4* @subpackage  jelix_tests module
     5* @author      Laurent Jouanneau
     6* @contributor
     7* @copyright   2009 Laurent Jouanneau
     8* @link        http://jelix.org
     9* @licence     GNU Lesser General Public Licence see LICENCE file or http://www.gnu.org/licenses/lgpl.html
     10*/
     11
     12include_once (JELIX_LIB_PATH.'plugins/db/mysql/mysql.dbtools.php');
     13include_once (JELIX_LIB_PATH.'plugins/db/pgsql/pgsql.dbtools.php');
     14include_once (JELIX_LIB_PATH.'plugins/db/oci/oci.dbtools.php');
     15include_once (JELIX_LIB_PATH.'plugins/db/sqlite/sqlite.dbtools.php');
     16
     17
     18class UTjDbTools extends jUnitTestCase {
     19
     20
     21    function testEncloseName(){
     22
     23        $tools= new mysqlDbTools(null);
     24        $result = $tools->encloseName('foo');
     25        $this->assertEqualOrDiff('`foo`',$result);
     26
     27        $tools= new pgsqlDbTools(null);
     28        $result = $tools->encloseName('foo');
     29        $this->assertEqualOrDiff('"foo"',$result);
     30
     31        $tools= new ociDbTools(null);
     32        $result = $tools->encloseName('foo');
     33        $this->assertEqualOrDiff('foo',$result);
     34
     35        $tools= new sqliteDbTools(null);
     36        $result = $tools->encloseName('foo');
     37        $this->assertEqualOrDiff('foo',$result);
     38    }
     39   
     40   function testStringToPhpValue(){
     41   
     42        $tools= new mysqlDbTools(null);
     43
     44        try {
     45            $tools->stringToPhpValue('int','5', false);
     46            $this->fail("stringToPhpValue accepts int !!");
     47        } catch(Exception $e) {
     48            $this->pass();
     49        }
     50        try {
     51            $tools->stringToPhpValue( 'string','$foo',false);
     52            $this->fail("stringToPhpValue accepts string !!");
     53        } catch(Exception $e) {
     54            $this->pass();
     55        }
     56
     57        try {
     58            $tools->stringToPhpValue( 'autoincrement','5',false);
     59            $this->fail("stringToPhpValue accepts autoincrement !!");
     60        } catch(Exception $e) {
     61            $this->pass();
     62        }
     63
     64        // with no checknull
     65        $result = $tools->stringToPhpValue( 'integer','5',false);
     66        $this->assertEqualOrDiff(5,$result);
     67        $result = $tools->stringToPhpValue( 'float','5',false);
     68        $this->assertEqualOrDiff(5,$result);
     69        $result = $tools->stringToPhpValue( 'varchar','$foo',false);
     70        $this->assertEqualOrDiff('$foo',$result);
     71        $result = $tools->stringToPhpValue('varchar','$f\'oo', false);
     72        $this->assertEqualOrDiff('$f\'oo',$result);
     73        $result = $tools->stringToPhpValue('double','5.63', false);
     74        $this->assertEqualOrDiff(5.63,$result);
     75        $result = $tools->stringToPhpValue('float','5.63', false);
     76        $this->assertEqualOrDiff(5.63,$result);
     77        $result = $tools->stringToPhpValue('float','983298095.631212', false);
     78        $this->assertEqualOrDiff(983298095.631212,$result);
     79        $result = $tools->stringToPhpValue('numeric','565465465463', false);
     80        $this->assertEqualOrDiff('565465465463',$result);
     81        $result = $tools->stringToPhpValue('numeric','565469876543139798641315465463', false);
     82        $this->assertEqualOrDiff('565469876543139798641315465463',$result);
     83
     84        // with checknull
     85        $result = $tools->stringToPhpValue('integer','NULL', true);
     86        $this->assertEqualOrDiff(null,$result);
     87        $result = $tools->stringToPhpValue('varchar','NULL', true);
     88        $this->assertEqualOrDiff(null,$result);
     89    }
     90
     91
     92    function testEscapeValue(){
     93   
     94        $tools= new mysqlDbTools(null);
     95
     96        try {
     97            $tools->escapeValue('int','5', false);
     98            $this->fail("escapeValue accepts int !!");
     99        } catch(Exception $e) {
     100            $this->pass();
     101        }
     102        try {
     103            $tools->escapeValue( 'string','$foo',false);
     104            $this->fail("escapeValue accepts string !!");
     105        } catch(Exception $e) {
     106            $this->pass();
     107        }
     108
     109        try {
     110            $tools->escapeValue( 'autoincrement','5',false);
     111            $this->fail("escapeValue accepts autoincrement !!");
     112        } catch(Exception $e) {
     113            $this->pass();
     114        }
     115
     116
     117        // with no checknull
     118        $result = $tools->escapeValue( 'integer',5,false);
     119        $this->assertEqualOrDiff("5",$result);
     120        $result = $tools->escapeValue( 'numeric',598787232098320,false);
     121        $this->assertEqualOrDiff("598787232098320",$result);
     122        $result = $tools->escapeValue( 'numeric',59878723209832,false);
     123        $this->assertEqualOrDiff("59878723209832",$result);
     124        $result = $tools->escapeValue( 'numeric',5987872320983,false);
     125        $this->assertEqualOrDiff("5987872320983",$result);
     126        $result = $tools->escapeValue( 'numeric',598787232098,false);
     127        $this->assertEqualOrDiff("598787232098",$result);
     128        $result = $tools->escapeValue( 'numeric',59878723209,false);
     129        $this->assertEqualOrDiff("59878723209",$result);
     130        $result = $tools->escapeValue( 'numeric',5987872320,false);
     131        $this->assertEqualOrDiff("5987872320",$result);
     132        $result = $tools->escapeValue( 'integer',598787232,false);
     133        $this->assertEqualOrDiff("598787232",$result);
     134        $result = $tools->escapeValue( 'integer',59878723,false);
     135        $this->assertEqualOrDiff("59878723",$result);
     136        $result = $tools->escapeValue( 'integer',5987872,false);
     137        $this->assertEqualOrDiff("5987872",$result);
     138        $result = $tools->escapeValue( 'numeric',5987872320983209098238723,false);
     139        $this->assertEqualOrDiff("5987872320983209098238723",$result);
     140       
     141        $result = $tools->escapeValue( 'float',5,false);
     142        $this->assertEqualOrDiff("5",$result);
     143        $result = $tools->escapeValue( 'varchar','$foo',false);
     144        $this->assertEqualOrDiff('\'$foo\'',$result);
     145        $result = $tools->escapeValue('varchar','$f\'oo', false);
     146        $this->assertEqualOrDiff('\'$f\\\'oo\'',$result);
     147        $result = $tools->escapeValue('double',5.63, false);
     148        $this->assertEqualOrDiff('5.63',$result);
     149        $result = $tools->escapeValue('float',98084345.637655464, false);
     150        $this->assertEqualOrDiff('98084345.6377',$result);
     151        $result = $tools->escapeValue('decimal',98084345.637655464, false);
     152        $this->assertEqualOrDiff('98084345.637655464',$result);
     153        $result = $tools->escapeValue('numeric','565465465463', false);
     154        $this->assertEqualOrDiff('565465465463',$result);
     155        $result = $tools->escapeValue('numeric','565469876543139798641315465463', false);
     156        $this->assertEqualOrDiff('565469876543139798641315465463',$result);
     157
     158        // with checknull
     159        $result = $tools->escapeValue('integer',5, true);
     160        $this->assertEqualOrDiff('5',$result);
     161        $result = $tools->escapeValue('integer',null, true);
     162        $this->assertEqualOrDiff('NULL',$result);
     163        $result = $tools->escapeValue('varchar',null, true);
     164        $this->assertEqualOrDiff('NULL',$result);
     165    }
     166
     167
     168}
     169
  • testapp/modules/jelix_tests/tests/daotests.lib.php

     
     1<?php
     2/**
     3* @package     testapp
     4* @subpackage  jelix_tests module
     5* @author      Laurent Jouanneau
     6* @contributor
     7* @copyright   2009 Laurent Jouanneau
     8* @link        http://jelix.org
     9* @licence     GNU Lesser General Public Licence see LICENCE file or http://www.gnu.org/licenses/lgpl.html
     10*/
     11
     12require_once(JELIX_LIB_PATH.'dao/jDaoCompiler.class.php');
     13require_once(JELIX_LIB_PATH.'plugins/db/mysql/mysql.daobuilder.php');
     14include_once (JELIX_LIB_PATH.'plugins/db/mysql/mysql.dbtools.php');
     15
     16
     17class fakejSelectorDao extends jSelectorDao {
     18 
     19  function __construct($module='', $resource='', $driver='mysql') {
     20      $this->driver = $driver;
     21      $this->_compiler = 'jDaoCompiler';
     22      $this->_compilerPath = JELIX_LIB_PATH.'dao/jDaoCompiler.class.php';
     23      $this->module = $module;
     24      $this->resource = $resource;
     25      $this->_path = '';
     26      $this->_where =   '';
     27  }
     28}
     29
     30class testMysqlDaoGenerator extends mysqlDaoBuilder {
     31
     32    function GetPropertiesBy ($captureMethod){
     33        return $this->_getPropertiesBy ($captureMethod);
     34    }
     35
     36    function BuildSimpleConditions (&$fields, $fieldPrefix='', $forSelect=true){
     37        return $this->_buildSimpleConditions ($fields, $fieldPrefix, $forSelect);
     38    }
     39
     40    function BuildConditions($cond, $fields, $params=array(), $withPrefix=true, $groupby='') {
     41        return $this->_buildConditions ($cond, $fields, $params, $withPrefix, $groupby);
     42    }
     43
     44    function BuildSQLCondition ($condition, $fields, $params, $withPrefix){
     45        return $this->_buildSQLCondition ($condition, $fields, $params, $withPrefix, true);
     46    }
     47
     48    function GetPreparePHPValue($value, $fieldType, $checknull=true){
     49        return $this->tools->escapeValue($fieldType, $value, $checknull, true);
     50    }
     51
     52    function GetPreparePHPExpr($expr, $fieldType, $checknull=true, $forCondition=''){
     53        return $this->_preparePHPExpr($expr, $fieldType, $checknull, $forCondition);
     54    }
     55
     56    function GetSelectClause ($distinct=false){
     57        return $this->_getSelectClause ($distinct);
     58    }
     59
     60    function GetFromClause(){
     61        return $this->_getFromClause();
     62    }
     63}
     64
     65
     66class testDaoProperty {
     67    public $datatype;
     68    public $unifiedType;
     69    public $defaultValue=null;
     70    public $autoIncrement = false;
     71}
     72
     73
     74class testjDaoParser extends jDaoParser {
     75 
     76  function testParseDatasource($xml) {
     77      $this->parseDatasource($xml);
     78  }
     79  function testParseRecord($xml, $tools) {
     80      $this->parseRecord($xml, $tools);
     81  }
     82  function testParseFactory($xml) {
     83      $this->parseFactory($xml);
     84  }
     85}
  • testapp/modules/jelix_tests/tests/jdao.generator_select.html_cli.php

     
    99* @licence     GNU Lesser General Public Licence see LICENCE file or http://www.gnu.org/licenses/lgpl.html
    1010*/
    1111
    12 require_once(JELIX_LIB_PATH.'dao/jDaoCompiler.class.php');
    1312
    14 require_once(JELIX_LIB_PATH.'plugins/db/mysql/mysql.daobuilder.php');
     13require_once(dirname(__FILE__).'/daotests.lib.php');
    1514
    16 
    17 class testSelectMysqlDaoGenerator extends mysqlDaoBuilder {
    18 
    19     function GetSelectClause ($distinct=false){
    20         return $this->_getSelectClause ($distinct);
    21     }
    22 
    23     function GetFromClause(){
    24         return $this->_getFromClause();
    25     }
    26 
    27 }
    28 
    2915class UTDao_generator_select extends jUnitTestCase {
    3016
     17    protected $_selector;
     18    protected $_tools;
     19   
    3120    function setUp() {
    32         jDaoCompiler::$daoId ='';
    33         jDaoCompiler::$daoPath = '';
    34         jDaoCompiler::$dbType='mysql';
     21        $this->_selector = new fakejSelectorDao('foo','bar','mysql');
     22        $this->_tools= new mysqlDbTools(null);
    3523    }
    3624
     25
    3726    function testBuildSelectClause(){
    3827        $doc ='<?xml version="1.0"?>
    3928<dao xmlns="http://jelix.org/ns/dao/1.0">
     
    4635      <property name="price" fieldname="price" datatype="float"/>
    4736   </record>
    4837</dao>';
    49         $parser = new jDaoParser ();
    50         $parser->parse(simplexml_load_string($doc));
    51         $generator= new testSelectMysqlDaoGenerator('cDao_foo_Jx_bar_Jx_mysql', 'cDaoRecord_foo_Jx_bar_Jx_mysql', $parser);
     38        $parser = new jDaoParser ($this->_selector);
     39        $parser->parse(simplexml_load_string($doc), $this->_tools);
     40        $generator= new testMysqlDaoGenerator($this->_selector, $this->_tools, $parser);
    5241        $result = $generator->GetSelectClause();
    5342        $this->assertEqualOrDiff('SELECT `product_test`.`id`, `product_test`.`name`, `product_test`.`price`',$result);
    5443
     
    6352      <property name="price" fieldname="price" datatype="float"/>
    6453   </record>
    6554</dao>';
    66         $parser = new jDaoParser ();
    67         $parser->parse(simplexml_load_string($doc));
     55        $parser = new jDaoParser ($this->_selector);
     56        $parser->parse(simplexml_load_string($doc), $this->_tools);
    6857
    69         $generator= new testSelectMysqlDaoGenerator('cDao_foo_Jx_bar_Jx_mysql', 'cDaoRecord_foo_Jx_bar_Jx_mysql', $parser);
     58        $generator= new testMysqlDaoGenerator($this->_selector, $this->_tools, $parser);
    7059        $result = $generator->GetSelectClause();
    7160        $this->assertEqualOrDiff('SELECT `p`.`id`, `p`.`name`, `p`.`price`',$result);
    7261    }
     
    8675      <property name="price" fieldname="price" datatype="float"/>
    8776   </record>
    8877</dao>';
    89         $parser = new jDaoParser ();
    90         $parser->parse(simplexml_load_string($doc));
     78        $parser = new jDaoParser ($this->_selector);
     79        $parser->parse(simplexml_load_string($doc), $this->_tools);
    9180
    92         $generator= new testSelectMysqlDaoGenerator('cDao_foo_Jx_bar_Jx_mysql', 'cDaoRecord_foo_Jx_bar_Jx_mysql', $parser);
     81        $generator= new testMysqlDaoGenerator($this->_selector, $this->_tools, $parser);
    9382        $result = $generator->GetSelectClause();
    9483        $this->assertEqualOrDiff('SELECT `product_test`.`id`, `product_test`.`name`, `product_test`.`price`',$result);
    9584
     
    10493      <property name="price" fieldname="price" datatype="float"/>
    10594   </record>
    10695</dao>';
    107         $parser = new jDaoParser ();
    108         $parser->parse(simplexml_load_string($doc));
     96        $parser = new jDaoParser ($this->_selector);
     97        $parser->parse(simplexml_load_string($doc), $this->_tools);
    10998
    110         $generator= new testSelectMysqlDaoGenerator('cDao_foo_Jx_bar_Jx_mysql', 'cDaoRecord_foo_Jx_bar_Jx_mysql', $parser);
     99        $generator= new testMysqlDaoGenerator($this->_selector, $this->_tools, $parser);
    111100        $result = $generator->GetSelectClause();
    112101        $this->assertEqualOrDiff('SELECT `product_test`.`id`, TOUPPER(`product_test`.`name`) as `name`, `product_test`.`price`',$result);
    113102
     
    122111      <property name="price" fieldname="price" datatype="float"/>
    123112   </record>
    124113</dao>';
    125         $parser = new jDaoParser ();
    126         $parser->parse(simplexml_load_string($doc));
     114        $parser = new jDaoParser ($this->_selector);
     115        $parser->parse(simplexml_load_string($doc), $this->_tools);
    127116
    128         $generator= new testSelectMysqlDaoGenerator('cDao_foo_Jx_bar_Jx_mysql', 'cDaoRecord_foo_Jx_bar_Jx_mysql', $parser);
     117        $generator= new testMysqlDaoGenerator($this->_selector, $this->_tools, $parser);
    129118        $result = $generator->GetSelectClause();
    130119        $this->assertEqualOrDiff('SELECT `p`.`id`, TOUPPER(`p`.`name`) as `name`, `p`.`price`',$result);
    131120
     
    141130      <property name="price" fieldname="price" datatype="float"/>
    142131   </record>
    143132</dao>';
    144         $parser = new jDaoParser ();
    145         $parser->parse(simplexml_load_string($doc));
     133        $parser = new jDaoParser ($this->_selector);
     134        $parser->parse(simplexml_load_string($doc), $this->_tools);
    146135
    147         $generator= new testSelectMysqlDaoGenerator('cDao_foo_Jx_bar_Jx_mysql', 'cDaoRecord_foo_Jx_bar_Jx_mysql', $parser);
     136        $generator= new testMysqlDaoGenerator($this->_selector, $this->_tools, $parser);
    148137        $result = $generator->GetSelectClause();
    149138        $this->assertEqualOrDiff('SELECT `product_test`.`id`, TOUPPER(name) as `name`, `product_test`.`price`',$result);
    150139
     
    160149      <property name="price" fieldname="price" datatype="float"/>
    161150   </record>
    162151</dao>';
    163         $parser = new jDaoParser ();
    164         $parser->parse(simplexml_load_string($doc));
     152        $parser = new jDaoParser ($this->_selector);
     153        $parser->parse(simplexml_load_string($doc), $this->_tools);
    165154
    166         $generator= new testSelectMysqlDaoGenerator('cDao_foo_Jx_bar_Jx_mysql', 'cDaoRecord_foo_Jx_bar_Jx_mysql', $parser);
     155        $generator= new testMysqlDaoGenerator($this->_selector, $this->_tools, $parser);
    167156        $result = $generator->GetSelectClause();
    168157        $this->assertEqualOrDiff('SELECT `product_test`.`id`, CONCAT(name,\\\' \\\',price) as `name`, `product_test`.`price`',$result);
    169158
  • testapp/modules/jelix_tests/tests/jdao.parser.html_cli.php

     
    99* @licence     GNU Lesser General Public Licence see LICENCE file or http://www.gnu.org/licenses/lgpl.html
    1010*/
    1111
    12 require_once(JELIX_LIB_PATH.'dao/jDaoCompiler.class.php');
     12require_once(dirname(__FILE__).'/daotests.lib.php');
    1313
    1414class UTDao_parser extends jUnitTestCase {
    1515
     16    protected $_selector;
     17    protected $_tools;
    1618    function setUp() {
    17         jDaoCompiler::$daoId ='';
    18         jDaoCompiler::$daoPath = '';
     19        if (!$this->_selector) {
     20            $this->_selector = new fakejSelectorDao("foo", "bar", "mysql");
     21        }
     22        if (!$this->_tools) {
     23            $this->_tools= new mysqlDbTools(null);
     24        }
    1925    }
    2026
    2127
     
    190196        foreach($this->dsTest as $k=>$t){
    191197            //$this->sendMessage("test good datasource ".$k);
    192198            $xml= simplexml_load_string($t[0]);
    193             $p = new jDaoParser();
     199            $p = new testjDaoParser($this->_selector);
    194200            try{
    195                 $p->parse($xml,2);
     201                $p->testParseDatasource($xml);
    196202                $this->assertComplexIdenticalStr($p, $t[1]);
    197203            }catch(jDaoXmlException $e){
    198204                $this->fail("Exception sur le contenu xml inattendue : ".$e->getMessage().' ('.$e->getLocaleKey().')');
     
    212218  </datasources>
    213219</dao>',
    214220'jelix~daoxml.datasource.missing',
    215 array('','')
     221array('foo~bar','')
    216222),
    217223
    218224        array('<?xml version="1.0"?>
     
    222228  </datasources>
    223229</dao>',
    224230'jelix~daoxml.table.name',
    225 array('','')
     231array('foo~bar','')
    226232
    227233),
    228234
     
    233239  </datasources>
    234240</dao>',
    235241'jelix~daoxml.primarykey.missing',
    236 array('','')
     242array('foo~bar','')
    237243
    238244),
    239245        array('<?xml version="1.0"?>
     
    243249  </datasources>
    244250</dao>',
    245251'jelix~daoxml.primarykey.missing',
    246 array('','')
     252array('foo~bar','')
    247253
    248254),
    249255        array('<?xml version="1.0"?>
     
    254260  </datasources>
    255261</dao>',
    256262'jelix~daoxml.table.two.many',
    257 array('','')
     263array('foo~bar','')
    258264
    259265),
    260266
     
    267273  </datasources>
    268274</dao>',
    269275'jelix~daoxml.foreignkey.missing',
    270 array('','')
     276array('foo~bar','')
    271277
    272278),
    273279
     
    280286  </datasources>
    281287</dao>',
    282288'jelix~daoxml.foreignkey.missing',
    283 array('','')
     289array('foo~bar','')
    284290
    285291),
    286292
     
    293299  </datasources>
    294300</dao>',
    295301'jelix~daoxml.foreignkey.missing',
    296 array('','')
     302array('foo~bar','')
    297303
    298304),
    299305
     
    304310        foreach($this->dsTestbad as $k=>$t){
    305311            //$this->sendMessage("test bad datasource ".$k);
    306312            $xml= simplexml_load_string($t[0]);
    307             $p = new jDaoParser();
     313            $p = new testjDaoParser($this->_selector);
    308314            try{
    309                 $p->parse($xml,2);
     315                $p->testParseDatasource($xml);
    310316                $this->fail("Pas d'exception survenue !");
    311317            }catch(jDaoXmlException $e){
    312318                $this->assertEqual($e->getLocaleKey(), $t[1]);
     
    328334            <string p="fieldName" value="label"/>
    329335            <string p="table" value="news"/>
    330336            <string p="datatype" value="string"/>
     337            <string p="unifiedType" value="varchar"/>
     338            <boolean p="autoIncrement" value="false" />
    331339            <null p="regExp"/>
    332340            <boolean p="required" value="false"/>
    333341            <boolean p="requiredInConditions" value="false"/>
     
    352360            <string p="fieldName" value="label"/>
    353361            <string p="table" value="news"/>
    354362            <string p="datatype" value="string"/>
     363            <string p="unifiedType" value="varchar"/>
     364            <boolean p="autoIncrement" value="false" />
    355365            <null p="regExp"/>
    356366            <boolean p="required" value="false"/>
    357367            <boolean p="requiredInConditions" value="false"/>
     
    363373            <string p="sequenceName" value="" />
    364374            <null p="maxlength"/>
    365375            <null p="minlength"/>
    366             <string p="defaultValue" value="no label" />
     376            <string p="defaultValue" value="\'no label\'" />
    367377            <boolean p="ofPrimaryTable" value="true" />
    368378        </object>'
    369379        ),
     
    376386            <string p="fieldName" value="firstname"/>
    377387            <string p="table" value="news_author"/>
    378388            <string p="datatype" value="string"/>
     389            <string p="unifiedType" value="varchar"/>
     390            <boolean p="autoIncrement" value="false" />
    379391            <null p="regExp"/>
    380392            <boolean p="required" value="false"/>
    381393            <boolean p="requiredInConditions" value="false"/>
     
    387399            <string p="sequenceName" value="" />
    388400            <null p="maxlength"/>
    389401            <null p="minlength"/>
     402            <null p="defaultValue" />
    390403            <boolean p="ofPrimaryTable" value="false" />
    391404        </object>'
    392405        ),
    393406
    394     array(
     407        array(
    395408        '<?xml version="1.0"?>
    396409        <property name="id" fieldname="news_id" datatype="autoincrement" />',
    397410        '<?xml version="1.0"?>
     
    400413            <string p="fieldName" value="news_id"/>
    401414            <string p="table" value="news"/>
    402415            <string p="datatype" value="autoincrement"/>
     416            <string p="unifiedType" value="integer"/>
     417            <boolean p="autoIncrement" value="true" />
    403418            <null p="regExp"/>
    404419            <boolean p="required" value="false"/>
    405420            <boolean p="requiredInConditions" value="true"/>
     
    422437            <string p="fieldName" value="label"/>
    423438            <string p="table" value="news"/>
    424439            <string p="datatype" value="string"/>
     440            <string p="unifiedType" value="varchar"/>
     441            <boolean p="autoIncrement" value="false" />
    425442            <null p="regExp"/>
    426443            <boolean p="required" value="false"/>
    427444            <boolean p="requiredInConditions" value="false"/>
     
    445462            <string p="fieldName" value="label"/>
    446463            <string p="table" value="news"/>
    447464            <string p="datatype" value="string"/>
     465            <string p="unifiedType" value="varchar"/>
     466            <boolean p="autoIncrement" value="false" />
    448467            <null p="regExp"/>
    449468            <boolean p="required" value="false"/>
    450469            <boolean p="requiredInConditions" value="false"/>
     
    470489  </datasources>
    471490</dao>';
    472491
    473         $parser = new jDaoParser();
    474         $parser->parse(simplexml_load_string($dao),2);
     492        $parser = new testjDaoParser($this->_selector);
     493        $parser->testParseDatasource(simplexml_load_string($dao));
    475494
    476495        foreach($this->propDatas as $k=>$t){
    477496            //$this->sendMessage("test good property ".$k);
    478497            $xml= simplexml_load_string($t[0]);
    479498            try{
    480                 $p = new jDaoProperty($xml, $parser);
    481                 $this->assertComplexIdenticalStr($p, $t[1]);
     499                $p = new jDaoProperty($xml, $parser, $this->_tools);
     500                $this->assertComplexIdenticalStr($p, $t[1], "test $k");
    482501            }catch(jDaoXmlException $e){
    483502                $this->fail("Exception sur le contenu xml inattendue : ".$e->getMessage().' ('.$e->getLocaleKey().')');
    484503            }catch(Exception $e){
     
    486505            }
    487506        }
    488507    }
    489 
    490508}
    491509
    492 
    493 ?>
    494  No newline at end of file
  • testapp/modules/jelix_tests/tests/jdao.parser2.html_cli.php

     
    44* @subpackage  jelix_tests module
    55* @author      Jouanneau Laurent
    66* @contributor
    7 * @copyright   2006-2007 Jouanneau laurent
     7* @copyright   2006-2009 Jouanneau laurent
    88* @link        http://www.jelix.org
    99* @licence     GNU Lesser General Public Licence see LICENCE file or http://www.gnu.org/licenses/lgpl.html
    1010*/
     11require_once(dirname(__FILE__).'/daotests.lib.php');
    1112
    12 require_once(JELIX_LIB_PATH.'dao/jDaoCompiler.class.php');
    1313
    1414class UTDao_parser2 extends jUnitTestCase {
    1515
     16    protected $_selector;
    1617    function setUp() {
    17         jDaoCompiler::$daoId ='';
    18         jDaoCompiler::$daoPath = '';
     18        if (!$this->_selector) {
     19          $this->_selector = new fakejSelectorDao("foo", "bar", "mysql");
     20        }
    1921    }
    2022
    2123    protected $methDatas=array(
     
    380382  </record>
    381383</dao>';
    382384
    383         $parser = new jDaoParser();
    384         $parser->parse(simplexml_load_string($dao),1);
     385        $parser = new testjDaoParser($this->_selector);
     386        $doc = simplexml_load_string($dao);
     387        $parser->testParseDatasource($doc);
     388        $parser->testParseRecord($doc, new mysqlDbTools(null));
    385389
    386390        foreach($this->methDatas as $k=>$t){
    387391            //$this->sendMessage("test good method ".$k);
     
    407411                <orderitem property="publishdate" way="$afoo"/>
    408412            </order>
    409413          </method>',
    410           'jelix~daoxml.method.orderitem.parameter.unknow', array('','','foo','$afoo')
     414          'jelix~daoxml.method.orderitem.parameter.unknow', array('foo~bar','','foo','$afoo')
    411415          ),
    412416
    413417    );
     
    429433  </record>
    430434</dao>';
    431435
    432         $parser = new jDaoParser();
    433         $parser->parse(simplexml_load_string($dao),1);
    434 
     436        $parser = new testjDaoParser($this->_selector);
     437        $doc = simplexml_load_string($dao);
     438        $parser->testParseDatasource($doc);
     439        $parser->testParseRecord($doc, new mysqlDbTools(null));
     440       
    435441        foreach($this->badmethDatas as $k=>$t){
    436442            //$this->sendMessage("test bad method ".$k);
    437443            $xml= simplexml_load_string($t[0]);
  • lib/jelix-scripts/commands/createform.cmd.php

     
    5353        $gJConfig->startModule = $this->_parameters['module'];
    5454        jContext::push($this->_parameters['module']);
    5555
     56        $tools = jDb::getTools();
     57       
    5658        // we're going to parse the dao
    57         $selector = new jSelectorDao($dao, '',false);
     59        $selector = new jSelectorDao($dao,'');
    5860
    59         jDaoCompiler::$daoId = $selector->toString();
    60         jDaoCompiler::$daoPath = $selector->getPath();
    61         jDaoCompiler::$dbType = $selector->driver;
    62 
    6361        $doc = new DOMDocument();
    64 
    65         if(!$doc->load(jDaoCompiler::$daoPath)){
    66            throw new jException('jelix~daoxml.file.unknow', jDaoCompiler::$daoPath);
     62        $daoPath = $selector->getPath();
     63       
     64        if(!$doc->load($daoPath)){
     65           throw new jException('jelix~daoxml.file.unknow', $daoPath);
    6766        }
    6867
    6968        if($doc->documentElement->namespaceURI != JELIX_NAMESPACE_BASE.'dao/1.0'){
    70            throw new jException('jelix~daoxml.namespace.wrong',array(jDaoCompiler::$daoPath, $doc->namespaceURI));
     69           throw new jException('jelix~daoxml.namespace.wrong',array($daoPath, $doc->namespaceURI));
    7170        }
    7271
    73         $parser = new jDaoParser ();
    74         $parser->parse(simplexml_import_dom($doc));
     72        $parser = new jDaoParser ($selector);
     73        $parser->parse(simplexml_import_dom($doc), $tools);
    7574
    7675        // know we generate the form file
    7776
     
    8483            if( !$property->ofPrimaryTable) {
    8584                continue;
    8685            }
    87             if($property->isPK && ($property->datatype =='autoincrement' ||
    88                                    $property->datatype =='bigautoincrement')) {
     86            if($property->isPK && $property->autoIncrement) {
    8987                continue;
    9088            }
    9189
     
    106104            //    $attr.=' defaultvalue=""';
    107105            $datatype='';
    108106            $tag = 'input';
    109             switch($property->datatype){
    110                 case 'autoincrement':
    111                 case 'bigautoincrement':
    112                 case 'int':
     107            switch($property->unifiedType){
    113108                case 'integer':
    114109                case 'numeric':
    115110                    $datatype='integer';
     
    128123                    $datatype='decimal';
    129124                    break;
    130125                case 'text':
     126                case 'blob':
    131127                    $tag='textarea';
    132128                    break;
    133129                case 'boolean':
  • lib/jelix-scripts/commands/createdao.cmd.php

     
    7878         $primarykeys='';
    7979         foreach($fields as $fieldname=>$prop){
    8080
    81             switch(strtolower($prop->type)){
    82 
    83                case 'clob':
    84                case 'text':
    85                case 'mediumtext':
    86                case 'longtext':
    87                case 'tinytext':
    88                   $type='text';
    89                   break;
    90                case 'varchar2':
    91                case 'varchar':
    92                case 'char':
    93                case 'enum':
    94                case 'bpchar':
    95                case 'set':
    96                   $type='string';
    97                   break;
    98                case 'number':
    99                case 'tinyint':
    100                case 'numeric':
    101                case 'int':
    102                case 'integer':
    103                case 'smallint':
    104                case 'year':
    105                   if($prop->autoIncrement ){
    106                      $type='autoincrement';
    107                   }else{
    108                      $type='int';
    109                   }
    110                   break;
    111 
    112                case 'mediumint':
    113                case 'bigint':
    114                   if($prop->autoIncrement ){
    115                      $type='bigautoincrement';
    116                   }else{
    117                      $type='numeric';
    118                   }
    119                   break;
    120                case 'float':
    121                case 'double':
    122                case 'decimal':
    123                   $type='float';
    124                   break;
    125 
    126                case 'date':
    127                   $type='date';
    128                   break;
    129                case 'timestamp':
    130                case 'datetime':
    131                   $type='datetime';
    132                   break;
    133                case 'time':
    134                   $type='time';
    135                   break;
    136                case 'bool':
    137                case 'boolean':
    138                   $type='boolean';
    139                   break;
    140                default:
    141                   $type='';
     81            $properties.="\n        <property name=\"$fieldname\" fieldname=\"$fieldname\"";
     82            $properties.=' datatype="'.$prop->type.'"';
     83            if($prop->primary) {
     84               if($primarykeys != '')
     85                  $primarykeys.=','.$fieldname;
     86               else
     87                  $primarykeys.=$fieldname;
    14288            }
     89            if($prop->notNull && !$prop->autoIncrement)
     90               $properties.=' required="true"';
     91           
     92            if($prop->autoIncrement)
     93                $properties.=' autoincrement="true"';
    14394
    144             if($type!=''){
    145                $properties.="\n        <property name=\"$fieldname\" fieldname=\"$fieldname\"";
    146                $properties.=' datatype="'.$type.'"';
    147                if($prop->primary){
    148                   if($primarykeys != '')
    149                      $primarykeys.=','.$fieldname;
    150                   else
    151                      $primarykeys.=$fieldname;
    152                }
    153                if($prop->notNull && !$prop->autoIncrement)
    154                   $properties.=' required="true"';
    155 
    156                if($prop->hasDefault) {
    157                    $properties.=' default="'.htmlspecialchars($prop->default).'"';
    158                }
    159                if ($prop->length) {
    160                     $properties.=' maxlength="'.$prop->length.'"';
    161                }
    162                if ($prop->sequence) {
    163                     $properties.=' sequence="'.$prop->sequence.'"';
    164                }
    165                $properties.='/>';
     95            if($prop->hasDefault) {
     96                $properties.=' default="'.htmlspecialchars($prop->default).'"';
    16697            }
     98            if ($prop->length) {
     99                 $properties.=' maxlength="'.$prop->length.'"';
     100            }
     101            if ($prop->sequence) {
     102                 $properties.=' sequence="'.$prop->sequence.'"';
     103            }
     104            $properties.='/>';
    167105
    168106         }
    169107
  • lib/jelix-scripts/templates/dao_empty.xml.tpl

     
    44        <primarytable name="%%table%%" realname="%%table%%" primarykey=""/>
    55    </datasources>
    66    <record>
    7     <!--<property name="" fieldname="" datatype="string/int/float/autoincrement/date"
     7    <!--<property name="" fieldname="" datatype=""
    88        required="yes"
    99        maxlength="" minlength="" regexp=""
    10         sequence=""
     10        sequence="" autoincrement="false"
    1111        updatepattern="" insertpattern="" selectpattern=""
    1212    />-->
    1313    </record>
  • lib/jelix/plugins/db/sqlite/sqlite.daobuilder.php

     
    1818
    1919    protected $propertiesListForInsert = 'PrimaryFieldsExcludeAutoIncrement';
    2020
    21     function __construct($factoryClassName, $recordClassName, $daoDefinition){
    22         parent::__construct($factoryClassName, $recordClassName, $daoDefinition);
    23 
    24     }
    25 
    2621    protected function genSelectPattern ($pattern, $table, $fieldname, $propname ){
    2722        if ($pattern =='%s'){
    2823            $field = $table.$this->_encloseName($fieldname).' as '.$this->_encloseName($propname);
  • lib/jelix/plugins/db/sqlite/sqlite.dbtools.php

     
    44* @subpackage db_driver
    55* @author     Loic Mathaud
    66* @contributor Laurent Jouanneau
    7 * @copyright  2006 Loic Mathaud, 2007 Laurent Jouanneau
     7* @copyright  2006 Loic Mathaud, 2007-2009 Laurent Jouanneau
    88* @link      http://www.jelix.org
    99* @licence  http://www.gnu.org/licenses/lgpl.html GNU Lesser General Public Licence, see LICENCE file
    1010*/
    1111
    1212/**
    13  * classe d'outils pour gérer une base de données
     13 * tools to manage a sqlite database
    1414 * @package    jelix
    1515 * @subpackage db_driver
    1616 */
    1717class sqliteDbTools extends jDbTools {
    1818
     19    protected $typesInfo = array(
     20      // type                  native type        unified type  minvalue     maxvalue   minlength  maxlength
     21      'bool'            =>array('integer',          'boolean',  0,           1,          null,     null),
     22      'boolean'         =>array('integer',          'boolean',  0,           1,          null,     null),
     23      'bit'             =>array('integer',          'integer',  0,           1,          null,     null),
     24      'tinyint'         =>array('integer',          'integer',  -128,        127,        null,     null),
     25      'smallint'        =>array('integer',          'integer',  -32768,      32767,      null,     null),
     26      'mediumint'       =>array('integer',          'integer',  -8388608,    8388607,    null,     null),
     27      'integer'         =>array('integer',          'integer',  -2147483648, 2147483647, null,     null),
     28      'int'             =>array('integer',          'integer',  -2147483648, 2147483647, null,     null),
     29      'bigint'          =>array('numeric',          'numeric',  '-9223372036854775808', '9223372036854775807', null, null),
     30      'serial'          =>array('numeric',          'numeric',  '-9223372036854775808', '9223372036854775807', null, null),
     31      'bigserial'       =>array('numeric',          'numeric',  '-9223372036854775808', '9223372036854775807', null, null),
     32      'autoincrement'   =>array('integer',          'integer',  -2147483648, 2147483647, null,     null), // for old dao files
     33      'bigautoincrement'=>array('numeric',           'numeric',  '-9223372036854775808', '9223372036854775807', null, null),// for old dao files
     34
     35      'float'           =>array('float',            'float',    null,       null,       null,     null), //4bytes
     36      'money'           =>array('real',             'float',    null,       null,       null,     null), //4bytes
     37      'double precision'=>array('double',           'decimal',  null,       null,       null,     null), //8bytes
     38      'double'          =>array('double',           'decimal',  null,       null,       null,     null), //8bytes
     39      'real'            =>array('real',             'decimal',  null,       null,       null,     null), //8bytes
     40      'number'          =>array('real',             'decimal',  null,       null,       null,     null), //8bytes
     41      'binary_float'    =>array('double',           'float',    null,       null,       null,     null), //4bytes
     42      'binary_double'   =>array('double',           'decimal',  null,       null,       null,     null), //8bytes
     43     
     44      'numeric'         =>array('numeric',          'numeric',  null,       null,       null,     null),
     45      'decimal'         =>array('real',             'decimal',  null,       null,       null,     null),
     46      'dec'             =>array('real',             'decimal',  null,       null,       null,     null),
     47
     48      'date'            =>array('date',       'date',       null,       null,       10,    10),
     49      'time'            =>array('time',       'time',       null,       null,       8,     8),
     50      'datetime'        =>array('datetime',   'datetime',   null,       null,       19,    19),
     51      'timestamp'       =>array('datetime',   'datetime',   null,       null,       19,    19), // oracle/pgsql timestamp
     52      'utimestamp'      =>array('integer',    'integer',    0,          2147483647, null,  null), // mysql timestamp
     53      'year'            =>array('integer',    'year',       null,       null,       2,     4),
     54      'interval'        =>array('datetime',   'datetime',   null,       null,       19,    19),
     55
     56      'char'            =>array('char',       'char',       null,       null,       0,     255),
     57      'nchar'           =>array('char',       'char',       null,       null,       0,     255),
     58      'varchar'         =>array('varchar',    'varchar',    null,       null,       0,     65535),
     59      'varchar2'        =>array('varchar',    'varchar',    null,       null,       0,     4000),
     60      'nvarchar2'       =>array('varchar',    'varchar',    null,       null,       0,     4000),
     61      'character'       =>array('varchar',    'varchar',    null,       null,       0,     65535),
     62      'character varying'=>array('varchar',   'varchar',    null,       null,       0,     65535),
     63      'name'            =>array('varchar',    'varchar',    null,       null,       0,     64),
     64      'longvarchar'     =>array('varchar',    'varchar',    null,       null,       0,     65535),
     65      'string'          =>array('varchar',    'varchar',    null,       null,       0,     65535),// for old dao files
     66
     67      'tinytext'        =>array('text',   'text',       null,       null,       0,     255),
     68      'text'            =>array('text',       'text',       null,       null,       0,     65535),
     69      'mediumtext'      =>array('text', 'text',       null,       null,       0,     16777215),
     70      'longtext'        =>array('text',   'text',       null,       null,       0,     0),
     71      'long'            =>array('text',   'text',       null,       null,       0,     0),
     72      'clob'            =>array('text',   'text',       null,       null,       0,     0),
     73      'nclob'           =>array('text',   'text',       null,       null,       0,     0),
     74
     75
     76      'tinyblob'        =>array('blob',   'blob',       null,       null,       0,     255),
     77      'blob'            =>array('blob',       'blob',       null,       null,       0,     65535),
     78      'mediumblob'      =>array('blob', 'blob',       null,       null,       0,     16777215),
     79      'longblob'        =>array('blob',   'blob',       null,       null,       0,     0),
     80      'bfile'           =>array('blob',   'blob',       null,       null,       0,     0),
     81     
     82      'bytea'           =>array('blob',   'blob',       null,       null,       0,     0),
     83      'binary'          =>array('blob',     'binary',     null,       null,       0,     255),
     84      'varbinary'       =>array('blob',  'varbinary',  null,       null,       0,     255),
     85      'raw'             =>array('blob',  'varbinary',  null,       null,       0,     2000),
     86      'long raw'        =>array('blob',  'varbinary',  null,       null,       0,     0),
     87
     88      'enum'            =>array('varchar',    'varchar',    null,       null,       0,     65535),
     89      'set'             =>array('varchar',    'varchar',    null,       null,       0,     65535),
     90      'xmltype'         =>array('varchar',    'varchar',    null,       null,       0,     65535),
     91
     92      'point'           =>array('varchar',    'varchar',    null,       null,       0,     16),
     93      'line'            =>array('varchar',    'varchar',    null,       null,       0,     32),
     94      'lsed'            =>array('varchar',    'varchar',    null,       null,       0,     32),
     95      'box'             =>array('varchar',    'varchar',    null,       null,       0,     32),
     96      'path'            =>array('varchar',    'varchar',    null,       null,       0,     65535),
     97      'polygon'         =>array('varchar',    'varchar',    null,       null,       0,     65535),
     98      'circle'          =>array('varchar',    'varchar',    null,       null,       0,     24),
     99      'cidr'            =>array('varchar',    'varchar',    null,       null,       0,     24),
     100      'inet'            =>array('varchar',    'varchar',    null,       null,       0,     24),
     101      'macaddr'         =>array('integer',    'integer',    0,          0xFFFFFFFFFFFF, null,       null),
     102      'bit varying'     =>array('varchar',    'varchar',    null,       null,       0,     65535),
     103      'arrays'          =>array('varchar',    'varchar',    null,       null,       0,     65535),
     104      'complex types'   =>array('varchar',    'varchar',    null,       null,       0,     65535),
     105    );
     106
    19107    /**
    20     * retourne la liste des tables
    21     * @return   array    $tab[] = $nomDeTable
     108    * returns the list of tables
     109    * @return   array    list of table names
    22110    */
    23     protected function _getTableList (){
     111    public function getTableList (){
    24112        $results = array ();
    25113
    26         $rs = $this->_connector->query('SELECT name FROM sqlite_master WHERE type="table"');
     114        $rs = $this->_conn->query('SELECT name FROM sqlite_master WHERE type="table"');
    27115
    28116        while ($line = $rs->fetch ()){
    29117            $results[] = $line->name;
     
    33121    }
    34122
    35123    /**
    36     * récupère la liste des champs pour une base donnée.
    37     * @return   array    $tab[NomDuChamp] = obj avec prop (tye, length, lengthVar, notnull)
     124    * retrieve the list of fields of a table
     125    * @return   array    keys are field names and values are jDbFieldProperties objects
    38126    */
    39     protected function _getFieldList ($tableName) {
     127    public function getFieldList ($tableName) {
     128        $tableName = $this->_conn->prefixTable($tableName);
    40129        $results = array ();
    41130
    42131        $query = "PRAGMA table_info(". sqlite_escape_string($tableName) .")";
    43         $rs = $this->_connector->query($query);
     132        $rs = $this->_conn->query($query);
    44133        while ($line = $rs->fetch()) {
    45134            $field = new jDbFieldProperties();
    46135            $field->name = $line->name;
     
    57146                $field->type = $line->type;
    58147            }
    59148
     149            $typeinfo = $this->getTypeInfo($field->type);
     150            $field->unifiedType = $typeinfo[1];
     151            $field->maxValue = $typeinfo[3];
     152            $field->minValue = $typeinfo[2];
     153            $field->maxLength = $typeinfo[5];
     154            $field->minLength = $typeinfo[4];
     155
     156            if ($field->length !=0)
     157                $field->maxLength = $field->length;
     158
    60159            if ($field->type == 'integer' && $field->primary) {
    61160                $field->autoIncrement = true;
    62161            }
  • lib/jelix/plugins/db/intuition/intuition.daobuilder.php

     
    44* @subpackage db_driver
    55* @author     Laurent Jouanneau
    66* @contributor
    7 * @copyright  2007 Laurent Jouanneau
     7* @copyright  2007-2009 Laurent Jouanneau
    88* @link      http://www.jelix.org
    99* @licence  http://www.gnu.org/licenses/lgpl.html GNU Lesser General Public Licence, see LICENCE file
    1010*/
     
    1616 */
    1717class intuitionDaoBuilder extends jDaoGenerator {
    1818
    19 
    20     function __construct($factoryClassName, $recordClassName, $daoDefinition){
    21         parent::__construct($factoryClassName, $recordClassName, $daoDefinition);
    22 
    23     }
    24 
    2519}
  • lib/jelix/plugins/db/mysql/mysql.dbtools.php

     
    2121 */
    2222class mysqlDbTools extends jDbTools {
    2323
     24    protected $typesInfo = array(
     25      // type                  native type        unified type  minvalue     maxvalue   minlength  maxlength
     26      'bool'            =>array('boolean',          'boolean',  0,           1,          null,     null),
     27      'boolean'         =>array('boolean',          'boolean',  0,           1,          null,     null),
     28      'bit'             =>array('bit',              'integer',  0,           1,          null,     null),
     29      'tinyint'         =>array('tinyint',          'integer',  -128,        127,        null,     null),
     30      'smallint'        =>array('smallint',         'integer',  -32768,      32767,      null,     null),
     31      'mediumint'       =>array('mediumint',        'integer',  -8388608,    8388607,    null,     null),
     32      'integer'         =>array('integer',          'integer',  -2147483648, 2147483647, null,     null),
     33      'int'             =>array('integer',          'integer',  -2147483648, 2147483647, null,     null),
     34      'bigint'          =>array('bigint',           'numeric',  '-9223372036854775808', '9223372036854775807', null, null),
     35      'serial'          =>array('integer',          'numeric',  '-9223372036854775808', '9223372036854775807', null, null),
     36      'bigserial'       =>array('integer',          'numeric',  '-9223372036854775808', '9223372036854775807', null, null),
     37      'autoincrement'   =>array('integer',          'integer',  -2147483648, 2147483647, null,     null), // for old dao files
     38      'bigautoincrement'=>array('bigint',           'numeric',  '-9223372036854775808', '9223372036854775807', null, null),// for old dao files
     39
     40      'float'           =>array('float',            'float',    null,       null,       null,     null), //4bytes
     41      'money'           =>array('float',            'float',    null,       null,       null,     null), //4bytes
     42      'double precision'=>array('double precision', 'decimal',  null,       null,       null,     null), //8bytes
     43      'double'          =>array('double precision', 'decimal',  null,       null,       null,     null), //8bytes
     44      'real'            =>array('real',             'decimal',  null,       null,       null,     null), //8bytes
     45      'number'          =>array('real',             'decimal',  null,       null,       null,     null), //8bytes
     46      'binary_float'    =>array('float',            'float',    null,       null,       null,     null), //4bytes
     47      'binary_double'   =>array('real',             'decimal',  null,       null,       null,     null), //8bytes
     48     
     49      'numeric'         =>array('numeric',          'numeric',  null,       null,       null,     null),
     50      'decimal'         =>array('decimal',          'decimal',  null,       null,       null,     null),
     51      'dec'             =>array('decimal',          'decimal',  null,       null,       null,     null),
     52
     53      'date'            =>array('date',       'date',       null,       null,       10,    10),
     54      'time'            =>array('time',       'time',       null,       null,       8,     8),
     55      'datetime'        =>array('datetime',   'datetime',   null,       null,       19,    19),
     56      'timestamp'       =>array('datetime',   'datetime',   null,       null,       19,    19), // oracle/pgsql timestamp
     57      'utimestamp'      =>array('timestamp',  'integer',    0,          2147483647, null,  null), // mysql timestamp
     58      'year'            =>array('year',       'year',       null,       null,       2,     4),
     59      'interval'        =>array('datetime',   'datetime',   null,       null,       19,    19),
     60
     61      'char'            =>array('char',       'char',       null,       null,       0,     255),
     62      'nchar'           =>array('char',       'char',       null,       null,       0,     255),
     63      'varchar'         =>array('varchar',    'varchar',    null,       null,       0,     65535),
     64      'varchar2'        =>array('varchar',    'varchar',    null,       null,       0,     4000),
     65      'nvarchar2'       =>array('varchar',    'varchar',    null,       null,       0,     4000),
     66      'character'       =>array('varchar',    'varchar',    null,       null,       0,     65535),
     67      'character varying'=>array('varchar',   'varchar',    null,       null,       0,     65535),
     68      'name'            =>array('varchar',    'varchar',    null,       null,       0,     64),
     69      'longvarchar'     =>array('varchar',    'varchar',    null,       null,       0,     65535),
     70      'string'          =>array('varchar',    'varchar',    null,       null,       0,     65535),// for old dao files
     71
     72      'tinytext'        =>array('tinytext',   'text',       null,       null,       0,     255),
     73      'text'            =>array('text',       'text',       null,       null,       0,     65535),
     74      'mediumtext'      =>array('mediumtext', 'text',       null,       null,       0,     16777215),
     75      'longtext'        =>array('longtext',   'text',       null,       null,       0,     0),
     76      'long'            =>array('longtext',   'text',       null,       null,       0,     0),
     77      'clob'            =>array('longtext',   'text',       null,       null,       0,     0),
     78      'nclob'           =>array('longtext',   'text',       null,       null,       0,     0),
     79
     80
     81      'tinyblob'        =>array('tinyblob',   'blob',       null,       null,       0,     255),
     82      'blob'            =>array('blob',       'blob',       null,       null,       0,     65535),
     83      'mediumblob'      =>array('mediumblob', 'blob',       null,       null,       0,     16777215),
     84      'longblob'        =>array('longblob',   'blob',       null,       null,       0,     0),
     85      'bfile'           =>array('longblob',   'blob',       null,       null,       0,     0),
     86     
     87      'bytea'           =>array('longblob',   'blob',       null,       null,       0,     0),
     88      'binary'          =>array('binary',     'binary',     null,       null,       0,     255),
     89      'varbinary'       =>array('varbinary',  'varbinary',  null,       null,       0,     255),
     90      'raw'             =>array('varbinary',  'varbinary',  null,       null,       0,     2000),
     91      'long raw'        =>array('varbinary',  'varbinary',  null,       null,       0,     0),
     92
     93      'enum'            =>array('varchar',    'varchar',    null,       null,       0,     65535),
     94      'set'             =>array('varchar',    'varchar',    null,       null,       0,     65535),
     95      'xmltype'         =>array('varchar',    'varchar',    null,       null,       0,     65535),
     96
     97      'point'           =>array('varchar',    'varchar',    null,       null,       0,     16),
     98      'line'            =>array('varchar',    'varchar',    null,       null,       0,     32),
     99      'lsed'            =>array('varchar',    'varchar',    null,       null,       0,     32),
     100      'box'             =>array('varchar',    'varchar',    null,       null,       0,     32),
     101      'path'            =>array('varchar',    'varchar',    null,       null,       0,     65535),
     102      'polygon'         =>array('varchar',    'varchar',    null,       null,       0,     65535),
     103      'circle'          =>array('varchar',    'varchar',    null,       null,       0,     24),
     104      'cidr'            =>array('varchar',    'varchar',    null,       null,       0,     24),
     105      'inet'            =>array('varchar',    'varchar',    null,       null,       0,     24),
     106      'macaddr'         =>array('integer',    'integer',    0,          0xFFFFFFFFFFFF, null,       null),
     107      'bit varying'     =>array('varchar',    'varchar',    null,       null,       0,     65535),
     108      'arrays'          =>array('varchar',    'varchar',    null,       null,       0,     65535),
     109      'complex types'   =>array('varchar',    'varchar',    null,       null,       0,     65535),
     110    );
     111
     112    public function encloseName($name){
     113        return '`'.$name.'`';
     114    }
     115
    24116    /**
    25     * retourne la liste des tables
    26     * @return   array    $tab[] = $nomDeTable
     117    * returns the list of tables
     118    * @return   array    list of table names
    27119    */
    28     function _getTableList (){
     120    public function getTableList () {
    29121        $results = array ();
    30122
    31         $rs = $this->_connector->query ('SHOW TABLES FROM '.$this->_connector->profile['database']);
    32         $col_name = 'Tables_in_'.$this->_connector->profile['database'];
     123        $rs = $this->_conn->query ('SHOW TABLES FROM '.$this->_conn->profile['database']);
     124        $col_name = 'Tables_in_'.$this->_conn->profile['database'];
    33125
    34126        while ($line = $rs->fetch ()){
    35127            $results[] = $line->$col_name;
     
    39131    }
    40132
    41133    /**
    42     * récupère la liste des champs pour une base donnée.
    43     * @return   array    $tab[NomDuChamp] = obj avec prop (tye, length, lengthVar, notnull)
     134    * retrieve the list of fields of a table
     135    * @return   array    keys are field names and values are jDbFieldProperties objects
    44136    */
    45     function _getFieldList ($tableName){
     137    public function getFieldList ($tableName) {
     138        $tableName = $this->_conn->prefixTable($tableName);
    46139        $results = array ();
    47140
    48         $rs = $this->_connector->query ('SHOW FIELDS FROM `'.$tableName.'`');
     141        $rs = $this->_conn->query ('SHOW FIELDS FROM `'.$tableName.'`');
    49142
    50143        while ($line = $rs->fetch ()){
    51144            $field = new jDbFieldProperties();
     
    58151            } else {
    59152                $field->type = $line->Type;
    60153            }
     154            $typeinfo = $this->getTypeInfo($field->type);
     155            $field->unifiedType = $typeinfo[1];
     156            $field->maxValue = $typeinfo[3];
     157            $field->minValue = $typeinfo[2];
     158            $field->maxLength = $typeinfo[5];
     159            $field->minLength = $typeinfo[4];
     160            if ($field->length !=0)
     161                $field->maxLength = $field->length;
    61162
    62163            $field->name = $line->Field;
    63164            $field->notNull = ($line->Null == 'NO');
     
    77178    public function execSQLScript ($file) {
    78179        $queries = $this->parseSQLScript(file_get_contents($file));
    79180        foreach($queries as $query)
    80             $this->_connector->exec($query);
     181            $this->_conn->exec($query);
    81182        return count($queries);
    82183    }
    83184
  • lib/jelix/plugins/db/mysql/mysql.daobuilder.php

     
    44* @subpackage db_driver
    55* @author     Laurent Jouanneau
    66* @contributor
    7 * @copyright  2007 Laurent Jouanneau
     7* @copyright  2007-2009 Laurent Jouanneau
    88* @link      http://www.jelix.org
    99* @licence  http://www.gnu.org/licenses/lgpl.html GNU Lesser General Public Licence, see LICENCE file
    1010*/
     
    1818
    1919    protected $propertiesListForInsert = 'PrimaryFieldsExcludeAutoIncrement';
    2020
    21     function __construct($factoryClassName, $recordClassName, $daoDefinition){
    22         parent::__construct($factoryClassName, $recordClassName, $daoDefinition);
    23 
    24     }
    25 
    26     protected function _encloseName($name){
    27         return '`'.$name.'`';
    28     }
    29 
    3021}
  • lib/jelix/plugins/db/pgsql/pgsql.dbtools.php

     
    55* @author     Laurent Jouanneau
    66* @contributor Laurent Jouanneau
    77* @contributor Nicolas Jeudy (patch ticket #99)
    8 * @copyright  2005-2007 Laurent Jouanneau
    9 * @link        http://www.jelix.org
     8* @copyright  2005-2009 Laurent Jouanneau
     9* @link        http://jelix.org
    1010* @licence  http://www.gnu.org/licenses/lgpl.html GNU Lesser General Public Licence, see LICENCE file
    1111*/
    1212
     
    1717 */
    1818class pgsqlDbTools extends jDbTools {
    1919
     20    public $trueValue = 'TRUE';
     21   
     22    public $falseValue = 'FALSE';
     23
     24    protected $typesInfo = array(
     25      // type                  native type        unified type  minvalue     maxvalue   minlength  maxlength
     26      'bool'            =>array('boolean',          'boolean',  0,           1,          null,     null),
     27      'boolean'         =>array('boolean',          'boolean',  0,           1,          null,     null),
     28      'bit'             =>array('smallint',         'integer',  0,           1,          null,     null),
     29      'tinyint'         =>array('smallint',         'integer',  -128,        127,        null,     null),
     30      'smallint'        =>array('smallint',         'integer',  -32768,      32767,      null,     null),
     31      'mediumint'       =>array('integer',          'integer',  -8388608,    8388607,    null,     null),
     32      'integer'         =>array('integer',          'integer',  -2147483648, 2147483647, null,     null),
     33      'int'             =>array('integer',          'integer',  -2147483648, 2147483647, null,     null),
     34      'bigint'          =>array('bigint',           'numeric',  '-9223372036854775808', '9223372036854775807', null, null),
     35      'serial'          =>array('serial',           'integer',  -2147483648, 2147483647, null, null),
     36      'bigserial'       =>array('bigserial',        'numeric',  '-9223372036854775808', '9223372036854775807', null, null),
     37      'autoincrement'   =>array('serial',           'integer',  -2147483648, 2147483647, null,     null), // for old dao files
     38      'bigautoincrement'=>array('bigserial',        'numeric',  '-9223372036854775808', '9223372036854775807', null, null),// for old dao files
     39
     40      'float'           =>array('real',             'float',    null,       null,       null,     null), //4bytes
     41      'money'           =>array('money',            'float',    null,       null,       null,     null), //4bytes
     42      'double precision'=>array('double precision', 'decimal',  null,       null,       null,     null), //8bytes
     43      'double'          =>array('double precision', 'decimal',  null,       null,       null,     null), //8bytes
     44      'real'            =>array('real',             'float',    null,       null,       null,     null), //8bytes
     45      'number'          =>array('double',           'decimal',  null,       null,       null,     null), //8bytes
     46      'binary_float'    =>array('real',             'float',    null,       null,       null,     null), //4bytes
     47      'binary_double'   =>array('double',           'decimal',  null,       null,       null,     null), //8bytes
     48     
     49      'numeric'         =>array('numeric',          'numeric',  null,       null,       null,     null),
     50      'decimal'         =>array('decimal',          'decimal',  null,       null,       null,     null),
     51      'dec'             =>array('decimal',          'decimal',  null,       null,       null,     null),
     52
     53      'date'            =>array('date',       'date',       null,       null,       10,    10),
     54      'time'            =>array('time',       'time',       null,       null,       8,     8),
     55      'datetime'        =>array('datetime',   'datetime',   null,       null,       19,    19),
     56      'timestamp'       =>array('datetime',   'datetime',   null,       null,       19,    19), // oracle/pgsql timestamp
     57      'utimestamp'      =>array('timestamp',  'integer',    0,          2147483647, null,  null), // mysql timestamp
     58      'year'            =>array('year',       'year',       null,       null,       2,     4),
     59      'interval'        =>array('interval',   'integer',    null,       null,       19,    19),
     60
     61      'char'            =>array('char',       'char',       null,       null,       0,     255),
     62      'nchar'           =>array('nchar',       'char',       null,       null,       0,     255),
     63      'varchar'         =>array('varchar',    'varchar',    null,       null,       0,     0),
     64      'varchar2'        =>array('varchar',    'varchar',    null,       null,       0,     0),
     65      'nvarchar2'       =>array('nvarchar',    'varchar',    null,       null,       0,     0),
     66      'character'       =>array('character',    'varchar',    null,       null,       0,     0),
     67      'character varying'=>array('character varying',   'varchar',    null,       null,       0,     0),
     68      'name'            =>array('name',    'varchar',    null,       null,       0,     64),
     69      'longvarchar'     =>array('varchar',    'varchar',    null,       null,       0,     0),
     70      'string'          =>array('varchar',    'varchar',    null,       null,       0,     0),// for old dao files
     71
     72      'tinytext'        =>array('text',   'text',       null,       null,       0,     255),
     73      'text'            =>array('text',   'text',       null,       null,       0,     0),
     74      'mediumtext'      =>array('text',   'text',       null,       null,       0,     0),
     75      'longtext'        =>array('text',   'text',       null,       null,       0,     0),
     76      'long'            =>array('text',   'text',       null,       null,       0,     0),
     77      'clob'            =>array('text',   'text',       null,       null,       0,     0),
     78      'nclob'           =>array('text',   'text',       null,       null,       0,     0),
     79
     80
     81      'tinyblob'        =>array('bytea',   'blob',       null,       null,       0,     255),
     82      'blob'            =>array('bytea',   'blob',       null,       null,       0,     65535),
     83      'mediumblob'      =>array('bytea',   'blob',       null,       null,       0,     16777215),
     84      'longblob'        =>array('bytea',   'blob',       null,       null,       0,     0),
     85      'bfile'           =>array('bytea',   'blob',       null,       null,       0,     0),
     86     
     87      'bytea'           =>array('bytea',  'varbinary',   null,       null,       0,     0),
     88      'binary'          =>array('bytea',  'binary',      null,       null,       0,     255),
     89      'varbinary'       =>array('bytea',  'varbinary',   null,       null,       0,     255),
     90      'raw'             =>array('bytea',  'varbinary',   null,       null,       0,     2000),
     91      'long raw'        =>array('bytea',  'varbinary',   null,       null,       0,     0),
     92
     93      'enum'            =>array('varchar',    'varchar',    null,       null,       0,     65535),
     94      'set'             =>array('varchar',    'varchar',    null,       null,       0,     65535),
     95      'xmltype'         =>array('varchar',    'varchar',    null,       null,       0,     65535),
     96
     97      'point'           =>array('point',    'varchar',    null,       null,       0,     16),
     98      'line'            =>array('line',     'varchar',    null,       null,       0,     32),
     99      'lsed'            =>array('lsed',     'varchar',    null,       null,       0,     32),
     100      'box'             =>array('box',      'varchar',    null,       null,       0,     32),
     101      'path'            =>array('path',     'varchar',    null,       null,       0,     65535),
     102      'polygon'         =>array('polygon',  'varchar',    null,       null,       0,     65535),
     103      'circle'          =>array('circle',   'varchar',    null,       null,       0,     24),
     104      'cidr'            =>array('cidr',     'varchar',    null,       null,       0,     24),
     105      'inet'            =>array('inet',     'varchar',    null,       null,       0,     24),
     106      'macaddr'         =>array('macaddr',  'integer',    0,          0xFFFFFFFFFFFF, null,       null),
     107      'bit varying'     =>array('bit varying', 'varchar', null,       null,       0,     65535),
     108      'arrays'          =>array('array',    'varchar',    null,       null,       0,     65535),
     109      'complex types'   =>array('complex',  'varchar',    null,       null,       0,     65535),
     110    );
     111
     112    public function encloseName($name){
     113        return '"'.$name.'"';
     114    }
     115
    20116   /*
    21    * retourne la liste des tables
    22    * @return   array    $tab[] = $nomDeTable
     117    * returns the list of tables
     118    * @return   array    list of table names
    23119   */
    24    protected function _getTableList (){
     120   public function getTableList () {
    25121      $results = array ();
    26122      $sql = "SELECT tablename FROM pg_tables WHERE schemaname NOT IN ('pg_catalog', 'information_schema') ORDER BY tablename";
    27       $rs = $this->_connector->query ($sql);
     123      $rs = $this->_conn->query ($sql);
    28124      while ($line = $rs->fetch()){
    29125         $results[] = $line->tablename;
    30126      }
    31127      return $results;
    32128   }
    33129    /**
    34     * récupère la liste des champs pour une base donnée.
    35     * @return    array    $tab[NomDuChamp] = obj avec prop (tye, length, lengthVar, notnull)
     130    * retrieve the list of fields of a table
     131    * @return   array    keys are field names and values are jDbFieldProperties objects
    36132    */
    37     protected function _getFieldList ($tableName){
     133    public function getFieldList ($tableName) {
     134        $tableName = $this->_conn->prefixTable($tableName);
    38135        $results = array ();
    39136       
    40137        // get table informations
    41138        $sql ='SELECT oid, relhaspkey, relhasindex FROM pg_class WHERE relname = \''.$tableName.'\'';
    42         $rs = $this->_connector->query ($sql);
     139        $rs = $this->_conn->query ($sql);
    43140        if (! ($table = $rs->fetch())) {
    44141            throw new Exception('dbtools, pgsql: unknow table');
    45142        }
     
    48145        // get primary keys informations
    49146        if ($table->relhaspkey == 't') {
    50147            $sql = 'SELECT indkey FROM pg_index WHERE indrelid = '.$table->oid.' and indisprimary = true';
    51             $rs = $this->_connector->query ($sql);
     148            $rs = $this->_conn->query ($sql);
    52149            $pkeys = preg_split("/[\s]+/", $rs->fetch()->indkey);
    53150        }
    54151
     
    61158        ORDER BY a.attnum";
    62159
    63160        $toReturn=array();
    64         $rs = $this->_connector->query ($sql_get_fields);
     161        $rs = $this->_conn->query ($sql_get_fields);
    65162        while ($line = $rs->fetch ()){
    66163            $field = new jDbFieldProperties();
    67164            $field->name = $line->attname;
     
    70167            $field->hasDefault = ($line->atthasdef == 't');
    71168            $field->default = $line->adsrc;
    72169
    73             if(preg_match('/^nextval\(.*\)$/', $line->adsrc)){
     170            $typeinfo = $this->getTypeInfo($field->type);
     171            $field->unifiedType = $typeinfo[1];
     172            $field->maxValue = $typeinfo[3];
     173            $field->minValue = $typeinfo[2];
     174            $field->maxLength = $typeinfo[5];
     175            $field->minLength = $typeinfo[4];
     176
     177            if(preg_match('/^nextval\(.*\)$/', $line->adsrc) || $typeinfo[6]){
    74178                $field->autoIncrement=true;
    75179                $field->default = '';
    76180            }
     
    78182            if(in_array($line->attnum, $pkeys))
    79183                $field->primary = true;
    80184
    81             if($line->attlen == -1 && $line->atttypmod != -1)
     185            if($line->attlen == -1 && $line->atttypmod != -1) {
    82186                $field->length = $line->atttypmod - 4;
     187                $field->maxLength = $field->length;
     188            }
    83189
    84190            $toReturn[$line->attname]=$field;
    85191        }
     
    89195
    90196    public function execSQLScript ($file) {
    91197        $sqlQueries=file_get_contents($file);
    92         $this->_connector->query ($sqlQueries);
     198        $this->_conn->query ($sqlQueries);
    93199    }
    94200}
    95201
  • lib/jelix/plugins/db/pgsql/pgsql.daobuilder.php

     
    1717class pgsqlDaoBuilder extends jDaoGenerator {
    1818
    1919    protected $propertiesListForInsert = 'PrimaryFieldsExcludeAutoIncrement';
    20    
    21     protected $trueValue = 'TRUE';
    22    
    23     protected $falseValue = 'FALSE';
    24    
    25     function __construct($factoryClassName, $recordClassName, $daoDefinition){
    26         parent::__construct($factoryClassName, $recordClassName, $daoDefinition);
    2720
    28     }
    29 
    3021    protected function genUpdateAutoIncrementPK($pkai, $pTableRealName) {
    3122        return '          $record->'.$pkai->name.'= $this->_conn->lastInsertId(\''.$pkai->sequenceName.'\');';
    3223    }
    3324
    34     protected function _encloseName($name){
    35         return '"'.$name.'"';
    36     }
    37 
    3825    protected function _getAutoIncrementPKField ($using = null){
    3926        if ($using === null){
    4027            $using = $this->_dataParser->getProperties ();
     
    4633        foreach ($using as $id=>$field) {
    4734            if(!$field->isPK)
    4835                continue;
    49             if ($field->datatype == 'autoincrement' || $field->datatype == 'bigautoincrement') {
     36            if ($field->autoIncrement) {
    5037               if(!strlen($field->sequenceName)){
    5138                  $field->sequenceName = $tb.'_'.$field->name.'_seq';
    5239               }
  • lib/jelix/plugins/db/oci/oci.dbtools.php

     
    33* @package    jelix
    44* @subpackage db_driver
    55* @author     Gwendal Jouannic
    6 * @contributor
    7 * @copyright  2008 Gwendal Jouannic
     6* @contributor Laurent Jouanneau
     7* @copyright  2008 Gwendal Jouannic, 2009 Laurent Jouanneau
    88* @link      http://www.jelix.org
    99* @licence  http://www.gnu.org/licenses/lgpl.html GNU Lesser General Public Licence, see LICENCE file
    1010*/
    1111
    1212
    1313class ociDbTools extends jDbTools {
    14        
     14
     15    protected $typesInfo = array(
     16      // type                  native type        unified type  minvalue     maxvalue   minlength  maxlength
     17      'bool'            =>array('number',          'boolean',  0,           1,          null,     null),
     18      'boolean'         =>array('boolean',          'boolean',  0,           1,          null,     null),
     19      'bit'             =>array('bit',              'integer',  0,           1,          null,     null),
     20      'tinyint'         =>array('tinyint',          'integer',  -128,        127,        null,     null),
     21      'smallint'        =>array('smallint',         'integer',  -32768,      32767,      null,     null),
     22      'mediumint'       =>array('mediumint',        'integer',  -8388608,    8388607,    null,     null),
     23      'integer'         =>array('integer',          'integer',  -2147483648, 2147483647, null,     null),
     24      'int'             =>array('integer',          'integer',  -2147483648, 2147483647, null,     null),
     25      'bigint'          =>array('bigint',           'numeric',  '-9223372036854775808', '9223372036854775807', null, null),
     26      'serial'          =>array('integer',          'numeric',  '-9223372036854775808', '9223372036854775807', null, null),
     27      'bigserial'       =>array('integer',          'numeric',  '-9223372036854775808', '9223372036854775807', null, null),
     28      'autoincrement'   =>array('integer',          'integer',  -2147483648, 2147483647, null,     null), // for old dao files
     29      'bigautoincrement'=>array('bigint',           'numeric',  '-9223372036854775808', '9223372036854775807', null, null),// for old dao files
     30
     31      'float'           =>array('float',            'float',    null,       null,       null,     null), //4bytes
     32      'money'           =>array('float',            'float',    null,       null,       null,     null), //4bytes
     33      'double precision'=>array('double precision', 'decimal',  null,       null,       null,     null), //8bytes
     34      'double'          =>array('double precision', 'decimal',  null,       null,       null,     null), //8bytes
     35      'real'            =>array('real',             'decimal',  null,       null,       null,     null), //8bytes
     36      'number'          =>array('real',             'decimal',  null,       null,       null,     null), //8bytes
     37      'binary_float'    =>array('float',            'float',    null,       null,       null,     null), //4bytes
     38      'binary_double'   =>array('real',             'decimal',  null,       null,       null,     null), //8bytes
     39     
     40      'numeric'         =>array('numeric',          'numeric',  null,       null,       null,     null),
     41      'decimal'         =>array('decimal',          'decimal',  null,       null,       null,     null),
     42      'dec'             =>array('decimal',          'decimal',  null,       null,       null,     null),
     43
     44      'date'            =>array('date',       'date',       null,       null,       10,    10),
     45      'time'            =>array('time',       'time',       null,       null,       8,     8),
     46      'datetime'        =>array('datetime',   'datetime',   null,       null,       19,    19),
     47      'timestamp'       =>array('datetime',   'datetime',   null,       null,       19,    19), // oracle/pgsql timestamp
     48      'utimestamp'      =>array('timestamp',  'integer',    0,          2147483647, null,  null), // mysql timestamp
     49      'year'            =>array('year',       'year',       null,       null,       2,     4),
     50      'interval'        =>array('datetime',   'datetime',   null,       null,       19,    19),
     51
     52      'char'            =>array('char',       'char',       null,       null,       0,     255),
     53      'nchar'           =>array('char',       'char',       null,       null,       0,     255),
     54      'varchar'         =>array('varchar',    'varchar',    null,       null,       0,     65535),
     55      'varchar2'        =>array('varchar',    'varchar',    null,       null,       0,     4000),
     56      'nvarchar2'       =>array('varchar',    'varchar',    null,       null,       0,     4000),
     57      'character'       =>array('varchar',    'varchar',    null,       null,       0,     65535),
     58      'character varying'=>array('varchar',   'varchar',    null,       null,       0,     65535),
     59      'name'            =>array('varchar',    'varchar',    null,       null,       0,     64),
     60      'longvarchar'     =>array('varchar',    'varchar',    null,       null,       0,     65535),
     61      'string'          =>array('varchar',    'varchar',    null,       null,       0,     65535),// for old dao files
     62
     63      'tinytext'        =>array('tinytext',   'text',       null,       null,       0,     255),
     64      'text'            =>array('text',       'text',       null,       null,       0,     65535),
     65      'mediumtext'      =>array('mediumtext', 'text',       null,       null,       0,     16777215),
     66      'longtext'        =>array('longtext',   'text',       null,       null,       0,     0),
     67      'long'            =>array('longtext',   'text',       null,       null,       0,     0),
     68      'clob'            =>array('longtext',   'text',       null,       null,       0,     0),
     69      'nclob'           =>array('longtext',   'text',       null,       null,       0,     0),
     70
     71
     72      'tinyblob'        =>array('tinyblob',   'blob',       null,       null,       0,     255),
     73      'blob'            =>array('blob',       'blob',       null,       null,       0,     65535),
     74      'mediumblob'      =>array('mediumblob', 'blob',       null,       null,       0,     16777215),
     75      'longblob'        =>array('longblob',   'blob',       null,       null,       0,     0),
     76      'bfile'           =>array('longblob',   'blob',       null,       null,       0,     0),
     77     
     78      'bytea'           =>array('longblob',   'blob',       null,       null,       0,     0),
     79      'binary'          =>array('binary',     'binary',     null,       null,       0,     255),
     80      'varbinary'       =>array('varbinary',  'varbinary',  null,       null,       0,     255),
     81      'raw'             =>array('varbinary',  'varbinary',  null,       null,       0,     2000),
     82      'long raw'        =>array('varbinary',  'varbinary',  null,       null,       0,     0),
     83
     84      'enum'            =>array('varchar',    'varchar',    null,       null,       0,     65535),
     85      'set'             =>array('varchar',    'varchar',    null,       null,       0,     65535),
     86      'xmltype'         =>array('varchar',    'varchar',    null,       null,       0,     65535),
     87
     88      'point'           =>array('varchar',    'varchar',    null,       null,       0,     16),
     89      'line'            =>array('varchar',    'varchar',    null,       null,       0,     32),
     90      'lsed'            =>array('varchar',    'varchar',    null,       null,       0,     32),
     91      'box'             =>array('varchar',    'varchar',    null,       null,       0,     32),
     92      'path'            =>array('varchar',    'varchar',    null,       null,       0,     65535),
     93      'polygon'         =>array('varchar',    'varchar',    null,       null,       0,     65535),
     94      'circle'          =>array('varchar',    'varchar',    null,       null,       0,     24),
     95      'cidr'            =>array('varchar',    'varchar',    null,       null,       0,     24),
     96      'inet'            =>array('varchar',    'varchar',    null,       null,       0,     24),
     97      'macaddr'         =>array('integer',    'integer',    0,          0xFFFFFFFFFFFF, null,       null),
     98      'bit varying'     =>array('varchar',    'varchar',    null,       null,       0,     65535),
     99      'arrays'          =>array('varchar',    'varchar',    null,       null,       0,     65535),
     100      'complex types'   =>array('varchar',    'varchar',    null,       null,       0,     65535),
     101    );
     102
     103
    15104    /**
    16     * retourne la liste des tables
    17     * @return   array    $tab[] = $nomDeTable
     105    * returns the list of tables
     106    * @return   array    list of table names
    18107    */
    19     function _getTableList (){
     108    public function getTableList () {
    20109        $results = array ();
    21110
    22         $rs = $this->_connector->query ('SELECT TABLE_NAME FROM USER_TABLES');
     111        $rs = $this->_conn->query ('SELECT TABLE_NAME FROM USER_TABLES');
    23112
    24113        while ($line = $rs->fetch ()){
    25114            $results[] = $line->table_name;
     
    29118    }
    30119
    31120    /**
    32     * récupère la liste des champs pour une base donnée.
    33     * @return   array    $tab[NomDuChamp] = obj avec prop (tye, length, lengthVar, notnull)
     121    * retrieve the list of fields of a table
     122    * @return   array    keys are field names and values are jDbFieldProperties objects
    34123    */
    35     function _getFieldList ($tableName){
     124    public function getFieldList ($tableName) {
     125        $tableName = $this->_conn->prefixTable($tableName);
    36126        $results = array ();
    37127
    38128        $query = 'SELECT COLUMN_NAME, DATA_TYPE, DATA_LENGTH, NULLABLE, DATA_DEFAULT, 
     
    48138                    FROM USER_TAB_COLUMNS UTC
    49139                    WHERE UTC.TABLE_NAME = \''.strtoupper($tableName).'\'';
    50140
    51         $rs = $this->_connector->query ($query);
     141        $rs = $this->_conn->query ($query);
    52142
    53143        while ($line = $rs->fetch ()){
    54144
     
    57147            $field->name = strtolower($line->column_name);
    58148            $field->type = strtolower($line->data_type);
    59149
    60             if ($line->data_type == 'VARCHAR2'){
     150            $typeinfo = $this->getTypeInfo($field->type);
     151            $field->unifiedType = $typeinfo[1];
     152            $field->maxValue = $typeinfo[3];
     153            $field->minValue = $typeinfo[2];
     154            $field->maxLength = $typeinfo[5];
     155            $field->minLength = $typeinfo[4];
     156
     157            if ($field->type == 'varchar2' || $field->type == 'varchar' ){
    61158                $field->length = intval($line->data_length);
     159                $field->maxLength = $field->length;
    62160            }
    63161
    64162            $field->notNull = ($line->nullable == 'N');
     
    87185    * @return   string
    88186    */
    89187    function _getAISequenceName($tbName, $clName){
    90         return preg_replace(array('/\*tbName\*/', '/\*clName\*/'), array(strtoupper($tbName), strtoupper($clName)), $this->_connector->profile['sequence_AI_pattern']);
     188        return preg_replace(array('/\*tbName\*/', '/\*clName\*/'), array(strtoupper($tbName), strtoupper($clName)), $this->_conn->profile['sequence_AI_pattern']);
    91189    }
    92190}
  • lib/jelix/plugins/db/oci/oci.daobuilder.php

     
    1919    protected $aliasWord = ' ';
    2020    protected $propertiesListForInsert = 'PrimaryFieldsExcludeAutoIncrement';
    2121
    22     function __construct($factoryClassName, $recordClassName, $daoDefinition){
    23         parent::__construct($factoryClassName, $recordClassName, $daoDefinition);
    24     }
    25 
    2622    protected function genOuterJoins(&$tables, $primaryTableName){
    2723        $sqlFrom = '';
    2824        $sqlWhere ='';
  • lib/jelix/db/jDb.class.php

     
    154154            throw new jException('jelix~db.error.profile.unknow',$name);
    155155        }
    156156    }
    157    
     157
    158158    /**
    159      * DEPRECATED. same as getProfile
    160      * @deprecated
    161      */
    162     public static function getProfil ($name='', $nameIsProfileType=false){
    163         trigger_error("jDb::getProfil() is deprecated, you should use jDb::getProfile()", E_USER_NOTICE);
    164         return self::getProfile($name, $nameIsProfileType);
    165     }
    166    
    167     /**
    168159     * call it to test a profile (during an install for example)
    169160     * @param array  $profile  profile properties
    170161     * @return boolean  true if properties are ok
  • lib/jelix/db/jDbTools.class.php

     
    2424 * @see jDbTools::getFieldList
    2525 */
    2626 class jDbFieldProperties {
     27 
    2728    /**
    28      * type of the field
     29     * native type of the field
    2930     * @var string
    3031     */
    3132    public $type;
    3233
    3334    /**
     35     * unified type of the field
     36     * @var string
     37     */
     38    public $unifiedtype;
     39
     40    /**
    3441     * field name
    3542     * @var string
    3643     */
     
    7380     * @var string
    7481     */
    7582    public $sequence = false;
     83   
     84    public $unsigned = false;
     85   
     86    public $minLength = null;
     87   
     88    public $maxLength = null;
     89   
     90    public $minValue = null;
     91   
     92    public $maxValue = null;
    7693}
    7794
    7895/**
     
    8299 */
    83100abstract class jDbTools {
    84101
     102    public $trueValue = '1';
     103
     104    public $falseValue = '0';
     105   
    85106    /**
    86107    * the database connector
    87108    * @var jDbConnection
    88109    */
    89     protected $_connector;
     110    protected $_conn;
    90111
    91112    /**
    92113    *
    93114    */
    94115    function __construct( $connector){
    95         $this->_connector = $connector;
     116        $this->_conn = $connector;
    96117    }
    97118
     119    protected $unifiedToPhp = array(
     120        'boolean'=>'boolean',
     121        'integer'=>'integer',
     122        'float'=>'float',
     123        'double'=>'float',
     124        'numeric'=>'numeric',
     125        'decimal'=>'decimal',
     126        'date'=>'string',
     127        'time'=>'string',
     128        'datetime'=>'string',
     129        'year'=>'string',
     130        'char'=>'string',
     131        'varchar'=>'string',
     132        'text'=>'string',
     133        'blob'=>'string',
     134        'binary'=>'string',
     135        'varbinary'=>'string',
     136    );
     137   
     138    protected $typesInfo = array();
     139
     140
    98141    /**
    99     * returns the table list
     142     * get informations about the given SQL type
     143     * @param string $nativeType the SQL type
     144     * @return array an array which contains characteristics of the type
     145     *        array ( 'nativetype', 'corresponding unifiedtype', minvalue, maxvalue, minlength, maxlength)
     146     * minvalue, maxvalue, minlength, maxlength can be null.
     147     * @since 1.1.1
    100148    */
    101     public function getTableList (){
    102         return $this->_getTableList ();
     149    public function getTypeInfo($nativeType) {
     150        if(isset($this->typesInfo[$nativeType])) {
     151            $r = $this->typesInfo[$nativeType];
     152        }
     153        else
     154            $r = $this->typesInfo['varchar'];
     155        $r[] = ($nativeType == 'serial' || $nativeType == 'autoincrement' || $nativeType == 'bigautoincrement');
     156        return $r;
    103157    }
    104158
    105159    /**
    106     * return the field list of a given table
    107     * @return array  array of jDbFieldProperties
     160     * return the PHP type corresponding to the given unified type
     161     * @param string $unifiedType
     162     * @return string the php type
     163     * @since 1.1.1
    108164    */
    109     public function getFieldList ($tableName){
    110         return $this->_getFieldList ($this->_connector->prefixTable($tableName));
     165    public function unifiedToPHPType($unifiedType) {
     166        if(isset($this->unifiedToPhp[$unifiedType])) {
     167            return $this->unifiedToPhp[$unifiedType];
     168        }
     169        throw new Exception('bad unified type name:'.$unifiedType);
    111170    }
    112171
    113     abstract protected function _getTableList ();
    114     abstract protected function _getFieldList ($tableName);
     172    /**
     173     * @param string $unifiedType  the unified type name
     174     * @param string $value        the value
     175     * @return string  the php value corresponding to the type
     176     * @since 1.1.1
     177    */
     178    public function stringToPhpValue($unifiedType, $value, $checkNull = false) {
     179        if($checkNull && ($value === null ||strtolower($value)=='null'))
     180            return null;
     181        switch($this->unifiedToPHPType($unifiedType)) {
     182            case 'boolean':
     183                return ($this->getBooleanValue($value) == $this->trueValue);
     184            case 'integer':
     185                return intval($value);
     186            case 'float':
     187                return floatval($value);
     188            case 'numeric':
     189            case 'decimal':
     190                if(is_numeric($value))
     191                    return $value;
     192                else
     193                    return floatval($value);
     194            default:
     195                return $value;
     196        }
     197    }
    115198
    116199    /**
     200     * @param string $unifiedType  the unified type name
     201     * @param mixed $value        the value
     202     * @return string  the value which is ready to include a SQL query string
     203     * @since 1.1.1
     204    */
     205    public function escapeValue($unifiedType, $value, $checkNull = false, $toPhpSource = false) {
     206        if($checkNull && ($value === null ||strtolower($value)=='null'))
     207            return 'NULL';
     208        switch($this->unifiedToPHPType($unifiedType)) {
     209            case 'boolean':
     210                return $this->getBooleanValue($value);
     211            case 'integer':
     212                return (string)intval($value);
     213            case 'float':
     214                return (string)doubleval($value);
     215            case 'numeric':
     216            case 'decimal':
     217                if(is_numeric($value))
     218                    return $value;
     219                else
     220                    return (string)floatval($value);
     221            default:
     222                if ($toPhpSource) {
     223                    if(strpos($value,"'") !== false){
     224                        return '\'.$this->_conn->quote(\''.str_replace('\'','\\\'',$value).'\').\'';
     225                    }else{
     226                        return "\\'".$value."\\'";
     227                    }
     228                }
     229                elseif ($this->_conn)
     230                    return $this->_conn->quote($value);
     231                else
     232                    return "'".addslashes($value)."'";
     233        }
     234    }
     235
     236    /**
     237     * @param string|boolean $value a value which is a boolean
     238     * @return string the string value representing a boolean in SQL
     239     * @since 1.1.1
     240    */
     241    public function getBooleanValue($value) {
     242      if(is_string($value))
     243          $value = strtolower($value);
     244      if ($value =='true' || $value === true || $value =='1'|| $value=='t')
     245          return $this->trueValue;
     246      else
     247          return $this->falseValue;
     248    }
     249
     250    /**
     251     * enclose the field name
     252     * @param string $fieldName the field name
     253     * @return string the enclosed field name
     254     * @since 1.1.1
     255     */
     256    public function encloseName($fieldName){
     257        return $fieldName;
     258    }
     259
     260    /**
     261    * returns the table list
     262    */
     263    abstract public function getTableList ();
     264
     265    /**
     266    * return the field list of a given table
     267    * @return array  array of jDbFieldProperties
     268    */
     269    abstract public function getFieldList ($tableName);
     270
     271    /**
    117272     * regular expression to detect comments and end of query
    118273     */
    119274    protected $dbmsStyle = array('/^\s*#/', '/;\s*$/');
     
    124279        $cmdSQL = '';
    125280        $nbCmd = 0;
    126281
    127          $style=$this->dbmsStyle;
     282        $style = $this->dbmsStyle;
    128283
    129284        foreach ((array)$lines as $key=>$line) {
    130285            if ((!preg_match($style[0],$line))&&(strlen(trim($line))>0)) { // la ligne n'est ni vide ni commentaire
     
    137292                    //Si on est à la ligne de fin de la commande on l'execute
    138293                    // On nettoie la commande du ";" de fin et on l'execute
    139294                    $cmdSQL = preg_replace($style[1],'',$cmdSQL);
    140                     $this->_connector->query ($cmdSQL);
     295                    $this->_conn->query ($cmdSQL);
    141296                    $nbCmd++;
    142297                    $cmdSQL = '';
    143298                }
  • lib/jelix/docs/ns/dao.rng

     
    5353         <oneOrMore>
    5454            <element name="property">
    5555               <attribute name="name" />
    56                <attribute name="datatype">
    57                   <ref  name="dao.datatypes"/>
    58                </attribute>
     56               <attribute name="datatype" />
    5957               <optional><attribute name="fieldname" /></optional>
    6058               <optional><attribute name="table" /></optional>
    6159               <optional><attribute name="required"><data type="boolean" /></attribute></optional>
     
    286284
    287285   <!-- divers -->
    288286
    289 
    290287   <define name="any">
    291288      <element>
    292289         <anyName/>
     
    302299      </element>
    303300   </define>
    304301
    305 
    306    <define name="dao.datatypes">
    307       <choice>
    308          <value>varchar</value>
    309          <value>varchardate</value>
    310          <value>autoincrement</value>
    311          <value>bigautoincrement</value>
    312          <ref name="jelix.datatypes.value"/>
    313       </choice>
    314    </define>
    315 
    316    <define name="jelix.datatypes.value">
    317       <choice>
    318          <value>int</value>
    319          <value>integer</value>
    320          <value>numeric</value>
    321          <value>double</value>
    322          <value>float</value>
    323          <value>datetime</value>
    324          <value>time</value>
    325          <value>date</value>
    326          <value>string</value>
    327          <value>text</value>
    328          <value>boolean</value>
    329       </choice>
    330    </define>
    331302</grammar>
    332  No newline at end of file
  • lib/jelix/core/selector/jSelectorDao.class.php

     
    2525    protected $_where;
    2626
    2727    function __construct($sel, $driver, $isprofile=true){
    28         if($isprofile){
     28        if ($isprofile) {
    2929            $p = jDb::getProfile($driver);
    30             if($p['driver'] == 'pdo'){
    31                 $this->driver=substr($p['dsn'],0,strpos($p['dsn'],':'));
    32             }else{
    33                 $this->driver= $p['driver'];
     30            if ($p['driver'] == 'pdo') {
     31                $this->driver = substr($p['dsn'], 0, strpos($p['dsn'],':'));
    3432            }
    35         }else{
    36             $this->driver=$driver;
     33            else {
     34                $this->driver = $p['driver'];
     35            }
    3736        }
     37        else {
     38            $this->driver = $driver;
     39        }
    3840        $this->_compiler='jDaoCompiler';
    3941        $this->_compilerPath=JELIX_LIB_PATH.'dao/jDaoCompiler.class.php';
    4042        parent::__construct($sel);
  • lib/jelix/dao/jDaoCompiler.class.php

     
    55#if ENABLE_OPTIMIZED_SOURCE
    66* @author     Croes Gérald, Laurent Jouanneau
    77* @contributor Laurent Jouanneau
    8 * @copyright  2001-2005 CopixTeam, 2005-2007 Laurent Jouanneau
     8* @copyright  2001-2005 CopixTeam, 2005-2009 Laurent Jouanneau
    99* Ideas and some parts of this file were get originally from the Copix project
    1010* (CopixDAOGeneratorV1, CopixDAODefinitionV1, Copix 2.3dev20050901, http://www.copix.org)
    1111* Few lines of code are still copyrighted 2001-2005 CopixTeam (LGPL licence).
     
    2424#else
    2525* @author      Laurent Jouanneau
    2626* @contributor
    27 * @copyright   2005-2007 Laurent Jouanneau
     27* @copyright   2005-2009 Laurent Jouanneau
    2828* Idea of this class was get originally from the Copix project
    2929* (CopixDaoCompiler, Copix 2.3dev20050901, http://www.copix.org)
    3030* no more line of code are copyrighted by CopixTeam
     
    4949 * @subpackage dao
    5050 */
    5151class jDaoCompiler  implements jISimpleCompiler {
    52     /**
    53     * the current DAO id.
    54     * @var string
    55     */
    56     static public $daoId = '';
    5752
    5853    /**
    59      * the current DAO file path
    60      * @var string
    61      */
    62     static public $daoPath = '';
    63 
    64     /**
    65      * The database type
    66      * @var string
    67      */
    68     static public $dbType='';
    69 
    70     /**
    7154    * compile the given class id.
    7255    */
    7356    public function compile ($selector) {
    7457
    75         jDaoCompiler::$daoId = $selector->toString();
    76         jDaoCompiler::$daoPath = $selector->getPath();
    77         jDaoCompiler::$dbType = $selector->driver;
     58        $daoPath = $selector->getPath();
    7859
    7960        // chargement du fichier XML
    8061        $doc = new DOMDocument();
    8162
    82         if(!$doc->load(jDaoCompiler::$daoPath)){
    83             throw new jException('jelix~daoxml.file.unknow', jDaoCompiler::$daoPath);
     63        if(!$doc->load($daoPath)){
     64            throw new jException('jelix~daoxml.file.unknow', $daoPath);
    8465        }
    8566
    8667        if($doc->documentElement->namespaceURI != JELIX_NAMESPACE_BASE.'dao/1.0'){
    87             throw new jException('jelix~daoxml.namespace.wrong',array(jDaoCompiler::$daoPath, $doc->namespaceURI));
     68            throw new jException('jelix~daoxml.namespace.wrong',array($daoPath, $doc->namespaceURI));
    8869        }
    8970
    90         $parser = new jDaoParser ();
    91         $parser->parse(simplexml_import_dom($doc));
    92 
    9371        global $gJConfig;
    9472#ifnot ENABLE_OPTIMIZED_SOURCE
    9573        if(!isset($gJConfig->_pluginsPathList_db[$selector->driver])
     
    9775            throw new jException('jelix~db.error.driver.notfound', $selector->driver);
    9876        }
    9977#endif
    100         require_once($gJConfig->_pluginsPathList_db[$selector->driver].$selector->driver.'.daobuilder.php');
     78        $path = $gJConfig->_pluginsPathList_db[$selector->driver].$selector->driver;
     79        require_once($path.'.dbtools.php');
     80        $class = $selector->driver.'DbTools';
     81        $tools = new $class(null);
     82
     83        $parser = new jDaoParser ($selector);
     84        $parser->parse(simplexml_import_dom($doc), $tools);
     85
     86        require_once($path.'.daobuilder.php');
    10187        $class = $selector->driver.'DaoBuilder';
    102         $generator = new $class ($selector->getDaoClass(), $selector->getDaoRecordClass(), $parser);
     88        $generator = new $class ($selector, $tools, $parser);
    10389
    10490        // génération des classes PHP correspondant à la définition de la DAO
    10591        $compiled = '<?php '.$generator->buildClasses ()."\n?>";
     
    116102class jDaoXmlException extends jException {
    117103
    118104    /**
     105     * @param jSelectorDao $selector
    119106     * @param string $localekey a locale key
    120107     * @param array $localeParams parameters for the message (for sprintf)
    121108     */
    122     public function __construct($localekey, $localeParams=array()) {
     109    public function __construct($selector, $localekey, $localeParams=array()) {
    123110        $localekey= 'jelix~daoxml.'.$localekey;
    124 
    125         $arg=array(jDaoCompiler::$daoId, jDaoCompiler::$daoPath);
     111        $arg=array($selector->toString(), $selector->getPath());
    126112        if(is_array($localeParams)){
    127113            $arg=array_merge($arg, $localeParams);
    128114        }else{
  • lib/jelix/dao/jDaoParser.class.php

     
    6666     */
    6767    private $_eventList = array();
    6868
    69 
    7069    public $hasOnlyPrimaryKeys = false;
     70   
     71    public $selector;
    7172    /**
    7273    * Constructor
    7374    */
    74     function __construct(){
     75    function __construct($selector) {
     76        $this->selector = $selector;
    7577    }
    7678
    7779    /**
    7880    * parse a dao xml content
    7981    * @param SimpleXmlElement $xml
     82    * @param jDbTools $tools
    8083    * @param int $debug  for debug only 0:parse all, 1:parse only datasource+record, 2;parse only datasource
    8184    */
    82     public function parse( $xml, $debug=0){
     85    public function parse( $xml, $tools){
     86        $this->parseDatasource($xml);
     87        $this->parseRecord($xml, $tools);
     88        $this->parseFactory($xml);
     89    }
     90   
     91    protected function parseDatasource($xml) {
    8392        // -- tables
    8493        if(isset ($xml->datasources) && isset ($xml->datasources[0]->primarytable)){
    8594            $t = $this->_parseTable (0, $xml->datasources[0]->primarytable[0]);
    8695            $this->_primaryTable = $t['name'];
    8796            if(isset($xml->datasources[0]->primarytable[1])){
    88                 throw new jDaoXmlException ('table.two.many');
     97                throw new jDaoXmlException ($this->selector, 'table.two.many');
    8998            }
    9099            foreach($xml->datasources[0]->foreigntable as $table){
    91100                $this->_parseTable (1, $table);
     
    94103                $this->_parseTable (2, $table);
    95104            }
    96105        }else{
    97             throw new jDaoXmlException ('datasource.missing');
     106            throw new jDaoXmlException ($this->selector, 'datasource.missing');
    98107        }
    99 
    100         if($debug == 2) return;
     108    }
     109   
     110    protected function parseRecord($xml, $tools) {
    101111        $countprop = 0;
    102112        //add the record properties
    103113        if(isset($xml->record) && isset($xml->record[0]->property)){
    104114            foreach ($xml->record[0]->property as $prop){
    105                 $p = new jDaoProperty ($prop->attributes(), $this);
     115                $p = new jDaoProperty ($prop->attributes(), $this, $tools);
    106116                $this->_properties[$p->name] = $p;
    107117                $this->_tables[$p->table]['fields'][] = $p->name;
    108                 if(($p->table == $this->_primaryTable) && !$p->isPK)
     118                if($p->ofPrimaryTable && !$p->isPK)
    109119                    $countprop ++;
    110120            }
    111121            $this->hasOnlyPrimaryKeys = ($countprop == 0);
    112122        }else
    113             throw new jDaoXmlException ('properties.missing');
    114 
    115         if($debug == 1) return;
    116 
     123            throw new jDaoXmlException ($this->selector, 'properties.missing');
     124    }
     125   
     126    protected function parseFactory($xml) {
    117127        // get additionnal methods definition
    118128        if (isset ($xml->factory)) {
    119129            if (isset($xml->factory[0]['events'])) {
     
    125135                foreach($xml->factory[0]->method as $method){
    126136                    $m = new jDaoMethod ($method, $this);
    127137                    if(isset ($this->_methods[$m->name])){
    128                         throw new jDaoXmlException ('method.duplicate',$m->name);
     138                        throw new jDaoXmlException ($this->selector, 'method.duplicate',$m->name);
    129139                    }
    130140                    $this->_methods[$m->name] = $m;
    131141                }
     
    140150        $infos = $this->getAttr($tabletag, array('name','realname','primarykey','onforeignkey'));
    141151
    142152        if ($infos['name'] === null )
    143             throw new jDaoXmlException ('table.name');
     153            throw new jDaoXmlException ($this->selector, 'table.name');
    144154
    145155        if($infos['realname'] === null)
    146156            $infos['realname'] = $infos['name'];
    147157
    148158        if($infos['primarykey'] === null)
    149             throw new jDaoXmlException ('primarykey.missing');
     159            throw new jDaoXmlException ($this->selector, 'primarykey.missing');
    150160
    151161        $infos['pk']= preg_split("/[\s,]+/", $infos['primarykey']);
    152162        unset($infos['primarykey']);
    153163
    154164        if(count($infos['pk']) == 0 || $infos['pk'][0] == '')
    155             throw new jDaoXmlException ('primarykey.missing');
     165            throw new jDaoXmlException ($this->selector, 'primarykey.missing');
    156166
    157167        if($typetable){ // pour les foreigntable et optionalforeigntable
    158168            if($infos['onforeignkey'] === null)
    159                 throw new jDaoXmlException ('foreignkey.missing');
     169                throw new jDaoXmlException ($this->selector, 'foreignkey.missing');
    160170            $infos['fk']=preg_split("/[\s,]+/",$infos['onforeignkey']);
    161171            unset($infos['onforeignkey']);
    162172            if(count($infos['fk']) == 0 || $infos['fk'][0] == '')
    163                 throw new jDaoXmlException ('foreignkey.missing');
     173                throw new jDaoXmlException ($this->selector, 'foreignkey.missing');
    164174            if(count($infos['fk']) != count($infos['pk']))
    165                 throw new jDaoXmlException ('foreignkey.missing');
     175                throw new jDaoXmlException ($this->selector, 'foreignkey.missing');
    166176            if($typetable == 1){
    167177                $this->_ijoins[]=$infos['name'];
    168178            }else{
  • lib/jelix/dao/jDaoMethod.class.php

     
    44* @subpackage  dao
    55* @author      Croes Gérald, Laurent Jouanneau
    66* @contributor Laurent Jouanneau
    7 * @copyright   2001-2005 CopixTeam, 2005-2006 Laurent Jouanneau
     7* @copyright   2001-2005 CopixTeam, 2005-2009 Laurent Jouanneau
    88* This class was get originally from the Copix project (CopixDAODefinitionV1, Copix 2.3dev20050901, http://www.copix.org)
    99* Few lines of code are still copyrighted 2001-2005 CopixTeam (LGPL licence).
    1010* Initial authors of this Copix class are Gerald Croes and Laurent Jouanneau,
     
    3030    private $_parametersDefaultValues = array();
    3131    private $_limit = null;
    3232    private $_values = array();
    33     private $_def = null;
     33    private $_parser = null;
    3434    private $_procstock=null;
    3535    private $_body=null;
    3636    private $_groupBy=null;
    3737
    38     function __construct ($method, $def){
    39         $this->_def = $def;
     38    /**
     39     * @param simpleXmlElement $method  the xml element describing the method to generate
     40     * @param jDaoParser  $parser the parser on a dao file
     41    */
     42    function __construct ($method, $parser){
     43        $this->_parser = $parser;
    4044
    41         $params = $def->getAttr($method, array('name', 'type', 'call','distinct', 'eventbefore', 'eventafter', 'groupby'));
     45        $params = $parser->getAttr($method, array('name', 'type', 'call','distinct', 'eventbefore', 'eventafter', 'groupby'));
    4246
    4347        if ($params['name']===null){
    44             throw new jDaoXmlException ('missing.attr', array('name', 'method'));
     48            throw new jDaoXmlException ($this->_parser->selector, 'missing.attr', array('name', 'method'));
    4549        }
    4650
    4751        $this->name = $params['name'];
     
    5155            foreach ($method->parameter as $param){
    5256                $attr = $param->attributes();
    5357                if (!isset ($attr['name'])){
    54                     throw new jDaoXmlException ('method.parameter.unknowname', array($this->name));
     58                    throw new jDaoXmlException ($this->_parser->selector, 'method.parameter.unknowname', array($this->name));
    5559                }
    5660                $this->_parameters[]=(string)$attr['name'];
    5761                if (isset ($attr['default'])){
     
    6266
    6367        if($this->type == 'sql'){
    6468            if($params['call'] === null){
    65                 throw new jDaoXmlException  ('method.procstock.name.missing');
     69                throw new jDaoXmlException ($this->_parser->selector, 'method.procstock.name.missing');
    6670            }
    6771            $this->_procstock=$params['call'];
    6872            return;
     
    7276            if (isset ($method->body)){
    7377                $this->_body = (string)$method->body;
    7478            }else{
    75                 throw new jDaoXmlException  ('method.body.missing');
     79                throw new jDaoXmlException ($this->_parser->selector, 'method.body.missing');
    7680            }
    7781            return;
    7882        }
     
    9094        }
    9195
    9296        if($this->type == 'update'){
    93             if($this->_def->hasOnlyPrimaryKeys)
    94                 throw new jDaoXmlException ('method.update.forbidden',array($this->name));
     97            if($this->_parser->hasOnlyPrimaryKeys)
     98                throw new jDaoXmlException ($this->_parser->selector, 'method.update.forbidden',array($this->name));
    9599
    96100            if(isset($method->values) && isset($method->values[0]->value)){
    97101                foreach ($method->values[0]->value as $val){
    98102                    $this->_addValue($val);
    99103                }
    100104            }else{
    101                 throw new jDaoXmlException ('method.values.undefine',array($this->name));
     105                throw new jDaoXmlException ($this->_parser->selector, 'method.values.undefine',array($this->name));
    102106            }
    103107            return;
    104108        }
    105109
    106110        if(strlen($params['distinct'])){
    107111            if($this->type == 'select'){
    108                 $this->distinct=$this->_def->getBool($params['distinct']);
     112                $this->distinct=$this->_parser->getBool($params['distinct']);
    109113            }elseif($this->type == 'count'){
    110                 $props = $this->_def->getProperties();
     114                $props = $this->_parser->getProperties();
    111115                if (!isset ($props[$params['distinct']])){
    112                     throw new jDaoXmlException ('method.property.unknown', array($this->name, $params['distinct']));
     116                    throw new jDaoXmlException ($this->_parser->selector, 'method.property.unknown', array($this->name, $params['distinct']));
    113117                }
    114118                $this->distinct=$params['distinct'];
    115119            }else{
    116                 throw new jDaoXmlException ('forbidden.attr.context', array('distinct', '<method name="'.$this->name.'"'));
     120                throw new jDaoXmlException ($this->_parser->selector, 'forbidden.attr.context', array('distinct', '<method name="'.$this->name.'"'));
    117121            }
    118122        }
    119123
     
    129133        if(strlen($params['groupby'])){
    130134            if($this->type == 'select' || $this->type == 'selectfirst'){
    131135                $this->_groupBy = preg_split("/[\s,]+/", $params['groupby']);
    132                 $props = $this->_def->getProperties();
     136                $props = $this->_parser->getProperties();
    133137                foreach($this->_groupBy as $p){
    134138                    if (!isset ($props[$p])) {
    135                         throw new jDaoXmlException ('method.property.unknown', array($this->name, $p));
     139                        throw new jDaoXmlException ($this->_parser->selector, 'method.property.unknown', array($this->name, $p));
    136140                    }
    137141                }
    138142            }else{
    139                 throw new jDaoXmlException ('forbidden.attr.context', array('groupby', '<method name="'.$this->name.'"'));
     143                throw new jDaoXmlException ($this->_parser->selector, 'forbidden.attr.context', array('groupby', '<method name="'.$this->name.'"'));
    140144            }
    141145        }
    142146
    143147        if (isset($method->limit)){
    144148            if(isset($method->limit[1])){
    145                 throw new jDaoXmlException ('tag.duplicate', array('limit', $this->name));
     149                throw new jDaoXmlException ($this->_parser->selector, 'tag.duplicate', array('limit', $this->name));
    146150            }
    147151            if($this->type == 'select'){
    148152                $this->_addLimit($method->limit[0]);
    149153            }else{
    150                 throw new jDaoXmlException ('method.limit.forbidden', $this->name);
     154                throw new jDaoXmlException ($this->_parser->selector, 'method.limit.forbidden', $this->name);
    151155            }
    152156        }
    153157    }
     
    196200
    197201    private function _addCondition($op, $cond){
    198202
    199         $attr = $this->_def->getAttr($cond, $this->_attrcond);
     203        $attr = $this->_parser->getAttr($cond, $this->_attrcond);
    200204
    201205        $field_id = ($attr['property']!==null? $attr['property']:'');
    202206
    203207        if(!isset($this->_op[$op])){
    204             throw new jDaoXmlException ('method.condition.unknown', array($this->name, $op));
     208            throw new jDaoXmlException ($this->_parser->selector, 'method.condition.unknown', array($this->name, $op));
    205209        }
    206210
    207211        $operator = $this->_op[$op];
    208212
    209         $props = $this->_def->getProperties();
     213        $props = $this->_parser->getProperties();
    210214
    211215        if (!isset ($props[$field_id])){
    212             throw new jDaoXmlException ('method.property.unknown', array($this->name, $field_id));
     216            throw new jDaoXmlException ($this->_parser->selector, 'method.property.unknown', array($this->name, $field_id));
    213217        }
    214218
    215219        if($this->type=='update'){
    216             if($props[$field_id]->table != $this->_def->getPrimaryTable()){
    217                 throw new jDaoXmlException ('method.property.forbidden', array($this->name, $field_id));
     220            if($props[$field_id]->table != $this->_parser->getPrimaryTable()){
     221                throw new jDaoXmlException ($this->_parser->selector, 'method.property.forbidden', array($this->name, $field_id));
    218222            }
    219223        }
    220224
     
    224228            $value = null;
    225229
    226230        if($value!==null && $attr['expr']!==null){
    227             throw new jDaoXmlException ('method.condition.valueexpr.together', array($this->name, $op));
     231            throw new jDaoXmlException ($this->_parser->selector, 'method.condition.valueexpr.together', array($this->name, $op));
    228232        }else if($value!==null){
    229233            if($op == 'isnull' || $op =='isnotnull'){
    230                 throw new jDaoXmlException ('method.condition.valueexpr.notallowed', array($this->name, $op,$field_id));
     234                throw new jDaoXmlException ($this->_parser->selector, 'method.condition.valueexpr.notallowed', array($this->name, $op,$field_id));
    231235            }
    232236            if($op == 'binary_op') {
    233237                if (!isset($attr['operator']) || empty($attr['operator'])) {
    234                     throw new jDaoXmlException ('method.condition.operator.missing', array($this->name, $op,$field_id));
     238                    throw new jDaoXmlException ($this->_parser->selector, 'method.condition.operator.missing', array($this->name, $op,$field_id));
    235239                }
    236240                if (isset($attr['driver']) && !empty($attr['driver'])) {
    237                     if (jDaoCompiler::$dbType != $attr['driver']) {
    238                         throw new jDaoXmlException ('method.condition.driver.notallowed', array($this->name, $op,$field_id));
     241                    if ($this->_parser->selector->driver != $attr['driver']) {
     242                        throw new jDaoXmlException ($this->_parser->selector, 'method.condition.driver.notallowed', array($this->name, $op,$field_id));
    239243                    }
    240244                }
    241245                $operator = $attr['operator'];
     
    243247            $this->_conditions->addCondition ($field_id, $operator, $value);
    244248        }else if($attr['expr']!==null){
    245249            if($op == 'isnull' || $op =='isnotnull'){
    246                 throw new jDaoXmlException ('method.condition.valueexpr.notallowed', array($this->name, $op, $field_id));
     250                throw new jDaoXmlException ($this->_parser->selector, 'method.condition.valueexpr.notallowed', array($this->name, $op, $field_id));
    247251            }
    248252            if(($op == 'in' || $op =='notin')&& !preg_match('/^\$[a-zA-Z0-9_]+$/', $attr['expr'])){
    249                 throw new jDaoXmlException ('method.condition.innotin.bad.expr', array($this->name, $op, $field_id));
     253                throw new jDaoXmlException ($this->_parser->selector, 'method.condition.innotin.bad.expr', array($this->name, $op, $field_id));
    250254            }
    251255            if($op == 'binary_op') {
    252256                if (!isset($attr['operator']) || empty($attr['operator'])) {
    253                     throw new jDaoXmlException ('method.condition.operator.missing', array($this->name, $op,$field_id));
     257                    throw new jDaoXmlException ($this->_parser->selector, 'method.condition.operator.missing', array($this->name, $op,$field_id));
    254258                }
    255259                if (isset($attr['driver']) && !empty($attr['driver'])) {
    256                     if (jDaoCompiler::$dbType != $attr['driver']) {
    257                         throw new jDaoXmlException ('method.condition.driver.notallowed', array($this->name, $op,$field_id));
     260                    if ($this->_parser->selector->driver != $attr['driver']) {
     261                        throw new jDaoXmlException ($this->_parser->selector, 'method.condition.driver.notallowed', array($this->name, $op,$field_id));
    258262                    }
    259263                }
    260264                $operator = $attr['operator'];
     
    262266            $this->_conditions->addCondition ($field_id, $operator, $attr['expr'], true);
    263267        }else{
    264268            if($op != 'isnull' && $op !='isnotnull'){
    265                 throw new jDaoXmlException ('method.condition.valueexpr.missing', array($this->name, $op, $field_id));
     269                throw new jDaoXmlException ($this->_parser->selector, 'method.condition.valueexpr.missing', array($this->name, $op, $field_id));
    266270            }
    267271            $this->_conditions->addCondition ($field_id, $operator, '', false);
    268272        }
    269273    }
    270274
    271275    private function _addOrder($order){
    272         $attr = $this->_def->getAttr($order, array('property','way'));
     276        $attr = $this->_parser->getAttr($order, array('property','way'));
    273277
    274278        $way  = ($attr['way'] !== null ? $attr['way']:'ASC');
    275279
    276280        if(substr ($way,0,1) == '$'){
    277281            if(!in_array (substr ($way,1),$this->_parameters)){
    278                 throw new jDaoXmlException ('method.orderitem.parameter.unknow', array($this->name, $way));
     282                throw new jDaoXmlException ($this->_parser->selector, 'method.orderitem.parameter.unknow', array($this->name, $way));
    279283            }
    280284        }
    281285
    282286        if ($attr['property'] != ''){
    283             $prop =$this->_def->getProperties();
     287            $prop =$this->_parser->getProperties();
    284288            if(isset($prop[$attr['property']])){
    285289                $this->_conditions->addItemOrder($attr['property'], $way);
    286290            }elseif(substr ($attr['property'],0,1) == '$'){
    287291                if(!in_array (substr ($attr['property'],1),$this->_parameters)){
    288                     throw new jDaoXmlException ('method.orderitem.parameter.unknow', array($this->name, $way));
     292                    throw new jDaoXmlException ($this->_parser->selector, 'method.orderitem.parameter.unknow', array($this->name, $way));
    289293                }
    290294                $this->_conditions->addItemOrder($attr['property'], $way);
    291295            }else{
    292                 throw new jDaoXmlException ('method.orderitem.bad', array($attr['property'], $this->name));
     296                throw new jDaoXmlException ($this->_parser->selector, 'method.orderitem.bad', array($attr['property'], $this->name));
    293297            }
    294298        }else{
    295             throw new jDaoXmlException ('method.orderitem.property.missing', array($this->name));
     299            throw new jDaoXmlException ($this->_parser->selector, 'method.orderitem.property.missing', array($this->name));
    296300        }
    297301    }
    298302
     
    302306        else
    303307            $value = null;
    304308
    305         $attr = $this->_def->getAttr($attr, array('property','expr'));
     309        $attr = $this->_parser->getAttr($attr, array('property','expr'));
    306310
    307311        $prop = $attr['property'];
    308         $props =$this->_def->getProperties();
     312        $props =$this->_parser->getProperties();
    309313
    310314        if ($prop === null){
    311             throw new jDaoXmlException ('method.values.property.unknow', array($this->name, $prop));
     315            throw new jDaoXmlException ($this->_parser->selector, 'method.values.property.unknow', array($this->name, $prop));
    312316        }
    313317
    314318        if(!isset($props[$prop])){
    315             throw new jDaoXmlException ('method.values.property.unknow', array($this->name, $prop));
     319            throw new jDaoXmlException ($this->_parser->selector, 'method.values.property.unknow', array($this->name, $prop));
    316320        }
    317321
    318         if($props[$prop]->table != $this->_def->getPrimaryTable()){
    319             throw new jDaoXmlException ('method.values.property.bad', array($this->name,$prop ));
     322        if($props[$prop]->table != $this->_parser->getPrimaryTable()){
     323            throw new jDaoXmlException ($this->_parser->selector, 'method.values.property.bad', array($this->name,$prop ));
    320324        }
    321325
    322326        if($props[$prop]->isPK){
    323             throw new jDaoXmlException ('method.values.property.pkforbidden', array($this->name,$prop ));
     327            throw new jDaoXmlException ($this->_parser->selector, 'method.values.property.pkforbidden', array($this->name,$prop ));
    324328        }
    325329
    326330        if($value!==null && $attr['expr']!==null){
    327             throw new jDaoXmlException ('method.values.valueexpr', array($this->name, $prop));
     331            throw new jDaoXmlException ($this->_parser->selector, 'method.values.valueexpr', array($this->name, $prop));
    328332        }else if($value!==null){
    329333            $this->_values [$prop]= array( $value, false);
    330334        }else if($attr['expr']!==null){
     
    335339    }
    336340
    337341    private function _addLimit($limit){
    338         $attr = $this->_def->getAttr($limit, array('offset','count'));
     342        $attr = $this->_parser->getAttr($limit, array('offset','count'));
    339343
    340344        extract($attr);
    341345
    342346        if( $offset === null){
    343             throw new jDaoXmlException ('missing.attr',array('offset','limit'));
     347            throw new jDaoXmlException ($this->_parser->selector, 'missing.attr',array('offset','limit'));
    344348        }
    345349        if($count === null){
    346             throw new jDaoXmlException ('missing.attr',array('count','limit'));
     350            throw new jDaoXmlException ($this->_parser->selector, 'missing.attr',array('count','limit'));
    347351        }
    348352
    349353        if(substr ($offset,0,1) == '$'){
    350354            if(in_array (substr ($offset,1),$this->_parameters)){
    351355                $offsetparam=true;
    352356            }else{
    353                 throw new jDaoXmlException ('method.limit.parameter.unknow', array($this->name, $offset));
     357                throw new jDaoXmlException ($this->_parser->selector, 'method.limit.parameter.unknow', array($this->name, $offset));
    354358            }
    355359        }else{
    356360            if(is_numeric ($offset)){
    357361                $offsetparam=false;
    358362                $offset = intval ($offset);
    359363            }else{
    360                 throw new jDaoXmlException ('method.limit.badvalue', array($this->name, $offset));
     364                throw new jDaoXmlException ($this->_parser->selector, 'method.limit.badvalue', array($this->name, $offset));
    361365            }
    362366        }
    363367
     
    365369            if(in_array (substr ($count,1),$this->_parameters)){
    366370                $countparam=true;
    367371            }else{
    368                 throw new jDaoXmlException ('method.limit.parameter.unknow', array($this->name, $count));
     372                throw new jDaoXmlException ($this->_parser->selector, 'method.limit.parameter.unknow', array($this->name, $count));
    369373            }
    370374        }else{
    371375            if(is_numeric($count)){
    372376                $countparam=false;
    373377                $count=intval($count);
    374378            }else{
    375                 throw new jDaoXmlException ('method.limit.badvalue', array($this->name, $count));
     379                throw new jDaoXmlException ($this->_parser->selector, 'method.limit.badvalue', array($this->name, $count));
    376380            }
    377381        }
    378382        $this->_limit= compact('offset', 'count', 'offsetparam','countparam');
  • lib/jelix/dao/jDaoFactoryBase.class.php

     
    121121     *  'isPK' => true/false, //says if it is a primary key
    122122     *  'isFK' => true/false, //says if it is a foreign key
    123123     *  'datatype' => '', // type of data : string
     124     *  'unifiedType'=> '' // the corresponding unified type
    124125     *  'table' => 'grp', // alias of the table the property is attached to
    125126     *  'updatePattern' => '%s',
    126127     *  'insertPattern' => '%s',
    127128     *  'selectPattern' => '%s',
    128      *  'sequenceName' => '', // name of the sequence when type is autoincrement
     129     *  'sequenceName' => '', // name of the sequence when field is autoincrement
    129130     *  'maxlength' => NULL, // or a number
    130131     *  'minlength' => NULL, // or a number
    131      *  'ofPrimaryTable' => true/false,
    132      *  'needsQuotes' => tree/false, // says if the value need to enclosed between quotes
     132     *  'ofPrimaryTable' => true/false
     133     *  'autoIncrement'=> true/false
    133134     * ) </pre>
    134135     * @return array informations on all properties
    135136     * @since 1.0beta3
     
    394395                if(is_array($cond['value'])){
    395396                    $values = array();
    396397                    foreach($cond['value'] as $value)
    397                         $values[] = $this->_prepareValue($value,$prop['datatype']);
     398                        $values[] = $this->_prepareValue($value,$prop['unifiedType']);
    398399                    $values = join(',', $values);
    399400                }
    400401                else
     
    403404                $r .= $prefix.'('.$values.')';
    404405            }
    405406            else if (!is_array ($cond['value'])){
    406                 $value = $this->_prepareValue($cond['value'],$prop['datatype']);
     407                $value = $this->_prepareValue($cond['value'],$prop['unifiedType']);
    407408                if ($value === 'NULL'){
    408409                    if($op == '='){
    409410                        $r .= $prefixNoCondition.' IS NULL';
     
    420421                    if (!$firstCV){
    421422                        $r .= ' or ';
    422423                    }
    423                     $value = $this->_prepareValue($conditionValue,$prop['datatype']);
     424                    $value = $this->_prepareValue($conditionValue,$prop['unifiedType']);
    424425                    if ($value === 'NULL'){
    425426                        if($op == '='){
    426427                            $r .= $prefixNoCondition.' IS NULL';
     
    460461            return 'NULL';
    461462       
    462463        switch(strtolower($fieldType)){
    463             case 'int':
    464464            case 'integer':
    465             case 'autoincrement':
    466                 $value = intval($value);
    467                 break;
     465                return intval($value);
    468466            case 'double':
    469467            case 'float':
    470                 $value = doubleval($value);
    471                 break;
    472             case 'numeric'://usefull for bigint and stuff
    473             case 'bigautoincrement':
    474                 if (is_numeric ($value)){
    475                     //was numeric, we can sends it as is
    476                     // no cast with intval else overflow
     468                return doubleval($value);
     469            case 'numeric':
     470            case 'decimal':
     471                if(is_numeric($value))
    477472                    return $value;
    478                 }else{
    479                     //not a numeric, nevermind, casting it
    480                     return intval ($value);
    481                 }
    482                 break;
     473                else
     474                    return doubleval($value);
    483475            case 'boolean':
    484476                if ($value === true|| strtolower($value)=='true'|| $value =='1' || $value ==='t')
    485                     $value = $this->trueValue;
     477                    return $this->trueValue;
    486478                else
    487                     $value = $this->falseValue;
     479                    return $this->falseValue;
    488480                break;
    489481            default:
    490                 $value = $this->_conn->quote ($value);
     482                return $this->_conn->quote ($value);
    491483        }
    492         return $value;
    493484    }
    494485}
  • lib/jelix/dao/jDaoProperty.class.php

     
    44* @subpackage  dao
    55* @author      Croes Gérald, Laurent Jouanneau
    66* @contributor Laurent Jouanneau
    7 * @copyright   2001-2005 CopixTeam, 2005-2006 Laurent Jouanneau
     7* @copyright   2001-2005 CopixTeam, 2005-2009 Laurent Jouanneau
    88* This class was get originally from the Copix project (CopixDAODefinitionV1, Copix 2.3dev20050901, http://www.copix.org)
    99* Few lines of code are still copyrighted 2001-2005 CopixTeam (LGPL licence).
    1010* Initial authors of this Copix class are Gerald Croes and Laurent Jouanneau,
     
    6262    public $isFK = false;
    6363
    6464    public $datatype;
     65   
     66    public $unifiedType;
    6567
    6668    public $table=null;
    6769    public $updatePattern='%s';
     
    7981    public $ofPrimaryTable = true;
    8082
    8183    public $defaultValue = null;
     84   
     85    public $autoIncrement = false;
    8286    /**
    8387    * constructor.
     88    * @param array  $attributes  list of attributes of a simpleXmlElement
     89    * @param jDaoParser $parser the parser on the dao file
     90    * @param jDbTools $tools
    8491    */
    85     function __construct ($aParams, $def){
     92    function __construct ($aAttributes, $parser, $tools){
    8693        $needed = array('name', 'fieldname', 'table', 'datatype', 'required',
    87                         'minlength', 'maxlength', 'regexp', 'sequence', 'default');
     94                        'minlength', 'maxlength', 'regexp', 'sequence', 'default','autoincrement');
    8895
    89         $params = $def->getAttr($aParams, $needed);
     96        $params = $parser->getAttr($aAttributes, $needed);
    9097
    9198        if ($params['name']===null){
    92             throw new jDaoXmlException ('missing.attr', array('name', 'property'));
     99            throw new jDaoXmlException ($parser->selector, 'missing.attr', array('name', 'property'));
    93100        }
    94101        $this->name       = $params['name'];
    95102
    96103        if(!preg_match('/^[a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*$/', $this->name)){
    97             throw new jDaoXmlException ('property.invalid.name', $this->name);
     104            throw new jDaoXmlException ($parser->selector, 'property.invalid.name', $this->name);
    98105        }
    99106
    100107
    101108        $this->fieldName  = $params['fieldname'] !==null ? $params['fieldname'] : $this->name;
    102         $this->table      = $params['table'] !==null ? $params['table'] : $def->getPrimaryTable();
     109        $this->table      = $params['table'] !==null ? $params['table'] : $parser->getPrimaryTable();
    103110
    104         $tables = $def->getTables();
     111        $tables = $parser->getTables();
    105112
    106113        if(!isset( $tables[$this->table])){
    107             throw new jDaoXmlException ('property.unknow.table', $this->name);
     114            throw new jDaoXmlException ($parser->selector, 'property.unknow.table', $this->name);
    108115        }
    109116
    110         $this->required   = $this->requiredInConditions = $def->getBool ($params['required']);
     117        $this->required   = $this->requiredInConditions = $parser->getBool ($params['required']);
    111118        $this->maxlength  = $params['maxlength'] !== null ? intval($params['maxlength']) : null;
    112119        $this->minlength  = $params['minlength'] !== null ? intval($params['minlength']) : null;
    113120        $this->regExp     = $params['regexp'];
     121        $this->autoIncrement = $parser->getBool ($params['autoincrement']);
    114122
    115123        if ($params['datatype']===null){
    116             throw new jDaoXmlException ('missing.attr', array('datatype', 'property'));
     124            throw new jDaoXmlException ($parser->selector, 'missing.attr', array('datatype', 'property'));
    117125        }
    118         $params['datatype']=trim(strtolower($params['datatype']));
     126        $params['datatype'] = trim(strtolower($params['datatype']));
    119127
    120         if (!in_array ($params['datatype'],
    121                        array ('autoincrement', 'bigautoincrement', 'int',
    122                               'datetime', 'time', 'integer', 'varchar', 'string',
    123                               'text', 'varchardate', 'date', 'numeric', 'double',
    124                               'float', 'boolean'))){
    125            throw new jDaoXmlException ('wrong.attr', array($params['datatype'],
     128        if ($params['datatype'] == '') {
     129            throw new jDaoXmlException ($parser->selector, 'wrong.attr', array($params['datatype'],
    126130                                                           $this->fieldName,
    127131                                                           'property'));
    128132        }
    129133        $this->datatype = strtolower($params['datatype']);
    130         $this->needsQuotes = in_array ($params['datatype'],
    131                 array ('string', 'varchar', 'text', 'date', 'datetime', 'time'));
    132134
     135        $ti = $tools->getTypeInfo($this->datatype);
     136        $this->unifiedType = $ti[1];
     137        if (!$this->autoIncrement)
     138            $this->autoIncrement = $ti[6];
     139
     140        if ($this->unifiedType == 'integer' || $this->unifiedType == 'numeric') {
     141            if ($params['sequence'] !== null) {
     142                $this->sequenceName = $params['sequence'];
     143                $this->autoIncrement = true;
     144            }
     145        }
     146
    133147        $this->isPK = in_array($this->fieldName, $tables[$this->table]['pk']);
    134148        if(!$this->isPK){
    135149            $this->isFK = isset($tables[$this->table]['fk'][$this->fieldName]);
    136         } else {
     150        }
     151        else {
    137152            $this->required = true;
    138153            $this->requiredInConditions = true;
    139154        }
    140155
    141         if($this->datatype == 'autoincrement' || $this->datatype == 'bigautoincrement') {
    142             if($params['sequence'] !==null){
    143                 $this->sequenceName = $params['sequence'];
    144             }
     156        if ($this->autoIncrement) {
    145157            $this->required = false;
    146158            $this->requiredInConditions = true;
    147159        }
    148160
    149         if($params['default'] !== null) {
    150             switch($this->datatype) {
    151               case 'autoincrement':
    152               case 'int':
    153               case 'integer':
    154                 $this->defaultValue = intval($params['default']);
    155                 break;
    156               case 'double':
    157               case 'float':
    158                 $this->defaultValue = doubleval($params['default']);
    159                 break;
    160               case 'boolean':
    161                 $v = $params['default'];
    162                 $this->defaultValue = ($v =='1'|| $v=='t'|| strtolower($v) =='true');
    163                 break;
    164               default:
    165                 $this->defaultValue = $params['default'];
    166             }
     161        if ($params['default'] !== null) {
     162            $this->defaultValue = $tools->escapeValue($this->unifiedType, $params['default']);
    167163        }
    168164
    169         // on ignore les attributs *pattern sur les champs PK et FK
    170         if(!$this->isPK && !$this->isFK){
    171             if(isset($aParams['updatepattern'])) {
    172                 $this->updatePattern=(string)$aParams['updatepattern'];
     165        // we ignore *pattern attributes on PK and FK fields
     166        if (!$this->isPK && !$this->isFK) {
     167            if(isset($aAttributes['updatepattern'])) {
     168                $this->updatePattern=(string)$aAttributes['updatepattern'];
    173169            }
    174170
    175             if(isset($aParams['insertpattern'])) {
    176                 $this->insertPattern=(string)$aParams['insertpattern'];
     171            if(isset($aAttributes['insertpattern'])) {
     172                $this->insertPattern=(string)$aAttributes['insertpattern'];
    177173            }
    178174
    179             if(isset($aParams['selectpattern'])) {
    180                 $this->selectPattern=(string)$aParams['selectpattern'];
     175            if(isset($aAttributes['selectpattern'])) {
     176                $this->selectPattern=(string)$aAttributes['selectpattern'];
    181177            }
    182178        }
    183179
    184180        // no update and insert patterns for field of external tables
    185         if($this->table != $def->getPrimaryTable()){
     181        if ($this->table != $parser->getPrimaryTable()) {
    186182            $this->updatePattern = '';
    187183            $this->insertPattern = '';
    188184            $this->required = false;
    189185            $this->requiredInConditions = false;
    190186            $this->ofPrimaryTable = false;
    191         }else{
     187        }
     188        else {
    192189            $this->ofPrimaryTable=true;
    193190        }
    194191    }
  • lib/jelix/dao/jDaoGenerator.class.php

     
    4949
    5050    protected $aliasWord = ' AS ';
    5151
    52     protected $trueValue = 1;
    53     protected $falseValue = 0;
     52    /**
     53     * @var jDbTools
     54    */
     55    protected $tools;
    5456
     57    protected $_daoId;
     58    protected $_daoPath;
     59    protected $_dbType;
     60
    5561    /**
    5662    * constructor
    5763    * @param jDaoParser $daoDefinition
    5864    */
    59     function __construct($factoryClassName, $recordClassName, $daoDefinition){
    60         $this->_dataParser = $daoDefinition;
    61         $this->_DaoClassName = $factoryClassName;
    62         $this->_DaoRecordClassName = $recordClassName;
     65    function __construct($selector, $tools, $daoParser){
     66        $this->_daoId = $selector->toString();
     67        $this->_daoPath = $selector->getPath();
     68        $this->_dbType = $selector->driver;
     69        $this->_dataParser = $daoParser;
     70        $this->_DaoClassName = $selector->getDaoClass();
     71        $this->_DaoRecordClassName = $selector->getDaoRecordClass();
     72        $this->tools = $tools;
    6373    }
    6474
    6575    /**
     
    93103
    94104        $properties=array();
    95105
    96         foreach ($this->_dataParser->getProperties() as $id=>$field){
     106        foreach ($this->_dataParser->getProperties() as $id=>$field) {
    97107            $properties[$id] = get_object_vars($field);
    98             if($field->defaultValue !== null)
     108            if ($field->defaultValue !== null) {
    99109                $src[] =' public $'.$id.'='.var_export($field->defaultValue, true).';';
     110            }
    100111            else
    101112                $src[] =' public $'.$id.';';
    102113        }
     
    116127        $src[] = '   protected $_fromClause;';
    117128        $src[] = '   protected $_whereClause=\''.$sqlWhereClause.'\';';
    118129        $src[] = '   protected $_DaoRecordClassName=\''.$this->_DaoRecordClassName.'\';';
    119         $src[] = '   protected $_daoSelector = \''.jDaoCompiler::$daoId.'\';';
     130        $src[] = '   protected $_daoSelector = \''.$this->_daoId.'\';';
    120131
    121         if($this->trueValue != 1){
    122             $src[]='   protected $trueValue ='.var_export($this->trueValue,true).';';
    123             $src[]='   protected $falseValue ='.var_export($this->falseValue,true).';';
     132        if($this->tools->trueValue != '1'){
     133            $src[]='   protected $trueValue ='.var_export($this->tools->trueValue, true).';';
     134            $src[]='   protected $falseValue ='.var_export($this->tools->falseValue, true).';';
    124135        }
    125136
    126137        if($this->_dataParser->hasEvent('deletebefore') || $this->_dataParser->hasEvent('delete'))
     
    141152        $src[] = '   $this->_fromClause = \''.$sqlFromClause.'\';';
    142153        $src[] = '}';
    143154
    144         // cannot put this methods directly into jDaoBase because of a php bug on static methods/properties
     155        // cannot put this methods directly into jDaoBase because self cannot refer to a child class
     156        // FIXME PHP53, we could use the static keyword instead of self
    145157        $src[] = '   public function getProperties() { return self::$_properties; }';
    146158        $src[] = '   public function getPrimaryKeyNames() { return self::$_pkFields;}';
    147159
     
    283295        }else{
    284296            //the dao is mapped on a table which contains only primary key : update is impossible
    285297            // so we will generate an error on update
    286             $src[] = "     throw new jException('jelix~dao.error.update.impossible',array('".jDaoCompiler::$daoId."','".jDaoCompiler::$daoPath."'));";
     298            $src[] = "     throw new jException('jelix~dao.error.update.impossible',array('".$this->_daoId."','".$this->_daoPath."'));";
    287299            $src[] = " }";
    288300        }
    289301
     
    331343                            $sqlSet.= ', '.$this->_encloseName($updatefields[$propname]->fieldName). '= '. $value[0];
    332344                        }else{
    333345                            $sqlSet.= ', '.$this->_encloseName($updatefields[$propname]->fieldName). '= '.
    334                                 $this->_preparePHPValue($value[0],$updatefields[$propname]->datatype,false);
     346                                $this->tools->escapeValue($updatefields[$propname]->unifiedType, $value[0], false, true);
    335347                        }
    336348                    }
    337349                    $src[] =substr($sqlSet,1).'\';';
     
    592604    }
    593605
    594606    protected function _capturePrimaryFieldsExcludeAutoIncrement(&$field){
    595         return ($field->table == $this->_dataParser->getPrimaryTable()) &&
    596         ($field->datatype != 'autoincrement') && ($field->datatype != 'bigautoincrement');
     607        return ($field->table == $this->_dataParser->getPrimaryTable() && !$field->autoIncrement);
    597608    }
    598609
    599610    protected function _capturePrimaryFieldsExcludePk(&$field){
     
    612623        return ($field->table == $this->_dataParser->getPrimaryTable()
    613624                && !$field->isPK
    614625                && !$field->isFK
    615                 && ( $field->datatype == 'autoincrement' || $field->datatype == 'bigautoincrement'
    616                     || ($field->insertPattern != '%s' && $field->selectPattern != '')));
     626                && ( $field->autoIncrement || ($field->insertPattern != '%s' && $field->selectPattern != '')));
    617627    }
    618628
    619629    protected function _captureFieldToUpdateOnUpdate(&$field){
    620630        return ($field->table == $this->_dataParser->getPrimaryTable()
    621631                && !$field->isPK
    622632                && !$field->isFK
    623                 && ( $field->datatype == 'autoincrement' || $field->datatype == 'bigautoincrement'
    624                     || ($field->updatePattern != '%s' && $field->selectPattern != '')));
     633                && ( $field->autoIncrement || ($field->updatePattern != '%s' && $field->selectPattern != '')));
    625634    }
    626635
    627636    /**
     
    638647        foreach ($using as $id=>$field) {
    639648            if(!$field->isPK)
    640649                continue;
    641             if ($field->datatype == 'autoincrement' || $field->datatype == 'bigautoincrement') {
     650            if ($field->autoIncrement) {
    642651                return $field;
    643652            }
    644653        }
     
    828837                        foreach($params as $param){
    829838                            $value = str_replace('$'.$param, '\'.'.$this->_preparePHPExpr('$'.$param, $prop, !$prop->requiredInConditions).'.\'',$value);
    830839                        }
    831                         $value= $cond['operator'].' '.$value;
     840                        $value = $cond['operator'].' '.$value;
    832841                    }
    833842                }else{
    834                     $value= $cond['operator'].' '.$this->_preparePHPValue($cond['value'], $prop->datatype,false);
     843                    $value = $cond['operator'].' '.$this->tools->escapeValue($prop->unifiedType, $cond['value'], false, true);
    835844                }
    836845                $r.=$value;
    837846            }
     
    852861        return $r;
    853862    }
    854863
    855 
    856 
    857     /**
    858     * prepare a string ready to be included in a PHP script
    859     * we assume that if the value is "NULL", all things has been take care of
    860     *   before the call of this method
    861     * The method generates something like (including quotes) '.some PHP code.'
    862     *   (we do break "simple quoted strings")
    863     */
    864     protected function _preparePHPValue($value, $fieldType, $checknull=true){
    865         if($checknull){
    866             if($value == 'null' || $value == 'NULL' || $value === null)
    867                 return 'NULL';
    868         }
    869         switch(strtolower($fieldType)){
    870             case 'int':
    871             case 'integer':
    872             case 'autoincrement':
    873                 return intval($value);
    874             case 'double':
    875             case 'float':
    876                 return doubleval($value);
    877             case 'numeric': //usefull for bigint and stuff
    878             case 'bigautoincrement':
    879                 if(is_numeric($value))
    880                     return $value;
    881                 else
    882                     return intval($value);
    883             case 'boolean':
    884                 return $this->getBooleanValue($value);
    885             default:
    886                 if(strpos($value,"'") !== false){
    887                     return '\'.$this->_conn->quote(\''.str_replace('\'','\\\'',$value).'\').\'';
    888                 }else{
    889                     return "\\'".$value."\\'";
    890                 }
    891         }
    892     }
    893 
    894864    protected function _preparePHPExpr($expr, $field, $checknull=true, $forCondition=''){
    895865        $opnull=$opval='';
    896866        if($checknull && $forCondition != ''){
     
    904874        if($forCondition!='')
    905875            $forCondition = '\''.$forCondition.'\'.';
    906876
    907         switch(strtolower($field->datatype)){
    908             case 'int':
     877        switch(strtolower($field->unifiedType)){
    909878            case 'integer':
    910879                if($checknull){
    911880                    $expr= '('.$expr.' === null ? \''.$opnull.'NULL\' : '.$forCondition.'intval('.$expr.'))';
     
    913882                    $expr= $forCondition.'intval('.$expr.')';
    914883                }
    915884                break;
    916             case 'autoincrement':
    917                 $expr= $forCondition.'intval('.$expr.')';
    918                 break;
    919885            case 'double':
    920886            case 'float':
    921887                if($checknull){
     
    924890                    $expr= $forCondition.'doubleval('.$expr.')';
    925891                }
    926892                break;
    927             case 'numeric': //usefull for bigint and stuff
     893            case 'numeric':
     894            case 'decimal':
    928895                if($checknull){
    929                     $expr='('.$expr.' === null ? \''.$opnull.'NULL\' : '.$forCondition.'(is_numeric ('.$expr.') ? '.$expr.' : intval('.$expr.')))';
     896                    $expr='('.$expr.' === null ? \''.$opnull.'NULL\' : '.$forCondition.'(is_numeric ('.$expr.') ? '.$expr.' : floatval('.$expr.')))';
    930897                }else{
    931                     $expr=$forCondition.'(is_numeric ('.$expr.') ? '.$expr.' : intval('.$expr.'))';
     898                    $expr=$forCondition.'(is_numeric ('.$expr.') ? '.$expr.' : floatval('.$expr.'))';
    932899                }
    933900                break;
    934             case 'bigautoincrement':
    935                 $expr=$forCondition.'(is_numeric ('.$expr.') ? '.$expr.' : intval('.$expr.'))';
    936                 break;
    937901            case 'boolean':
    938902                if($checknull){
    939903                    $expr= '('.$expr.' === null ? \''.$opnull.'NULL\' : '.$forCondition.'$this->_prepareValue('.$expr.', "boolean", true))';
     
    952916    }
    953917
    954918    protected function _encloseName($name){
    955         return $name;
     919        return $this->tools->encloseName($name);
    956920    }
    957921
    958922    protected function genUpdateAutoIncrementPK($pkai, $pTableRealName) {
    959923        return '       $record->'.$pkai->name.'= $this->_conn->lastInsertId();';
    960924    }
    961 
    962     protected function getBooleanValue($value){
    963         return (strtolower($value)=='true'|| $value =='1'|| $value=='t'?$this->trueValue:$this->falseValue);
    964     }
    965925}
  • lib/jelix/controllers/jControllerDaoCrudDfk.class.php

     
    154154            $dao = jDao::get($this->dao, $this->dbProfile);
    155155
    156156        $props = $dao->getProperties();
    157         $dt = $props[$this->dpkName]['datatype'];
    158         return ($dt == 'autoincrement' || $dt == 'bigautoincrement');
     157        return ($props[$this->dpkName]['autoIncrement'] == true);
    159158    }
    160159
    161160    protected function _getPk($spk, $dpk, $dao=null) {