An error occurred fetching the project authors.
  1. 16 May, 2005 1 commit
    • unknown's avatar
      After merge fixes · d15f89c4
      unknown authored
      mysql-test/r/alter_table.result:
        Fixed results after merge
      sql/handler.cc:
        Trivial optimzation
      sql/sql_table.cc:
        Trvial optimization
      sql/sql_yacc.yy:
        After merge fix
      sql/unireg.cc:
        Removed argument 'null_fields' from make_empty_rec() as it was not needed
        Moved assert() to right place to take bit fields into account
      d15f89c4
  2. 13 May, 2005 1 commit
    • unknown's avatar
      Fixes during review · 2a695127
      unknown authored
      mysql-test/r/select.result:
        Better error message
      mysql-test/t/select.test:
        Better error message
      sql/hostname.cc:
        Join identical code
      sql/sql_yacc.yy:
        Combine code (and get a better error message)
      strings/ctype-ucs2.c:
        Cast pointer differencess
      2a695127
  3. 09 May, 2005 1 commit
    • unknown's avatar
      Bug#8733 - server accepts malformed query (multiply mentioned distinct) · 19b86438
      unknown authored
        Detect conflicting options in SELECT
      
      
      mysql-test/r/select.result:
        Test for bug#8733
      mysql-test/t/select.test:
        Test for bug#8733
      sql/mysql_priv.h:
        New bit for ALL
      sql/sql_yacc.yy:
        We want to complain if DISTINCT or ALL is used in SELECT when a
        conflicting option is already selected.
      19b86438
  4. 08 May, 2005 1 commit
    • unknown's avatar
      Bug#8191 - SELECT INTO OUTFILE insists on FROM clause · 3ac2df4e
      unknown authored
        Fix bug + include test case.
        Enable outfile tests.
      
      
      mysql-test/t/outfile.test:
        Reenable outfile tests
        Add test for Bug#8191
      sql/sql_yacc.yy:
        Fix Bug#8191
      BitKeeper/etc/logging_ok:
        Logging to logging@openlogging.org accepted
      3ac2df4e
  5. 07 May, 2005 1 commit
    • unknown's avatar
      Bug#9666 - Can't use 'DEFAULT FALSE' for column of type bool · 76f63c97
      unknown authored
        Fix bug by moving TRUE/FALSE in with other literals.
      
      
      mysql-test/r/create.result:
        Test for Bug#9666
      mysql-test/t/create.test:
        Test for Bug#9666
      sql/sql_yacc.yy:
        Move TRUE/FALSE in with other literals.
      BitKeeper/etc/logging_ok:
        Logging to logging@openlogging.org accepted
      76f63c97
  6. 06 May, 2005 1 commit
    • unknown's avatar
      Fixes while reviewing new code · ab54e167
      unknown authored
      Added option --count to mysqlshow (to show number of rows)
      Fixed possible core dump in information schema
      
      
      client/client_priv.h:
        --count for mysqlshow
      client/mysqlshow.c:
        Added option --count to be used when the user want's number of rows per table in the output
        (We shouldn't use count(*) as default as this can be a slow operation)
      mysys/my_thr_init.c:
        Correct comment
      sql/ha_berkeley.cc:
        Remove not used variable
      sql/ha_berkeley.h:
        Remove not used variable
      sql/ha_innodb.cc:
        Remove not used function
      sql/ha_ndbcluster.cc:
        false -> FALSE
        true -> TRUE
      sql/handler.cc:
        Added and fixed comments
        Remove 'strange' code to remove compiler warnings (better to do things like this with attribute)
      sql/item.cc:
        false -> FALSE
      sql/item_cmpfunc.cc:
        Fixed indentation
      sql/item_cmpfunc.h:
        marked BETWEEN as a bool function
      sql/item_func.cc:
        Simple optimzation
      sql/key.cc:
        Removed wrong code
      sql/log.cc:
        Check result from open_index_file()
      sql/mysql_priv.h:
        Simplyfy some test of netware
      sql/mysqld.cc:
        Fixed indentation
        Check result form open_index_file()
        Simplify code with IF_NETWARE()
      sql/opt_range.cc:
        false -> FALSE
        true -> TRUE
        Fixed indentation
      sql/opt_sum.cc:
        Fixed comments
      sql/sp_head.cc:
        Simple optimzation
        Move variable declarations to begining of blocks
      sql/sql_acl.cc:
        Fix long lines
        Rename xx -> column
        Move declaration to beginning of block
      sql/sql_parse.cc:
        Removed comment
      sql/sql_select.cc:
        Indentation fixes
      sql/sql_show.cc:
        Fixed reference outside of array (possible core dump)
      sql/sql_table.cc:
        Simplify code
        Combine common code
      sql/sql_test.cc:
        false -> FALSE
      sql/sql_trigger.cc:
        false -> false
        true -> TRUE
      sql/sql_yacc.yy:
        Simpler test
      sql/unireg.cc:
        Added comment
      ab54e167
  7. 26 Apr, 2005 1 commit
    • unknown's avatar
      Fixed BUG#8408: Stored procedure crash if function contains SHOW · ede52616
      unknown authored
        We simply have to disallow any kind of result set being sent back
        from a function. Can't see any way to make that to work.
      
      
      mysql-test/r/sp-error.result:
        New test case for BUG#8408.
      mysql-test/t/sp-error.test:
        New test case for BUG#8408.
      sql/item_func.cc:
        Disable result sets from functions but temporarily turning CLIENT_MULTI_RESULTS off.
      sql/share/errmsg.txt:
        Added error message for statements not allowed in functions (detected during parsing).
      sql/sql_yacc.yy:
        Don't allow result sets in functions.
      ede52616
  8. 20 Apr, 2005 1 commit
    • unknown's avatar
      Fixed BUG#7047: Stored procedure crash if alter procedure · c751c6ce
      unknown authored
        by simply disallowing alter procedure/function in an SP (as for drop).
      
      
      mysql-test/r/sp-error.result:
        Added test case for BUG#7047.
      mysql-test/t/sp-error.test:
        Added test case for BUG#7047.
      sql/share/errmsg.txt:
        Modified error message for "update procedure/function" too.
      sql/sql_yacc.yy:
        Don't allow alter procedure/function in an SP.
      c751c6ce
  9. 19 Apr, 2005 1 commit
    • unknown's avatar
      Bug#9102 - Stored proccedures: function which returns blob causes crash · 9bf92ed6
      unknown authored
        Initialization of fields for sp return type was not complete.
      
      
      mysql-test/r/sp.result:
        Bug#9102
          Test for bug
      mysql-test/t/sp.test:
        Bug#9102
          Test for bug
      sql/mysql_priv.h:
        Bug#9102
          new function: sp_prepare_create_field()
      sql/sp_head.cc:
        Strip spaces and do charset conversion for sp function typelibs
      sql/sql_table.cc:
        Bug#9102
          new function - sp_prepare_create_field()
          prepares create_field in similar way to mysql_prepare_table()
      sql/sql_yacc.yy:
        Bug#9102
      9bf92ed6
  10. 15 Apr, 2005 3 commits
    • unknown's avatar
      BUG#9922 - INSERT SELECT with UNIONs allows concurrent INSERTs · e2d9929d
      unknown authored
      don't set lex->lock_option=TL_READ in the parser for SELECT
      
      
      e2d9929d
    • unknown's avatar
      Fix for bug #9486 "Can't perform multi-update in stored procedure". · c69e2fc7
      unknown authored
      New more SP-locking friendly approach to handling locks in multi-update.
      Now we mark all tables of multi-update as needing write lock at parsing
      stage and if possible downgrade lock at execution stage (For its work
      SP-locking mechanism needs to know all lock types right after parsing
      stage).
      
      
      mysql-test/r/sp-threads.result:
        Added test for bug #9486 "Can't perform multi-update in stored procedure".
      mysql-test/t/sp-threads.test:
        Added test for bug #9486 "Can't perform multi-update in stored procedure".
      sql/sp_head.cc:
        SP_TABLE, sp_head::merge_table_list()/add_used_tables_to_table_list():
          Since some queries during their execution (e.g. multi-update)
          may change type of lock for some of their tables and thus change
          lock_type member for some of elements of table list, we should
          store type of lock in SP_TABLE struct explicitly instead of using
          lock_type member of TABLE_LIST object pointed by SP_TABLE::table.
      sql/sql_lex.h:
        Removed no longer used LEX::multi_lock_option member.
      sql/sql_prepare.cc:
        mysql_test_update():
          We don't need to bother about LEX::multi_lock_option if we convert
          multi-update to update anymore. Since nowdays multi-update uses 
          TABLE_LIST::lock_type for specifying lock level of updated tables
          instead of LEX::multi_lock_option.
      sql/sql_update.cc:
        mysql_update()/mysql_multi_update_prepare():
         Now we mark all tables of multi-update as needing write lock at parsing
         stage and if possible downgrade lock at execution stage. Old approach
         (don't set lock type until execution stage) was not working well with
         SP-locking (For its work SP-locking mechanism needs to know all lock 
         types right after parsing stage).
        
        mysql_multi_update():
          We should return FALSE if no error occurs.
      sql/sql_yacc.yy:
        update:
         Now we mark all tables of multi-update as needing write lock at parsing
         stage and if possible downgrade lock at execution stage. Old approach
         (don't set lock type until execution stage) was not working well with
         SP-locking (For its work SP-locking mechanism needs to know all lock 
         types right after parsing stage).
      c69e2fc7
    • unknown's avatar
      Fixed BUG#9902: Crash with simple stored function using user defined variables · 53c095f0
      unknown authored
        ... actually, it was a query cache problem. (It shouldn't cache such queries)
      
      
      mysql-test/r/sp.result:
        Added testcase for BUG#9902.
      mysql-test/t/sp.test:
        Added testcase for BUG#9902.
      sql/sql_yacc.yy:
        Don't cache queries which are calling stored functions.
      53c095f0
  11. 13 Apr, 2005 1 commit
  12. 12 Apr, 2005 3 commits
    • unknown's avatar
      mysql-test/r/flush_block_commit.result · 70d8ae01
      unknown authored
          correct result after bugfix
      sql/sql_class.cc
          initialize net.query_cache_query
      
      
      mysql-test/r/flush_block_commit.result:
        correct result after bugfix
      sql/sql_class.cc:
        initialize net.query_cache_query
      sql/sql_yacc.yy:
        oops
      70d8ae01
    • unknown's avatar
      FLUSH TABLES WITH READ LOCK should block writes to binlog too · 859b3e16
      unknown authored
      mysql-test/r/flush_block_commit.result:
        FLUSH TABLES WITH READ LOCK should block writes to binlog too
        it does not yet
      mysql-test/t/flush_block_commit.test:
        FLUSH TABLES WITH READ LOCK should block writes to binlog too
        it does not yet
      859b3e16
    • unknown's avatar
      Fixed BUG#7185: Stored procedure crash if identifier is AVG · db40f4a5
      unknown authored
      mysql-test/r/sp.result:
        Added test case for BUG#7185.
      mysql-test/t/sp.test:
        Added test case for BUG#7185.
      sql/sql_yacc.yy:
        Allow non-reserved words as stored procedure names.
      db40f4a5
  13. 08 Apr, 2005 1 commit
    • unknown's avatar
      Fixed BUG#9073: Able to declare two handlers for same condition in same scope · fc5db935
      unknown authored
      mysql-test/r/sp-error.result:
        Added test case for BUG#9073.
      mysql-test/t/sp-error.test:
        Added test case for BUG#9073.
      sql/share/errmsg.txt:
        New error message for duplicate condition handlers in stored procedures.
      sql/sp_pcontext.cc:
        Keep track on condition handlers in the same block for error checking.
      sql/sp_pcontext.h:
        Keep track on condition handlers in the same block for error checking.
      sql/sql_yacc.yy:
        Keep track on condition handlers in the same block for error checking.
      fc5db935
  14. 06 Apr, 2005 2 commits
  15. 03 Apr, 2005 1 commit
    • unknown's avatar
      XID SQL syntax · 2fc4270b
      unknown authored
      minor cleanups
      XA tests
      
      
      include/m_ctype.h:
        minor cleanup
      sql/field.cc:
        minor cleanup
      sql/handler.cc:
        XID SQL syntax
      sql/handler.h:
        XID SQL syntax
      sql/item_sum.h:
        minor cleanup
      sql/lock.cc:
        comments
      sql/sql_class.cc:
        minor cleanup
      sql/sql_lex.h:
        XID SQL syntax
      sql/sql_parse.cc:
        XID SQL syntax
      sql/sql_yacc.yy:
        XID SQL syntax
        cleanups
      2fc4270b
  16. 30 Mar, 2005 1 commit
    • unknown's avatar
      Fixed BUG#6600: Stored procedure crash after repeated calls with check table. · 66b71ca3
      unknown authored
        Sedond attempt: Simply disallow CHECK in SPs, since it can't work.
      
      
      mysql-test/r/sp-error.result:
        New test cast for BUG#6600
      mysql-test/r/sp.result:
        Removed old test case for BUG#6600
      mysql-test/t/sp-error.test:
        New test cast for BUG#6600
      mysql-test/t/sp.test:
        Removed old test case for BUG#6600
      sql/share/errmsg.txt:
        Made the SP bad statement error message more general.
      sql/sp_head.cc:
        CHECK is not possible in stored procedures.
      sql/sql_parse.cc:
        Undid attempt to fix CHECK in stored procedures, it didn't work.
      sql/sql_yacc.yy:
        CHECK is not possible in stored procedures.
        (And updated error messages for LOCK/UNLOCK.)
      66b71ca3
  17. 29 Mar, 2005 1 commit
    • unknown's avatar
      Cleanups during review · 51690eca
      unknown authored
      ndb/src/ndbapi/DictCache.cpp:
        Simpler bit handling code
      sql/sql_acl.cc:
        Fix for bool parameter
      sql/sql_yacc.yy:
        Removed compiler warning
      51690eca
  18. 22 Mar, 2005 1 commit
    • unknown's avatar
      sql_acl.cc, sql_acl.h, sql_parse.cc · 30a23278
      unknown authored
        New privilege CREATE USER (CREATE_USER_ACL, Create_user_priv) added
      grant2.test:
        new tests (mostly backported from jani's patch)
      system_mysql_db.result, sp.result, grant2.result, grant.result:
        results updated
      
      
      mysql-test/r/grant.result:
        results updated
      mysql-test/r/grant2.result:
        results updated
      mysql-test/r/sp.result:
        results updated
      mysql-test/r/system_mysql_db.result:
        results updated
      mysql-test/t/grant2.test:
        new tests (mostly backported from jani's patch)
      scripts/mysql_create_system_tables.sh:
        Create_user_priv added
      scripts/mysql_fix_privilege_tables.sql:
        Create_user_priv added
      sql/sql_acl.cc:
        Create_user_priv added
      sql/sql_acl.h:
        Create_user_priv added
      sql/sql_parse.cc:
        Create_user_priv added
      sql/sql_show.cc:
        Create_user_priv added
      sql/sql_yacc.yy:
        Create_user_priv added
      BitKeeper/etc/logging_ok:
        Logging to logging@openlogging.org accepted
      30a23278
  19. 16 Mar, 2005 4 commits
    • unknown's avatar
      Cleanup during reviews · 284b8b8b
      unknown authored
      Removed some optional arguments
      Fixed portability problem in federated tests
      
      
      client/sql_string.cc:
        update from sql/sql_string.cc
      client/sql_string.h:
        update from sql/sql_string.h
      mysql-test/r/federated.result:
        Fixed error message
      sql/field.cc:
        Cleanup during review
        Remove const in 'const unsigned int'
      sql/field.h:
        Remove const in 'const unsigned int'
      sql/ha_federated.cc:
        Better error string.  Add missing argument to error (before 'errno' was picked up from stack)
      sql/handler.cc:
        Removed compiler warning
      sql/item_func.cc:
        Cleanup during review
      sql/item_sum.cc:
        Cleanup during review
      sql/lock.cc:
        Remove optional arguments
      sql/log_event.cc:
        Remove optional arguments
      sql/mysql_priv.h:
        Remove optional arguments
        cahnge preapre_create_fields to use pointers instead of references
      sql/opt_range.cc:
        Fix arguments so that return value is last
      sql/sql_base.cc:
        Remove optional arguments
      sql/sql_delete.cc:
        Remove optional arguments
      sql/sql_error.cc:
        Remove optional arguments
      sql/sql_help.cc:
        Remove optional arguments
      sql/sql_parse.cc:
        Remove optional arguments
      sql/sql_prepare.cc:
        Remove optional arguments
      sql/sql_rename.cc:
        Remove optional arguments
      sql/sql_select.cc:
        Remove optional arguments
      sql/sql_show.cc:
        Cleanup during review
      sql/sql_string.cc:
        Simple optimization
      sql/sql_table.cc:
        Remove optional arguments
        Fixed indentation
      sql/sql_update.cc:
        Remove optional arguments
      sql/sql_yacc.yy:
        Change references to pointers
      284b8b8b
    • unknown's avatar
      Fixed behavior of LOAD DATA with subqueries in SET clause. · ec919d74
      unknown authored
      The idea is to use TABLE_LIST::lock_type for passing type of lock for
      target table to mysql_load() instead of using LEX::lock_option 
      (which were rewritten by first subselect in SET clause).
      
      This should also fix potential problem with LOAD DATA in SP
      (it is important for them to have right lock_type in the table
       list by the end of statement parsing).
      
      
      mysql-test/r/loaddata.result:
        Added nice test for LOAD DATA with subquery.
      mysql-test/t/loaddata.test:
        Added nice test for LOAD DATA with subquery.
      sql/log_event.cc:
        Now we don't pass type of lock for target table to mysql_load()
        explicitly . Instead we use TABLE_LIST::lock_type for this table
        which is already properly set here.
      sql/mysql_priv.h:
        Now we don't pass type of lock for target table to mysql_load()
        explicitly . Instead we properly set TABLE_LIST::lock_type for
        this table in parser.
      sql/sql_load.cc:
        Now we don't pass type of lock for target table to mysql_load()
        explicitly . Instead we properly set TABLE_LIST::lock_type for
        this table in parser.
      sql/sql_parse.cc:
        Now we don't pass type of lock for target table to mysql_load()
        explicitly . Instead we properly set TABLE_LIST::lock_type for
        this table in parser.
      sql/sql_yacc.yy:
        load_data:
          Let us use TABLE_LIST::lock_type for passing type of lock for target
          table to mysql_load() instead of using LEX::lock_option (which will
          be rewritten by first subselect in SET clause).
      ec919d74
    • unknown's avatar
      WL#874 "Extended LOAD DATA". · 5f75c8f5
      unknown authored
      Now one can use user variables as target for data loaded from file
      (besides table's columns). Also LOAD DATA got new SET-clause in which
      one can specify values for table columns as expressions.
      
      For example the following is possible:
      LOAD DATA INFILE 'words.dat' INTO TABLE t1 (a, @b) SET c = @b + 1;
      
      This patch also implements new way of replicating LOAD DATA.
      Now we do it similarly to other queries.
      We store LOAD DATA query in new Execute_load_query event
      (which is last in the sequence of events representing LOAD DATA).
      When we are executing this event we simply rewrite part of query which
      holds name of file (we use name of temporary file) and then execute it
      as usual query. In the beggining of this sequence we use Begin_load_query
      event which is almost identical to Append_file event
      
      
      client/mysqlbinlog.cc:
        Added support of two new binary log events Begin_load_query_log_event and
        Execute_load_query_log_Event which are used to replicate LOAD DATA INFILE.
      mysql-test/r/ctype_ucs.result:
        Addition of two new types of binary log events shifted binlog positions.
        Updated test's results and made it more robust for future similar 
        changes.
      mysql-test/r/insert_select.result:
        Addition of two new types of binary log events shifted binlog positions.
        Updated test's results and made it more robust for future similar 
        changes.
      mysql-test/r/loaddata.result:
        Added tests for new LOAD DATA features.
      mysql-test/r/mix_innodb_myisam_binlog.result:
        Addition of two new types of binary log events shifted binlog positions.
        Updated test's results (don't dare to get rid from binlog positions
        completely since it seems that this test uses them).
      mysql-test/r/mysqlbinlog.result:
        New approach for binlogging of LOAD DATA statement. Now we store it as
        usual query and rewrite part in which file is specified when needed.
        So now mysqlbinlog output for LOAD DATA much more closer to its initial
        form. Updated test'd results accordingly.
      mysql-test/r/mysqldump.result:
        Made test more robust to other tests failures.
      mysql-test/r/rpl000015.result:
        Addition of two new types of binary log events shifted binlog positions.
        Updated test's results accordingly.
      mysql-test/r/rpl_change_master.result:
        Addition of two new types of binary log events shifted binlog positions.
        Updated test's results.
      mysql-test/r/rpl_charset.result:
        Addition of two new types of binary log events shifted binlog positions.
        Updated test's results accordingly
      mysql-test/r/rpl_deadlock.result:
        Addition of two new types of binary log events shifted binlog positions.
        Updated test's results accordingly
      mysql-test/r/rpl_error_ignored_table.result:
        Addition of two new types of binary log events shifted binlog positions.
        Updated test's results and made it more robust for future similar 
        changes.
      mysql-test/r/rpl_flush_log_loop.result:
        Addition of two new types of binary log events shifted binlog positions.
        Updated test's results accordingly.
      mysql-test/r/rpl_flush_tables.result:
        Addition of two new types of binary log events shifted binlog positions.
        Updated test's results and made it more robust for future similar 
        changes.
      mysql-test/r/rpl_loaddata.result:
        New way of replicating LOAD DATA. Now we do it similarly to other
        queries. We store LOAD DATA query in new Execute_load_query event
        (which is last in the sequence of events representing LOAD DATA).
        When we are executing this event we simply rewrite part of query which
        holds name of file (we use name of temporary file) and then execute it
        as usual query. In the beggining of this sequence we use Begin_load_query
        event which is almost identical to Append_file event...
        
        Updated test's results wwith new binlog positions.
      mysql-test/r/rpl_loaddata_rule_m.result:
        Addition of two new types of binary log events shifted binlog positions.
        Updated test's results and made it more robust for future similar 
        changes.
        Since now LOAD DATA is replicated much in the same way as usual query
        --binlog_do/ignore_db work for it inthe same way as for usual queries.
      mysql-test/r/rpl_loaddata_rule_s.result:
        Addition of two new types of binary log events shifted binlog positions.
        Updated test's results accordingly.
      mysql-test/r/rpl_loaddatalocal.result:
        Added nice test for case when it is important that LOAD DATA LOCAL
        ignores duplicates.
      mysql-test/r/rpl_log.result:
        Addition of two new types of binary log events shifted binlog positions.
        Updated test's results accordingly (don't dare to get rid from binlog 
        positions completely since it seems that this test uses them).
      mysql-test/r/rpl_log_pos.result:
        Addition of two new types of binary log events shifted binlog positions.
        Updated test's results accordingly.
      mysql-test/r/rpl_max_relay_size.result:
        Addition of two new types of binary log events shifted binlog positions.
        Updated test's results accordingly.
      mysql-test/r/rpl_multi_query.result:
        Addition of two new types of binary log events shifted binlog positions.
        Updated test's results accordingly.
      mysql-test/r/rpl_relayrotate.result:
        Addition of two new types of binary log events shifted binlog positions.
        Updated test's results accordingly.
      mysql-test/r/rpl_replicate_do.result:
        Addition of two new types of binary log events shifted binlog positions.
        Updated test's results accordingly.
      mysql-test/r/rpl_reset_slave.result:
        Addition of two new types of binary log events shifted binlog positions.
        Updated test's results accordingly.
      mysql-test/r/rpl_rotate_logs.result:
        Addition of two new types of binary log events shifted binlog positions.
        Updated test's results accordingly.
      mysql-test/r/rpl_server_id1.result:
        Addition of two new types of binary log events shifted binlog positions.
        Updated test's results accordingly.
      mysql-test/r/rpl_server_id2.result:
        Addition of two new types of binary log events shifted binlog positions.
        Updated test's results accordingly.
      mysql-test/r/rpl_temporary.result:
        Addition of two new types of binary log events shifted binlog positions.
        Updated test's results and made it more robust for future similar 
        changes.
      mysql-test/r/rpl_timezone.result:
        Addition of two new types of binary log events shifted binlog positions.
        Updated test's results and made it more robust for future similar 
        changes.
      mysql-test/r/rpl_until.result:
        Addition of two new types of binary log events shifted binlog positions.
        Updated test's results accordingly and tweaked test a bit to bring it
        back to good shape.
      mysql-test/r/rpl_user_variables.result:
        Addition of two new types of binary log events shifted binlog positions.
        Updated test's results and made it more robust for future similar 
        changes.
      mysql-test/r/user_var.result:
        Addition of two new types of binary log events shifted binlog positions.
        Updated test's results and made it more robust for future similar 
        changes.
      mysql-test/t/ctype_ucs.test:
        Addition of two new types of binary log events shifted binlog positions.
        Updated test accordingly and made it more robust for future similar
        changes.
      mysql-test/t/insert_select.test:
        Addition of two new types of binary log events shifted binlog positions.
        Updated test accordingly and made it more robust for future similar
        changes.
      mysql-test/t/loaddata.test:
        Added test cases for new LOAD DATA functionality.
      mysql-test/t/mix_innodb_myisam_binlog.test:
        Addition of two new types of binary log events shifted binlog positions.
        Updated test accordingly.
      mysql-test/t/mysqlbinlog.test:
        New way of replicating LOAD DATA local. Now we do it similarly to other
        queries. We store LOAD DATA query in new Execute_load_query event
        (which is last in the sequence of events representing LOAD DATA).
        When we are executing this event we simply rewrite part of query which
        holds name of file (we use name of temporary file) and then execute it
        as usual query. In the beggining of this sequence we use Begin_load_query
        event which is almost identical to Append_file event...
        
        Thus we need new binlog positions for LOAD DATA events.
      mysql-test/t/mysqlbinlog2.test:
        Addition of two new types of binary log events shifted binlog positions.
        Updated test accordingly.
      mysql-test/t/mysqldump.test:
        Made test more robust for failures of other tests.
      mysql-test/t/rpl_charset.test:
        Addition of two new types of binary log events shifted binlog positions.
        Updated test accordingly.
      mysql-test/t/rpl_deadlock.test:
        Addition of two new types of binary log events shifted binlog positions.
        Updated test accordingly.
      mysql-test/t/rpl_error_ignored_table.test:
        Addition of two new types of binary log events shifted binlog positions.
        Updated test accordingly and made it more robust for future similar
        changes.
      mysql-test/t/rpl_flush_tables.test:
        Addition of two new types of binary log events shifted binlog positions.
        Made test more robust for future similar changes.
      mysql-test/t/rpl_loaddata.test:
        New way of replicating LOAD DATA. Now we do it similarly to other
        queries. We store LOAD DATA query in new Execute_load_query event
        (which is last in the sequence of events representing LOAD DATA).
        When we are executing this event we simply rewrite part of query which
        holds name of file (we use name of temporary file) and then execute it
        as usual query. In the beggining of this sequence we use Begin_load_query
        event which is almost identical to Append_file event...
        
        Apropritely updated comments in test.
      mysql-test/t/rpl_loaddata_rule_m.test:
        Addition of two new types of binary log events shifted binlog positions.
        Updated test accordingly and made it more robust for future similar 
        changes.
        Since now LOAD DATA is replicated much in the same way as usual query
        --binlog_do/ignore_db work for it inthe same way as for usual queries.
      mysql-test/t/rpl_loaddata_rule_s.test:
        Addition of two new types of binary log events shifted binlog positions.
        Updated test accordingly.
      mysql-test/t/rpl_loaddatalocal.test:
        Added nice test for case when it is important that LOAD DATA LOCAL
        ignores duplicates.
      mysql-test/t/rpl_log.test:
        Addition of two new types of binary log events shifted binlog positions.
        Updated test accordingly (don't dare to get rid from binlog positions
        completely since it seems that this test uses them).
      mysql-test/t/rpl_log_pos.test:
        Addition of two new types of binary log events shifted binlog positions.
        Updated test accordingly.
      mysql-test/t/rpl_multi_query.test:
        Addition of two new types of binary log events shifted binlog positions.
        Updated test accordingly.
      mysql-test/t/rpl_temporary.test:
        Addition of two new types of binary log events shifted binlog positions.
        Made test more robust for future similar changes.
      mysql-test/t/rpl_timezone.test:
        Addition of two new types of binary log events shifted binlog positions.
        Made test more robust for future similar changes.
      mysql-test/t/rpl_until.test:
        Addition of two new types of binary log events shifted binlog positions.
        Updated test accordingly and tweaked it a bit to bring it back to good
        shape.
      mysql-test/t/rpl_user_variables.test:
        Addition of two new types of binary log events shifted binlog positions.
        Updated test accordingly and made it more robust for future similar
        changes.
      mysql-test/t/user_var.test:
        Addition of two new types of binary log events shifted binlog positions.
        Updated test accordingly and made it more robust for future similar
        changes.
      sql/item_func.cc:
        Added Item_user_var_as_out_param class that represents user variable
        which used as out parameter in LOAD DATA.
        
        Moved code from Item_func_set_user_var::update_hash() function to
        separate static function to be able to reuse it in this new class.
      sql/item_func.h:
        Added Item_user_var_as_out_param class that represents user variable
        which used as out parameter in LOAD DATA.
      sql/log_event.cc:
        New way of replicating LOAD DATA. Now we do it similarly to other
        queries. We store LOAD DATA query in new Execute_load_query event
        (which is last in the sequence of events representing LOAD DATA).
        When we are executing this event we simply rewrite part of query which
        holds name of file (we use name of temporary file) and then execute it
        as usual query. In the beggining of this sequence we use Begin_load_query
        event which is almost identical to Append_file event.
      sql/log_event.h:
        New way of replicating LOAD DATA. Now we do it similarly to other
        queries. We store LOAD DATA query in new Execute_load_query event
        (which is last in the sequence of events representing LOAD DATA).
        When we are executing this event we simply rewrite part of query which
        holds name of file (we use name of temporary file) and then execute it
        as usual query. In the beggining of this sequence we use Begin_load_query
        event which is almost identical to Append_file event.
      sql/mysql_priv.h:
        Now mysql_load() has two more arguments. They are needed to pass list of
        columns and corresponding expressions from new LOAD DATA's SET clause.
      sql/share/errmsg.txt:
        Added new error message which is used to forbid loading of data from
        fixed length rows to variables.
      sql/sql_lex.h:
        Added LEX::fname_start/fname_end members. 
        They are pointers to part of LOAD DATA statement which should be
        rewritten during replication (file name + little extra).
      sql/sql_load.cc:
        Added support for extended LOAD DATA. 
        Now one can use user variables as target for data loaded from file 
        (besides table's columns). Also LOAD DATA got new SET-clause in which
        one can specify values for table columns as expressions.
        
        Updated mysql_load()/read_fixed_length()/read_sep_field() to support
        this functionality (now they can read data from file to both columns and
        variables and assign do calculations and assignments specified in SET
        clause).
        
        We also use new approach for LOAD DATA binlogging/replication.
      sql/sql_parse.cc:
        mysql_execute_command():
          Since now we have SET clause in LOAD DATA we should also check
          permissions for tables used in its expressions. Also mysql_load()
          has two more arguments to pass information about this clause.
      sql/sql_repl.cc:
        New way of replicating LOAD DATA. Now we do it similarly to other
        queries. We store LOAD DATA query in new Execute_load_query event
        (which is last in the sequence of events representing LOAD DATA).
        When we are executing this event we simply rewrite part of query which
        holds name of file (we use name of temporary file) and then execute it
        as usual query. In the beggining of this sequence we use Begin_load_query
        event which is almost identical to Append_file event.
      sql/sql_repl.h:
        struct st_load_file_info:
          Removed memebers which are no longer needed for LOAD DATA binnlogging.
      sql/sql_yacc.yy:
        Added support for extended LOAD DATA syntax. Now one can use
        user variables as target for data loaded from file (besides table's 
        columns). Also LOAD DATA got new SET-clause in which one can specify
        values for table columns as expressions.
        
        For example the following is possible:
        LOAD DATA INFILE 'words.dat' INTO TABLE t1 (a, @b) SET c = @b + 1;
        
        Also now we save pointers to the beginning and to the end of part of 
        LOAD DATA statement which should be rewritten during replication.
      5f75c8f5
    • unknown's avatar
      Bug#8670 · 8e7c17a8
      unknown authored
        Rework to resolve ambigious grammer: conflict in join expression
        handling of parentheses for nested joins and derived tables.
        Tests included of failing statements
      Optimize item construction for AND/OR logical expressions
      
      
      mysql-test/r/select.result:
        Bug#8670
          Tests for failing expressions
      mysql-test/t/select.test:
        Bug#8670
          Tests for failing expressions
      sql/sql_parse.cc:
        Bug#8670
          method st_select_lex::end_nested_join() returns NULL when
          there are no elements in the join.
      sql/sql_yacc.yy:
        Optimize construction for Item_cond_or and Item_cond_and
          Reduces object count in case of complex expressions.
        Bug#8670
          Solve ambigious grammar.
          Fix handling of parentheses in join expressions to
          correct handling of nested joins and derived tables.
      8e7c17a8
  20. 13 Mar, 2005 1 commit
    • unknown's avatar
      WL#926 "SUM(DISTINCT) and AVG(DISTINCT)": improvement of SUM(DISTINCT) and · 1534ed8e
      unknown authored
       implementation of AVG(DISTINCT) which utilizes the approach with Fields.
      The patch implemented in October is portede to the up-to-date tree 
      containing DECIMAL type.
      Tests for AVG(DISTINCT) (although there is not much to test provided
      that SUM(DISTINCT) works), cleanups for COUNT(DISTINCT) and GROUP_CONCAT()
      will follow in another changeset.
      
      
      sql/field.cc:
        A handy way to init create_field used for use with virtual tmp tables.
        Feel free to extend it for your own needs.
      sql/field.h:
        Declaration for create_field::init_for_tmp_table()
      sql/item.cc:
        Implementation for a framework used to easily handle different result
        types of SQL expressions. Instead of having instances of each possible 
        result type (integer, decimal, double) in every item, variables
        of all used types are moved to struct Hybrid_type.
        Hybrid_type can change its dynamic type in runtime, and become,
        for instance, DECIMAL from INTEGER.
        All type-specific Item operations are moved to the class hierarchy
        Hybrid_type_traits. Item::decimals and Item::max_length can
        be moved to Hybrid_type as well.
      sql/item.h:
        Declaration for Hybrid_type framework. See also comments for item.cc
        in this changeset.
      sql/item_sum.cc:
        Rewritten implementation for Item_sum_sum_distinct (SUM(DISTINCT))
        and added implementation for Item_sum_avg_distinct (AVG(DISTINCT)).
        The classes utilize Hybrid_type class hierarchy and Fields to
        convert SUM/AVG arguments to binary representation and store in a RB-tree.
      sql/item_sum.h:
        Declarations for Item_sum_distinct (the new intermediate class used
        for SUM and AVG distinct), Item_sum_sum_distinct, Item_sum_avg_distinct.
      sql/sql_select.cc:
        Implementatio of create_virtual_tmp_table().
      sql/sql_select.h:
        Declaration for create_virtual_tmp_table.
      sql/sql_yacc.yy:
        Grammar support for Item_sum_avg_distinct.
      1534ed8e
  21. 04 Mar, 2005 2 commits
    • unknown's avatar
      Bug#3788 · 1220069c
      unknown authored
        Crashes with stored procedure return non-string values
        Also fixes Bug#2773
      
      
      mysql-test/r/information_schema.result:
        Bug#3788
          Fix results for bugfix
      mysql-test/r/sp.result:
        Bug#3788
          Tests for Bug
          Fix results for bugfix
      mysql-test/t/sp.test:
        Bug#3788
          New tests for bug
      sql/item.cc:
        Fix unrelated crash in view test with --ps-protocol.
      sql/item_func.cc:
        Bug#3788
          Alter how SP function result types are handled.
      sql/item_func.h:
        Bug#3788
          Alter how SP function result types are handled.
      sql/mysql_priv.h:
        Bug#3788
          Prototypes for new global functions
      sql/sp.cc:
        Bug#3788
          Alter how function return type is reported
      sql/sp_head.cc:
        Bug#3788
          Change how function return types are stored for SPs
      sql/sp_head.h:
        Bug#3788
          Change how function return types are stored for SPs
      sql/sql_parse.cc:
        Bug#3788
          Split out field construction into its own function
      sql/sql_table.cc:
        Bug#3788
          Split out field preparation code into its own function
      sql/sql_yacc.yy:
        Bug#3788
          Change how function return types are stored for SPs
      sql/unireg.cc:
        Bug#3788
          Add assertion check
      1220069c
    • unknown's avatar
      Better approach for prelocking of tables for stored routines execution · ac9f68b9
      unknown authored
      and some SP-related cleanups.
      
      - We don't have separate stage for calculation of list of tables
        to be prelocked and doing implicit LOCK/UNLOCK any more.
        Instead we calculate this list at open_tables() and do implicit
        LOCK in lock_tables() (and UNLOCK in close_thread_tables()).
        Also now we support cases when same table (with same alias) is
        used several times in the same query in SP.
      
      - Cleaned up execution of SP. Moved all common code which handles
        LEX and does preparations before statement execution or complex
        expression evaluation to auxilary sp_lex_keeper class. Now 
        all statements in SP (and corresponding instructions) that
        evaluate expression which can contain subquery have their
        own LEX.
      
      
      mysql-test/r/lock.result:
        Replaced wrong error code with the correct one after fixing bug in
        SP-locking.
      mysql-test/r/mysqldump.result:
        Added dropping of view which is used in test to its beginning.
      mysql-test/r/sp.result:
        Added tests for improved SP-locking.
        Temporarily disabled tests for SHOW PROCEDURE STATUS and alike
        (Until Monty will allow to open mysql.proc under LOCK TABLES without
        mentioning it in lock list).
        Replaced wrong results of test for bug #5240 with correct results after
        fixing bug in handling of cursors.
      mysql-test/t/lock.test:
        Replaced wrong error code with the correct one after fixing bug in
        SP-locking.
      mysql-test/t/mysqldump.test:
        Added dropping of view which is used in test to its beginning.
      mysql-test/t/sp.test:
        Added tests for improved SP-locking.
        Temporarily disabled tests for SHOW PROCEDURE STATUS and alike
        (Until Monty will allow to open mysql.proc under LOCK TABLES without
        mentioning it in lock list).
        Removed test for bug #1654 since we already test exactly this function
        in one of SP-locking tests.
        Removed comment about cursor's wrong behavior in test for bug #5240
        after fixing bug which was its cause.
      sql/item_func.cc:
        Removed comment which is no longer true.
      sql/mysql_priv.h:
        Changed open_tables() signature.
        Now its 2nd parameter is in/out since it can add elements to table list.
      sql/sp.cc:
        sp_find_procedure():
         Added one more parameter which enforces cache only lookup.
        
        sp_merge_hash():
         Now uses its return value to indicate that first of two hashes changed
         as result of merge.
        
        sp_cache_routines():
         This function caches all stored routines used in query now.
      sql/sp.h:
        - sp_find_procedure() now has one more parameter which enforces cache only
          lookup.
        - sp_merge_hash() now uses its return value to indicate that first of two
          hashes changed as result of merge.
        - sp_cache_routines() caches all stored routines now. So it does not need
          third argument any more.
      sql/sp_head.cc:
        sp_head::sp_head():
         Added initialization of new m_spfuns and m_spprocs members.
        
        sp_head::execute():
         Let us save/restore part of thread context which can be damaged by
         execution of instructions.
        sp_head::execute_function()/execute_procedure():
         Now it is responsibility of caller to close tables used in
         subqueries which are passed as routine parameters.
        
        sp_head::restore_lex():
         Let us accumulate information about routines used by this one
         in new m_spfuns, m_spprocs hashes.
        
        sp_lex_keeper::reset_lex_and_exec_core()
         Main method of new auxilary sp_lex_keeper class to which instructions 
         delegate responsibility for handling LEX and preparations before
         executing statement or calculating complex expression.
        
        Since all instructions which calculate complex expression or execute
        command now use sp_lex_keeper they have to implement
        sp_instr::exec_core() method. Most of instruction specific logic
        has moved from sp_instr::execute() to this new method.
        
        Removed sp_instr_set_user_var class which is no longer used, because
        nowdays we allow execution of statements in stored functions and
        triggers.
        
        sp_merge_table_list() became sp_head::merge_table_list() method. It
        also treats sp_head::m_sptabs as multi-set of tables now.
        
        sp_hash_to_table_list() became sp_head::add_used_tables_to_table_list().
        It takes into account that sp_head::m_sptabs is multi-set and allocates
        object into persistent arena of PS.
        
        Removed sp_merge_table_hash(), sp_open_and_lock_tables(),
        sp_unlock_tables(), sp_merge_routine_tables() methods since they are not
        used by new prelocking mechanism.
        
        Added sp_add_sp_tables_to_table_list() which serves for adding tables needed
        by routines used in query to the query table list for prelocking.
      sql/sp_head.h:
        class sp_head:
        - Added m_spfuns, m_spprocs members for storing names of routines used
          by this routine.
        - Added add_used_tables_to_table_list() method which allows to add
          tables needed by this routine to query's table list.
        - Converted sp_merge_table_list() to sp_head::merge_table_list() method.
        - Changed semantics of THD::m_sptabs. Now it is multi-set which contains
          only tables which are used by this routine and not routines that are
          called from this one.
        
        Removed sp_merge_routine_tables(), sp_merge_table_hash(),
        sp_open_and_lock_tables(), sp_unlock_tables() calls since they are not
        used for our prelocking list calculation.
        
        Added auxilary sp_lex_keeper class to which instructions delegate
        responsibility for handling LEX and preparations before executing
        statement or calculating complex expression. This class uses
        new sp_instr::exec_core() method which is responsible for executing
        instruction's core function after all preparations were made.
        
        All instructions which hold and calculate complex expression now have
        their own LEX (by aggregating sp_lex_keeper instance). sp_instr_stmt
        now uses sp_lex_keeper too.
        
        Removed sp_instr_set_user_var class which is no longer used, because
        nowdays we allow execution of statements in stored functions and
        triggers.
      sql/sp_rcontext.cc:
        Now sp_cursor holds pointer to sp_lex_keeper instead of LEX.
      sql/sp_rcontext.h:
        Now sp_cursor holds pointer to sp_lex_keeper instead of LEX.
      sql/sql_acl.cc:
        acl_init(), grant_init():
          Now we use simple_open_n_lock_tables() instead of explicit
          calls to open_tables() and mysql_lock_tables().
      sql/sql_base.cc:
        Implemented support for execution of statements in "prelocked" mode.
        
        When we have statement which uses stored routines explicitly or
        implicitly (via views or triggers) we have to open and lock all tables
        for these routines at the same time as tables for the main statement.
        In fact we have to do implicit LOCK TABLES at the begining of such
        statement and implict UNLOCK TABLES at its end. We call such mode
        "prelocked".
        
        When open_tables() is called for the statement tables which are needed
        for execution of routines used by it are added to its tables list
        (this process also caches all routines used). Implicit use of routines
        is discovered when we open view or table with trigger and apropriate
        tables are added to the table list at this moment. Statement which has
        such extra tables in its list (well actually any that uses functions)
        is marked as requiring prelocked mode for its execution.
        
        When lock_tables() sees such statement it will issue implicit LOCK TABLES
        for this extended table list instead of doing usual locking, it will also
        set THD::prelocked_mode to indicate that we are in prelocked mode.
        
        When open_tables()/lock_tables() are called for statement of stored
        routine (substatement), they notice that we are running in prelocked mode
        and use one of prelocked tables from those that are not used by upper
        levels of execution.
        
        close_thread_tables() for substatement won't really close tables used
        but will mark them as free for reuse instead.
        
        Finally when close_thread_tables() is called for the main statement it
        really unlocks and closes all tables used.
        
        Everything will work even if one uses such statement under real LOCK
        TABLES (we are simply not doing implicit LOCK/UNLOCK in this case).
      sql/sql_class.cc:
        Added initialization of THD::prelocked_mode member.
      sql/sql_class.h:
        - Added prelocked_mode_type enum and THD::prelocked_mode member
          which are used for indication whenever "prelocked mode" is on 
          (i.e. that statement uses stored routines and is executed under
           implicit LOCK TABLES).
        - Removed THD::shortcut_make_view which is no longer needed.
          We use TABLE_LIST::prelocking_placeholder for the same purprose
          now.
      sql/sql_handler.cc:
        Changed open_tables() invocation.
        Now its 2nd parameter is in/out since it can add elements to table list.
      sql/sql_lex.cc:
        lex_start():
          Added initialization of LEX::query_tables_own_last.
          Unused LEX::sptabs member was removed.
        st_lex::unlink_first_table()/link_first_table_back():
          We should update LEX::query_tables_last properly if table list
          contains(ed) only one element.
      sql/sql_lex.h:
        LEX:
        - Removed sptabs member since it is no longer used.
        - Added query_tables_own_last member, which if non-0 indicates that
          statement requires prelocking (implicit LOCK TABLES) for its execution
          and points to last own element in query table list. If it is zero
          then this query does not need prelocking.
        - Added requires_prelocking(), mark_as_requiring_prelocking(),
          first_not_own_table() inline methods to incapsulate and simplify
          usage of this new member.
      sql/sql_parse.cc:
        dispatch_command():
          To properly leave prelocked mode when needed we should call
          close_thread_tables() even if there are no open tables.
        mysql_execute_command():
        - Removed part of function which were responsible for doing implicit
          LOCK TABLES before statement execution if statement used stored 
          routines (and doing UNLOCK TABLES at the end).
          Now we do all this in open_tables()/lock_tables()/close_thread_tables()
          instead.
        - It is also sensible to reset errors before execution of statement
          which uses routines.
        - SQLCOM_DO, SQLCOM_SET_OPTION, SQLCOM_CALL
          We should always try to open tables because even if statement has empty
          table list, it can call routines using tables, which should be preopened
          before statement execution.
        - SQLCOM_CALL
          We should not look up routine called in mysql.proc, since it should be
          already cached by this moment by open_tables() call.
        - SQLCOM_LOCK_TABLES
          it is better to use simple_open_n_lock_tables() since we want to avoid
          materialization of derived tables for this command.
      sql/sql_prepare.cc:
        mysql_test_update():
          Changed open_tables() invocations. Now its 2nd parameter is in/out
          since it can add elements to table list.
        check_prepared_statement():
          Since now we cache all routines used by statement in open_tables() we 
          don't need to do it explicitly.
        mysql_stmt_prepare():
          Now we should call close_thread_tables() when THD::lex points to the
          LEX of statement which opened tables.
        reset_stmt_for_execute():
          Commented why we are resetting all tables in table list.
      sql/sql_trigger.h:
        Table_triggers_list::process_triggers():
          We should surpress sending of ok packet when we are calling trigger's
          routine, since now we allow statements in them.
      sql/sql_update.cc:
        Changed open_tables() invocations.
        Now its 2nd parameter is in/out since it can add elements to table list.
      sql/sql_view.cc:
        mysql_make_view():
        - Removed handling of routines used in view. Instead we add tables which
          are needed for their execution to statement's table list in 
          open_tables().
        - Now we use TABLE_LIST::prelocking_placeholder instead of 
          THD::shortcut_make_view for indicating that view is opened
          only to discover which tables and routines it uses (this happens
          when we build extended table list for prelocking). Also now we try
          to avoid to modify main LEX in this case (except of its table list).
        - Corrected small error we added tables to the table list of the main
          LEX without updating its query_tables_last member properly.
      sql/sql_yacc.yy:
        Now each expression which is used in SP statements and can contain
        subquery has its own LEX. This LEX is stored in corresponding sp_instr
        object and used along with Item tree for expression calculation.
        
        We don't need sp_instr_set_user_var() anymore since now we allow
        execution of statements in stored functions and triggers.
      sql/table.h:
        Added TABLE_LIST::prelocking_placeholder member for distinguishing
        elements of table list which does not belong to the statement itself
        and added there only for prelocking (as they are to be used by routines
        called by this statement).
      sql/tztime.cc:
        my_tz_init():
          Now we use more simplier simple_open_n_lock_tables() call instead of 
          open_tables()/lock_tables() pair.
      ac9f68b9
  22. 28 Feb, 2005 1 commit
    • unknown's avatar
      Fixed BUG#8760: Stored Procedures: Invalid SQLSTATE is allowed in · 110f6abd
      unknown authored
                      a DECLARE ? HANDLER FOR stmt.
      
      
      mysql-test/r/sp-error.result:
        New test case for BUG#8776 (check format of sqlstates in handler declarations).
      mysql-test/t/sp-error.test:
        New test case for BUG#8776 (check format of sqlstates in handler declarations).
      sql/share/errmsg.txt:
        New error message for malformed SQLSTATEs.
      sql/sp_pcontext.cc:
        Added function for checking SQLSTATE format.
      sql/sp_pcontext.h:
        Added function for checking SQLSTATE format.
      sql/sql_yacc.yy:
        Check format of SQLSTATE in handler declaration.
      110f6abd
  23. 25 Feb, 2005 2 commits
    • unknown's avatar
      BUG#3190 fix (request for STDDEV_SAMP, VAR_SAMP). · d339dd13
      unknown authored
      This bug is also known as WL#1639.
      
      
      mysql-test/r/func_group.result:
        Test case for stddev_pop, var_pop, stddev_samp, var_samp was added.
      mysql-test/t/func_group.test:
        Test case for stddev_pop, var_pop, stddev_samp, var_samp was added.
      sql/item_sum.cc:
        New functions stddev_samp and var_samp were added.
      sql/item_sum.h:
        New functions stddev_samp and var_samp were added.
      sql/lex.h:
        New functions stddev_pop, var_pop, stddev_samp and var_samp were added.
      sql/sql_yacc.yy:
        New functions stddev_pop, var_pop, stddev_samp and var_samp were added.
      d339dd13
    • unknown's avatar
      Remove compiler warnings and remove not used variables · 248e4494
      unknown authored
      (Found during build process)
      
      
      extra/comp_err.c:
        Remove compiler warnings
      extra/perror.c:
        Remove compiler warnings
      innobase/dict/dict0dict.c:
        Remove compiler warnings
      innobase/dict/dict0load.c:
        Remove compiler warnings
      innobase/pars/pars0sym.c:
        Remove compiler warnings
      innobase/row/row0row.c:
        Remove compiler warnings
      innobase/row/row0sel.c:
        Remove compiler warnings
      libmysqld/lib_sql.cc:
        Remove not used variables
      myisam/mi_key.c:
        Remove compiler warnings
      regex/engine.c:
        Added comment
      sql/derror.cc:
        Remove not used variables
      sql/examples/ha_archive.cc:
        Fixed bug in blob handling
        Removed not used variable
      sql/field.cc:
        Remove compiler warnings
        Remove not used variables
      sql/filesort.cc:
        Remove compiler warnings
      sql/ha_heap.cc:
        Remove not used variable
      sql/ha_innodb.cc:
        Remove not used variables
        Remove compiler warnings
      sql/handler.cc:
        Remove compiler warnings and remove not used variables
      sql/item.cc:
        Remove compiler warnings and remove not used variables
      sql/item_subselect.cc:
        Remove compiler warnings
      sql/item_sum.cc:
        Remove compiler warnings
      sql/item_sum.h:
        Remove compiler warnings and remove not used variables
      sql/log.cc:
        Remove compiler warnings and remove not used variables
      sql/log_event.cc:
        Remove compiler warnings
      sql/mysqld.cc:
        Remove compiler warnings and remove not used variables
      sql/opt_range.cc:
        Remove compiler warnings and remove not used variables
      sql/slave.cc:
        Remove compiler warnings and remove not used variables
      sql/sp_pcontext.cc:
        Remove compiler warnings and remove not used variables
      sql/sql_acl.cc:
        Remove compiler warnings and remove not used variables
      sql/sql_analyse.cc:
        Remove compiler warnings and remove not used variables
      sql/sql_base.cc:
        Remove compiler warnings and remove not used variables
      sql/sql_db.cc:
        Remove compiler warnings and remove not used variables
      sql/sql_help.cc:
        Remove compiler warnings and remove not used variables
      sql/sql_insert.cc:
        Remove compiler warnings and remove not used variables
      sql/sql_load.cc:
        Remove compiler warnings and remove not used variables
      sql/sql_parse.cc:
        Remove compiler warnings and remove not used variables
      sql/sql_prepare.cc:
        Remove compiler warnings and remove not used variables
      sql/sql_select.cc:
        Remove compiler warnings and remove not used variables
      sql/sql_show.cc:
        Remove compiler warnings and remove not used variables
      sql/sql_table.cc:
        Remove compiler warnings
      sql/sql_union.cc:
        Remove compiler warnings
      sql/sql_update.cc:
        Remove compiler warnings and remove not used variables
      sql/sql_yacc.yy:
        Remove compiler warnings and remove not used variables
      sql/strfunc.cc:
        Remove compiler warnings and remove not used variables
      strings/ctype-ucs2.c:
        Remove compiler warnings
      tests/mysql_client_test.c:
        Remove compiler warnings and remove not used variables
      tools/mysqlmanager.c:
        Remove compiler warnings and remove not used variables
      248e4494
  24. 21 Feb, 2005 1 commit
  25. 19 Feb, 2005 1 commit
    • unknown's avatar
      fix compilation errors · a98179dc
      unknown authored
      sql/examples/ha_tina.cc:
        make tina to compile (wasn't catched with -max build)
      sql/sql_yacc.yy:
        fix compilation errors --without-geometry
      a98179dc
  26. 17 Feb, 2005 1 commit
  27. 15 Feb, 2005 2 commits
    • unknown's avatar
      After merge fixes · 6992c010
      unknown authored
      mysql-test/r/ctype_ucs.result:
        Fixed warning after merge
      sql/field.cc:
        After merge fix
      sql/item_cmpfunc.cc:
        Style & comment changes
      sql/sql_yacc.yy:
        After merge fix
      6992c010
    • unknown's avatar
      Bug#7879: Using TL_READ_NO_INSERT locks instead of TL_READ locks when · 95dec435
      unknown authored
      reading tables in "complex" SQL statements. If inserts happen in a
      table being read, the statements have no serialization order and the
      change can therefore not be reproduced on the slave.
      
      
      sql/sql_update.cc:
        Switching to using T_READ_NO_INSERT when the binlog is used.
      sql/sql_yacc.yy:
        Switching to using T_READ_NO_INSERT when the binlog is used.
      95dec435
  28. 13 Feb, 2005 1 commit
    • unknown's avatar
      Bug#2435 · a8d2152f
      unknown authored
        Alter handling for UNION syntax
        Tests for UNION and parentheses
      
      
      mysql-test/r/union.result:
        Bug#2435
          Tests for UNION and parentheses
      mysql-test/t/union.test:
        Bug#2435
          Tests for UNION and parentheses
      sql/sql_yacc.yy:
        Bug#2435
          Amend handling of UNION with parentheses.
      a8d2152f
  29. 09 Feb, 2005 1 commit