An error occurred fetching the project authors.
  1. 30 Jun, 2005 1 commit
    • unknown's avatar
      Fixed BUG#11529: crash server after use stored procedure · a95bb38a
      unknown authored
      Make sure to cleanup the items for a cursor query after each open, otherwise
      it's done too late, after the run-time mem_root is freed.
      
      
      mysql-test/r/sp.result:
        New test case for BUG#11529.
      mysql-test/t/sp.test:
        New test case for BUG#11529.
      sql/sp_head.cc:
        Add a back pointer from a sp_cursor to its cpush instruction, and use it to set
        the arena and cleanup the items for the cursor's query when opening it.
      sql/sp_rcontext.cc:
        Store pointer in sp_cursor to its cpush instruction.
      sql/sp_rcontext.h:
        Store pointer in sp_cursor to its cpush instruction.
      a95bb38a
  2. 29 Jun, 2005 1 commit
  3. 28 Jun, 2005 1 commit
    • unknown's avatar
      Fixed comments. · d2f7623d
      unknown authored
      sql/opt_range.cc:
        comment fixed.
      sql/sp_head.cc:
        An obsolete comment removed.
      d2f7623d
  4. 23 Jun, 2005 1 commit
    • unknown's avatar
      - implement inheritance of sp_instr: public Query_arena. · 91180cb8
      unknown authored
        We need every instruction to have its own arena, because we want to
        track instruction's state (INITIALIZED_FOR_SP -> EXECUTED). Because of 
        `if' statements and other conditional instructions used in stored 
        procedures, not every instruction of a stored procedure gets executed 
        during the first (or even subsequent) execution of the procedure. 
        So it's better if we track the execution state of every instruction 
        independently.
        All instructions of a given procedure now also share sp_head's 
        mem_root, but keep their own free_list.
        This simplifies juggling with free Item lists in sp_head::execute.
      - free_items() moved to be a member of Query_arena. 
      - logic of 'backup_arena' debug member of Query_arena has been
        changed to support
        multi-backups. Until now, TRUE 'backup_arena' meant that there is
        exactly one active backup of the THD arena. Now it means simply that
        the arena is used for backup, so that we can't accidentally overwrite an 
        existing backup. This allows doing multiple backups, e.g. in
        sp_head::execute and Cursor::fetch, when THD arena is already backed up
        but we want to set yet another arena (usually the 'permanent' arena,
        to save permanent transformations/optimizations of a parsed tree).
      
      
      sql/sp_head.cc:
        - use Query_arena support in sp_head::execute() as now sp_instr inherites
          from it.
      sql/sp_head.h:
        - inherite sp_instr from Query_arena
      sql/sql_class.cc:
        - changed the principle of Query_arena::backup_arena; free_items is now
          a member of Query_arena.
      sql/sql_class.h:
        - changed the principle of Query_arena::backup_arena; free_items is now
          a member of Query_arena.
      sql/sql_prepare.cc:
        free_items() is now a member of Query_arena.
      sql/sql_select.cc:
        free_items() now automatically sets free_list to zero.
      91180cb8
  5. 22 Jun, 2005 1 commit
    • unknown's avatar
      Adjust to the changed Query_arena constructor: · 40f0738b
      unknown authored
      main_mem_root is moved out of class Query_arena.
      
      
      sql/sp_head.cc:
        Adjust to the changed Query_arena constructor. 
        main_mem_root is moved out of class Query_arena.
      sql/sp_head.h:
        main_mem_root is moved out of class Query_arena: add it to class sp_head.
      sql/sql_class.cc:
        main_mem_root is moved out of class Query_arena: remove
        constructors no longer relevant, remove dead code.
      sql/sql_class.h:
        main_mem_root is moved out of class Query_arena.
      sql/sql_prepare.cc:
        It's better to not use main_mem_root anywhere: logically, it's not
        a public member (can't fix sp_head::make_field and Item_subselect::exec
        to make it protected)
      sql/sql_select.cc:
        New Cursor constructor, which avoids unneeded memory allocation
        when initializign main_mem_root.
      sql/sql_select.h:
        main_mem_root is moved out of class Query_arena.
      40f0738b
  6. 21 Jun, 2005 2 commits
    • unknown's avatar
      fixed items cleunup for SP (BUG#10136) · ef36e81b
      unknown authored
      mysql-test/r/sp.result:
        test commented until bug#11394 fix
        test for bug#10136
      mysql-test/t/sp.test:
        test commented until bug#11394 fix
        bug10136
      sql/sp_head.cc:
        fixed items cleunup for SP
      ef36e81b
    • unknown's avatar
      A preparatory patch to help adding JOIN::transform() and move one-time · 04f6f63d
      unknown authored
      query transformations to the PREPARE stage (prepared statements).
      
      
      sql/item.h:
        Remove an unused friend declaration.
      sql/mysql_priv.h:
        Change signature of insert_fields()
      sql/sp_head.cc:
        Make is_stmt_prepare_or_first_sp_execute really work: reset SP state
        to EXECUTED after execution.
      sql/sql_base.cc:
        allocate_view_names flag of insert_fields is removed.
        The purpose of this variable was to amend the case when a view
        is replaced with a base table between subsequent executions of a prepared
        statement: in that case the new table theoretically can be used instead
        of the view. If allocate_view_names was set,
        all the references to the view expressions were replaced with Item_field's
        which in turn could have been resolved by their names.
        But this approach doesn't work for other reasons, so let's not try
        to help what must be solved by TDC.
      sql/sql_class.h:
        Add is_first_sp_execute() helper method.
      sql/sql_handler.cc:
        insert_fields signature changed.
      sql/sql_lex.h:
        Add a comment for variable 'first_execution'.
      04f6f63d
  7. 15 Jun, 2005 1 commit
    • unknown's avatar
      renamed: · f1e42a0b
      unknown authored
        Item_buff -> Cached_item
        Item_arena -> Query_arena
        TEST_ASSERT -> YYERROR_UNLESS
      
      
      sql/item.h:
        renamed:
          Item_buff -> Cached_item
      sql/item_buff.cc:
        renamed:
          Item_buff -> Cached_item
      sql/item_func.cc:
        renamed:
          Item_arena -> Query_arena
      sql/item_subselect.cc:
        renamed:
          Item_arena -> Query_arena
      sql/sp_head.cc:
        renamed:
          Item_arena -> Query_arena
      sql/sp_head.h:
        renamed:
          Item_arena -> Query_arena
      sql/sql_base.cc:
        renamed:
          Item_arena -> Query_arena
      sql/sql_class.cc:
        renamed:
          Item_arena -> Query_arena
      sql/sql_class.h:
        renamed:
          Item_arena -> Query_arena
      sql/sql_lex.cc:
        renamed:
          Item_arena -> Query_arena
      sql/sql_prepare.cc:
        renamed:
          Item_arena -> Query_arena
      sql/sql_select.cc:
        renamed:
          Item_arena -> Query_arena
      sql/sql_select.h:
        renamed:
          Item_buff -> Cached_item
          Item_arena -> Query_arena
      sql/sql_union.cc:
        renamed:
          Item_arena -> Query_arena
      sql/sql_view.cc:
        renamed:
          Item_arena -> Query_arena
      sql/sql_yacc.yy:
        renamed:
          TEST_ASSERT -> YYERROR_UNLESS
      sql/table.cc:
        renamed:
          Item_arena -> Query_arena
      f1e42a0b
  8. 10 Jun, 2005 1 commit
    • unknown's avatar
      Post review and additional fix for BUG#10968: Stored procedures: crash if long loop. · 03949f8c
      unknown authored
        Fixed valgrind complaints. This fixes the memory leak problems for
        procedured, and partially for functions. There's still a leak involving
        results from functions that turned out to be too involved, so it will be
        fixed separately.
      
      
      mysql-test/r/sp.result:
        Fixed some minor mistake (spotted while debugging).
      mysql-test/t/sp.test:
        Fixed some minor mistake (spotted while debugging).
      sql/item_func.cc:
        Moved Item_func_sp::cleanup() from item_func.h to ease debugging,
        and made a debug output come out right.
      sql/item_func.h:
        Moved Item_func_sp::cleanup() to item_func.cc to ease debugging.
      sql/sp_head.cc:
        Fixed valgrind problems with the previous memory leak fix (unit cleanup and
        putting result field in a differen mem_root), and removed prealloc flag from
        init_alloc_root() calls.
      sql/sp_rcontext.cc:
        New mem_root pointer used for return fields from functions.
      sql/sp_rcontext.h:
        New mem_root pointer used for return fields from functions.
      03949f8c
  9. 09 Jun, 2005 1 commit
    • unknown's avatar
      A fix and test case for Bug#10729 "mysql_stmt_attr_set · d0db7027
      unknown authored
      CURSOR_TYPE_READ_ONLY". The bug was that we (me) don't perform proper
      cleanups of the prepared statement when done fetching from a cursor.
      Another patch.
      
      
      sql/mysql_priv.h:
        Rename reset_stmt_for_execute to init_stmt_before_use (to correspond to
        cleanup_stmt_and_thd_after_use).
      sql/sp_head.cc:
        Rename.
      sql/sql_prepare.cc:
        Move common cleanup code to a cleanup function, call it when we close
        a cursor.
      sql/sql_select.cc:
        Cleanup.
      sql/sql_select.h:
        No need for init_thd, this code has been inlined in Cursor::open.
      tests/mysql_client_test.c:
        Add a test case for Bug#10729 "mysql_stmt_attr_set CURSOR_TYPE_READ_ONLY"
        (problem reusing a prepared statemnt if there was a cursor)
      d0db7027
  10. 07 Jun, 2005 1 commit
    • unknown's avatar
      Patch two (the final one) for Bug#7306 "the server side preparedStatement · 5188f031
      unknown authored
       error for LIMIT placeholder".
      The patch adds grammar support for LIMIT ?, ? and changes the
      type of ST_SELECT_LEX::select_limit,offset_limit from ha_rows to Item*,
      so that it can point to Item_param.
      
      
      mysql-test/include/ps_modify.inc:
        Fix existing tests: now LIMIT can contain placeholders.
      mysql-test/include/ps_query.inc:
        Fix existing tests: now LIMIT can contain placeholders.
      mysql-test/r/ps.result:
        Add basic test coverage for LIMIT ?, ? and fix test results.
      mysql-test/r/ps_2myisam.result:
        Fix test results: now LIMIT can contain placeholders.
      mysql-test/r/ps_3innodb.result:
        Fix test results: now LIMIT can contain placeholders.
      mysql-test/r/ps_4heap.result:
        Fix test results: now LIMIT can contain placeholders.
      mysql-test/r/ps_5merge.result:
        Fix test results: now LIMIT can contain placeholders.
      mysql-test/r/ps_6bdb.result:
        Fix test results: now LIMIT can contain placeholders.
      mysql-test/r/ps_7ndb.result:
        Fix test results: now LIMIT can contain placeholders.
      mysql-test/t/ps.test:
        Add basic test coverage for LIMIT ?, ?.
      sql/item.h:
        Add a short-cut for (ulonglong) val_int() to Item.
        Add a constructor to Item_int() that accepts ulonglong.
        Simplify Item_uint constructor by using the c-tor above.
      sql/item_subselect.cc:
        Now select_limit has type Item *.
        We can safely create an Item in Item_exists_subselect::fix_length_and_dec():
        it will be allocated in runtime memory root and freed in the end of
        execution.
      sql/sp_head.cc:
        Add a special initalization state for stored procedures to 
        be able to easily distinguish the first execution of a stored procedure
        from prepared statement prepare.
      sql/sql_class.h:
        Introduce new state 'INITIALIZED_FOR_SP' to be able to easily distinguish
        the first execution of a stored procedure from prepared statement prepare.
      sql/sql_derived.cc:
        - use unit->set_limit() to set unit->select_limit_cnt, offset_limit_cnt
          evreryplace. Add a warning about use of set_limit in 
        mysql_derived_filling.
      sql/sql_error.cc:
        - use unit->set_limit() to set unit->select_limit_cnt, offset_limit_cnt
          evreryplace.
        - this change is also aware of bug#11095 "show warnings limit 0 returns 
        all rows instead of zero rows", so the one who merges the bugfix from
        4.1 can use local version of sql_error.cc.
      sql/sql_handler.cc:
        - use unit->set_limit() to initalize 
        unit->select_limit_cnt,offset_limit_cnt everyplace.
      sql/sql_lex.cc:
        Now ST_SELECT_LEX::select_limit, offset_limit have type Item *
      sql/sql_lex.h:
        Now ST_SELECT_LEX::select_limit, offset_limit have type Item *
      sql/sql_parse.cc:
        - use unit->set_limit() to initalize 
        unit->select_limit_cnt,offset_limit_cnt everyplace. 
        - we can create an Item_int to set global limit of a statement:
        it will be created in the runtime mem root and freed in the end of
        execution.
      sql/sql_repl.cc:
        Use unit->set_limit to initialize limits.
      sql/sql_select.cc:
        - select_limit is now Item* so the proper way to check for default value
        is to compare it with NULL.
      sql/sql_union.cc:
        Evaluate offset_limit_cnt using the new type of ST_SELECT_LEX::offset_limit
      sql/sql_view.cc:
        Now ST_SELECT_LEX::select_limit, offset_limit have type Item *
      sql/sql_yacc.yy:
        Add grammar support for LIMIT ?, ? clause.
      5188f031
  11. 05 Jun, 2005 2 commits
    • unknown's avatar
      sp_rcontext.cc, sp_pcontext.cc, sp_head.cc, sp_cache.cc, ha_federated.cc: · 9a3bb0c7
      unknown authored
        Include "mysql_priv.h" before testing USE_PRAGMA_IMPLEMENTATION
      
      
      sql/ha_federated.cc:
        Include "mysql_priv.h" before testing USE_PRAGMA_IMPLEMENTATION
      sql/sp_cache.cc:
        Include "mysql_priv.h" before testing USE_PRAGMA_IMPLEMENTATION
      sql/sp_head.cc:
        Include "mysql_priv.h" before testing USE_PRAGMA_IMPLEMENTATION
      sql/sp_pcontext.cc:
        Include "mysql_priv.h" before testing USE_PRAGMA_IMPLEMENTATION
      sql/sp_rcontext.cc:
        Include "mysql_priv.h" before testing USE_PRAGMA_IMPLEMENTATION
      9a3bb0c7
    • unknown's avatar
      Cleanup during review · b08b3a15
      unknown authored
      Simple optimization for 2 argument usage to function of variable arguments
      Fix stack overrun when using 1+1+1+1+1+1+1+....
      Update crash-me results for 5.0
      Don't call post_open if pre_open() fails (optimization)
      
      
      
      sql-bench/limits/mysql-4.1.cfg:
        Rename: sql-bench/limits/mysql.cfg -> sql-bench/limits/mysql-4.1.cfg
      libmysql/libmysql.c:
        More portable define
      mysql-test/mysql-test-run.sh:
        Write also InnoDB warnings to warnings.log
      mysql-test/t/type_newdecimal.test:
        Don't get errors if innodb is not defined
      mysys/my_alloc.c:
        Cleanup comments
      mysys/thr_lock.c:
        Cleanup comments
      sql/item.h:
        Remove not needed initializer
      sql/item_func.cc:
        Simple optimization for 2 argument usage to function of variable arguments
      sql/mysql_priv.h:
        We use more stackspace with the introduction of int_op() etc.
        This change ensures we don't run out of stack when doing 1+1+1+1...
        (Tested on x86, 32 bit)
      sql/sp_head.cc:
        Don't call post_open if pre_open() fails
      sql/sp_rcontext.cc:
        More comments
        Change so that post_open() doesn't have to be called if pre_open() fails
      sql/sql_parse.cc:
        Fold long lines
      sql/sql_select.cc:
        Simple reorganization to reduce number of if's
        Ensure that table_map is updated for where clause (fixed warning from valgrind)
      b08b3a15
  12. 03 Jun, 2005 1 commit
  13. 01 Jun, 2005 1 commit
    • unknown's avatar
      Fixed BUG#10961: Stored procedures: crash if select * from dual · 77bd9d36
      unknown authored
        Have to catch errors from SELECT when opening a cursor.
      
      
      mysql-test/r/sp.result:
        New test case for BUG#10961.
      mysql-test/t/sp.test:
        New test case for BUG#10961.
      sql/protocol.h:
        Init data in Protocol_cursor constructor, for error cases.
      sql/sp_head.cc:
        Catch "hidden" errors during SELECT when opening a cursor.
      77bd9d36
  14. 31 May, 2005 1 commit
    • unknown's avatar
      Post-review fixes of BUG#9937: Crash on call to stored procedure. · 2e113ada
      unknown authored
      sql/item_cmpfunc.cc:
        Put the buff parameter back in check_stack_overrun().
      sql/item_func.cc:
        Put the buff parameter back in check_stack_overrun().
      sql/item_subselect.cc:
        Put the buff parameter back in check_stack_overrun().
      sql/mysql_priv.h:
        Put the buff parameter back in check_stack_overrun().
      sql/mysqld.cc:
        Style fixes.
      sql/sp_head.cc:
        Put the buff parameter back in check_stack_overrun().
      sql/sql_parse.cc:
        Put the buff parameter back in check_stack_overrun(), and added comment explaining the purpose.
      sql/table.cc:
        Put the buff parameter back in check_stack_overrun().
      2e113ada
  15. 27 May, 2005 2 commits
    • unknown's avatar
      Fix for trigger.test failure in --debug mode. · d51a5bae
      unknown authored
      We can't have Item_trigger_field as aggregated object inside of
      sp_instr_set_trigger_field class since in this case its destructor
      will be called twice. So instead let us create this Item separately
      and store pointer to it in instruction object.
      
      
      sql/sp_head.cc:
        sp_instr_set_trigger_field:
          We can't have Item_trigger_field as aggregated object since in this
          case its destructor will be called twice, so let us store pointer
          to this Item (Another way to avoid this is to exclude this Item
          from free_list but this can't be done in elegant way in 5.0 and
          will also cause additional problems with Item::cleanup()).
      sql/sp_head.h:
        sp_instr_set_trigger_field:
          We can't have Item_trigger_field as aggregated object since in this
          case its destructor will be called twice, so let us store pointer
          to this Item (Another way to avoid this is to exclude this Item
          from free_list but this can't be done in elegant way in 5.0 and
          will also cause additional problems with Item::cleanup()).
      sql/sql_yacc.yy:
        We can't have Item_trigger_field as aggregated object inside of
        sp_instr_set_trigger_field class since in this case its destructor
        will be called twice. So instead let us create this Item separately
        and store pointer to it in instruction object.
      d51a5bae
    • unknown's avatar
      Add USE_PRAGMA_INTERFACE and USE_PRAGMA_IMPLEMENTATION to files not existsing in 4.1 · 73b4415c
      unknown authored
      sql/hash_filo.h:
        USE_PRAGMA_INTERFACE
      sql/sp_cache.cc:
        USE_PRAGMA_IMPLEMENTATION
      sql/sp_cache.h:
        USE_PRAGMA_INTERFACE
      sql/sp_head.cc:
        USE_PRAGMA_IMPLEMENTATION
      sql/sp_head.h:
        USE_PRAGMA_INTERFACE
      sql/sp_pcontext.cc:
        USE_PRAGMA_IMPLEMENTATION
      sql/sp_pcontext.h:
        USE_PRAGMA_INTERFACE
      sql/sp_rcontext.cc:
        USE_PRAGMA_IMPLEMENTATION
      sql/sp_rcontext.h:
        USE_PRAGMA_INTERFACE
      73b4415c
  16. 26 May, 2005 1 commit
    • unknown's avatar
      Fixed BUG#9937: Crash on call to stored procedure. · 0d8dce03
      unknown authored
      This only showed up on two known platforms, both ia64 (one HP-UX and one Linux wich icc).
      For some reason, they only get half the stack size they are supposed to have, which
      makes deep SP recursion overrun the stack before check_stack_overrun() is triggered.
      Also made som minor fixes in the check_stack_overrun() definition, supporting variable
      margins.
      No test case added, but the reason for the bug report was a failed existing test case
      on these machines, which now works.
      
      
      sql/item_cmpfunc.cc:
        Adopted call to new check_stack_overrun() definition.
      sql/item_func.cc:
        Adopted calls to new check_stack_overrun() definition.
      sql/item_subselect.cc:
        Adopted call to new check_stack_overrun() definition.
      sql/mysql_priv.h:
        Changed definition of check_stack_overrun(), thread_stack_min variable no longer needed.
      sql/mysqld.cc:
        thread_stack_min variable no longer needed (with variable margin arg. to check_thread_overrun()).
        On (at least some) ia64 machines, it seems we only get half the requested stack in reality,
        so deep SP recursion crashes before the thread overrun check is triggered.
        We work around this by requesting twice the stack requested to get expected size.
      sql/sp_head.cc:
        Adopted call to new check_stack_overrun() definition, and use a wider margin
        execution.
      sql/sql_parse.cc:
        Modified check_stack_overrun() definition. Removed unused arg that didn't sever any
        purpose, and added a 'margin' argument to support different margins for different
        callrers.
      sql/table.cc:
        Adopted call to new check_stack_overrun() definition.
      0d8dce03
  17. 23 May, 2005 1 commit
    • unknown's avatar
      Fixed on BUG#6048: Stored procedure causes operating system reboot · 9c79a9d6
      unknown authored
        Memory leak in locally evalutated expressions during SP execution fixed by
        reusing allocated item slots when possible.
        Note: No test case added, since the test is a stress test that tries to make
        the machine to run out of memory.
        Second attempt, now tested with debug build, valgrind build, max (optimized)
        build, with and without --debug, --vagrind and --ps-protocol.
        Errors in trigger and view test with --debug in debug build where present
        before this patch, and likewise for valgrind warnings for view test in
        valgrind build with --ps-protocol.
      
      
      sql/item.cc:
        Init rsize in Item (for SP item reusal).
      sql/item.h:
        Addes special new operator for reuse of Items, for SP internal use only.
      sql/sp_head.cc:
        Reuse items assigned internally in SPs when possible.
      sql/sp_rcontext.cc:
        Reuse items assigned internally in SPs when possible.
        Moved the local variable assignment here (from sp_head) to avoid
        duplicated code.
      sql/sp_rcontext.h:
        New arg to sp_rcontext::set_item_eval() (and some coding style).
      sql/sql_class.cc:
        Adjusted call to new set_item_eval().
      9c79a9d6
  18. 19 May, 2005 1 commit
  19. 18 May, 2005 1 commit
    • unknown's avatar
      Fixed BUG#6048: Stored procedure causes operating system reboot. · 90a2edd7
      unknown authored
        Memory leak in locally evalutated expressions during SP execution fixed by
        reusing allocated item slots when possible.
        Note: No test case added, since the test is a stress test that tries to make
        the machine to run out of memory.
      
      
      sql/item.cc:
        Make it possible to reuse allocated item slots (for use in SP execution).
      sql/item.h:
        Make it possible to reuse allocated item slots (for use in SP execution).
      sql/sp_head.cc:
        Reuse allocated item slots for expression evalutation during SP execution.
      sql/sp_rcontext.cc:
        Updated sp_eval_func_item() call, and prevent item reuse in reused frames (for handlers).
      90a2edd7
  20. 17 May, 2005 2 commits
    • unknown's avatar
      Bug#10246 - Parser: bad syntax for GRANT EXECUTE · 55171821
      unknown authored
        Rename some functions
        more fine-grained sp privileges
        make grant/revoke sp grammar less ambigious
      
      
      mysql-test/r/sp-security.result:
        change test for new syntax
      mysql-test/r/system_mysql_db.result:
        change test for new syntax
      mysql-test/t/sp-security.test:
        change test for new syntax
      scripts/mysql_create_system_tables.sh:
        now store routine_type for procs_priv
      scripts/mysql_fix_privilege_tables.sql:
        now store routine_type for procs_priv
      sql/item_func.cc:
        rename of function
      sql/mysql_priv.h:
        rename of function
      sql/sp_head.cc:
        extra arg for check_some_routine_access
      sql/sql_acl.cc:
        rename of function. now handle func/proc acls seperately
      sql/sql_acl.h:
        rename of function
      sql/sql_parse.cc:
        rename of function
        grants for procs handled distinctly from funcs
      sql/sql_show.cc:
        check_some_routine_access extra arg
      sql/sql_base.cc:
        fix for build
      sql/sql_yacc.yy:
        fix for build
      55171821
    • unknown's avatar
      sql_yacc.yy: · afaa3c89
      unknown authored
        missing semicolon added
      sql_base.cc:
        bad merge fixed
      sp_head.cc, view.test, view.result:
        Correct restoring view name in SP table locking BUG#9758
      configure.in:
        restore -fno-implicit-templates -fno-exceptions -fno-rtti in configure
      
      
      configure.in:
        restore -fno-implicit-templates -fno-exceptions -fno-rtti in configure
      mysql-test/r/view.result:
        Correct restoring view name in SP table locking BUG#9758
      mysql-test/t/view.test:
        Correct restoring view name in SP table locking BUG#9758
      sql/sp_head.cc:
        Correct restoring view name in SP table locking BUG#9758
      sql/sql_base.cc:
        bad merge fixed
      sql/sql_yacc.yy:
        missing semicolon added
      afaa3c89
  21. 08 May, 2005 1 commit
    • unknown's avatar
      Item::fix_field need correct pointer on item reference to chnge it if itis... · a6b15466
      unknown authored
      Item::fix_field need correct pointer on item reference to chnge it if itis need, so support of correct item address added to SP commands (BUG#5963)
      some optimisation of IF/NOT IF ptomised to Pem
      
      
      mysql-test/r/sp.result:
        test for bug#5963
      mysql-test/t/sp.test:
        test for bug#5963
      sql/item.cc:
        new method which return reference on Item for SP variables support
      sql/item.h:
        comment fixed
        method added
      sql/sp_head.cc:
        preparation of item made separate function
        we do not need new constant Item to check IF/IF NOT
        support of passing correct address of item for fix_fields method
      sql/sp_rcontext.cc:
        support of Item address passing to fix_fields
      sql/sp_rcontext.h:
        support of correct address passing to fix_fields
      sql/sql_class.cc:
        support of correct item address passing to fix_field
      a6b15466
  22. 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
  23. 05 May, 2005 1 commit
    • unknown's avatar
      A lot of fixes to Precision math · 6de14a23
      unknown authored
      Mostly about precision/decimals of the results of the operations
      
      
      include/decimal.h:
        decimal interface changed a little
      sql/field.cc:
        a lot of precision/decimals related changes to the Field_new_decimal
      sql/field.h:
        Field_new_decimal interface changed
      sql/ha_ndbcluster.cc:
        f->precision should be used here
      sql/item.cc:
        precision/decimals counting related changes
      sql/item.h:
        precision/decimals counting related changes
      sql/item_cmpfunc.cc:
        precision/decimals counting related changes
      sql/item_cmpfunc.h:
        precision/decimals counting related changes
      sql/item_func.cc:
        precision/decimals counting related changes
      sql/item_func.h:
        precision/decimals counting related changes
      sql/item_sum.cc:
        precision/decimals counting related changes
      sql/item_sum.h:
        precision/decimals counting related changes
      sql/my_decimal.cc:
        precision/decimals counting related changes
      sql/my_decimal.h:
        precision/decimals counting related changes
      sql/mysqld.cc:
        precision/decimals counting related changes
      sql/set_var.cc:
        precision/decimals counting related changes
      sql/sp_head.cc:
        dbug_decimal_print was replaced with dbug_decimal_as_string
      sql/sql_class.h:
        div_precincrement variable added
      sql/sql_parse.cc:
        precision/decimals counting related changes
      sql/sql_select.cc:
        precision/decimals counting related changes
      sql/sql_show.cc:
        Field::representation_length was removed
      strings/decimal.c:
        decimal_actual_fraction was introduced
      BitKeeper/etc/logging_ok:
        Logging to logging@openlogging.org accepted
      6de14a23
  24. 20 Apr, 2005 2 commits
    • unknown's avatar
      Bug#9775 - Stored procedures: crash if create function that returns enum or set · de8a3b31
      unknown authored
        Fix bug and implement return type casting.
      
      
      mysql-test/r/sp.result:
        Bug#9775
          Test for bug + feature
        Fix previous tests
      mysql-test/t/sp.test:
        Bug#9775
          Test for bug + feature
        Fix previous tests
      sql/item_func.cc:
        Bug#9775
          new method Item_func_sp::execute(Field **)
          some optimizations.
      sql/item_func.h:
        Bug#9775
          results for Item_func_sp pass through a Field of the return type.
          new method Item_func_sp::execute(Field **)
      sql/sp_head.cc:
        Bug#9775
          missing initialiation for type_lengths in sp_head::create_typelib()
      de8a3b31
    • unknown's avatar
      Fixed BUG#6898: Stored procedure crash if GOTO statements exist · 5642bbd3
      unknown authored
        Bug in the optimizer caused an infinite loop for weird code.
      
      
      mysql-test/r/sp.result:
        New test case for BUG#6898.
      mysql-test/t/sp.test:
        New test case for BUG#6898.
      sql/sp_head.cc:
        Detect self referencing jumps in the optimizer.
      5642bbd3
  25. 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
  26. 15 Apr, 2005 1 commit
    • 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
  27. 14 Apr, 2005 1 commit
    • unknown's avatar
      Fixed BUG#9598: stored procedure call within stored procedure · e0fdbeba
      unknown authored
                      overwrites IN variable
        and added error checking of variables for [IN]OUT parameters while
        rewriting the out parameter handling.
      
      
      mysql-test/r/sp-error.result:
        New test case for non-variable argument for [IN]OUT parameters.
        (And changed to qualified names in some other error messages.)
      mysql-test/r/sp.result:
        New test case for BUG#9598.
      mysql-test/t/sp-error.test:
        New test case for non-variable argument for [IN]OUT parameters.
      mysql-test/t/sp.test:
        New test case for BUG#9598.
      sql/item.h:
        Need to distinguish between SP local variable items and other items,
        for error checking and [IN]OUT parameter handling.
      sql/share/errmsg.txt:
        New error message for non-variable arguments for [IN]OUT parameters in stored procedures.
      sql/sp_head.cc:
        Rewrote the [IN]OUT parameter handling in procedure invokation, to make
        it work properly when using user variables in sub-calls.
        Also added error checking for non-variable arguments for such parameters
        (and changed to qualified names for wrong number of arg. errors).
      sql/sp_rcontext.cc:
        No need to keep track on the out index for an [IN]OUT parameter any more.
      sql/sp_rcontext.h:
        No need to keep track on the out index for an [IN]OUT parameter any more.
      e0fdbeba
  28. 05 Apr, 2005 1 commit
  29. 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
  30. 18 Mar, 2005 1 commit
    • unknown's avatar
      Fixed BUG#6600: Stored procedure crash after repeated calls with check table · 6c621bbd
      unknown authored
      mysql-test/r/sp.result:
        New test case for BUG#6600.
      mysql-test/t/sp.test:
        New test case for BUG#6600.
      sql/sp_head.cc:
        Added yet another multiple result set statement to the list.
      sql/sql_parse.cc:
        Have to invalidate SP caches in CHECK TABLE, or it will produce very
        strange results when called in SPs.
      6c621bbd
  31. 15 Mar, 2005 1 commit
    • unknown's avatar
      Code cleanups during review of pushed code · ef7ebed4
      unknown authored
      sql/mysql_priv.h:
        Added 'const' to some arguments
      sql/sp_head.cc:
        Added comments
        code cleanup
        acceess -> access
      sql/sql_acl.cc:
        Simply code by making check_routine_level_acl() available also in embedded server
      sql/sql_acl.h:
        Added 'const' to some arguments
      sql/sql_parse.cc:
        Added 'const' to some arguments
        Fixed the check_rounte_level_acl() is always called
        (old code didn't properly check access privilges if grant_option was not set)
      sql/sql_show.cc:
        Simplify usage of get_field()
        Now we can always call check_some_routine_access()
      sql/sql_udf.cc:
        Don't give warnings for suspicios UDF's if --log-warnings isn't given
      sql/table.cc:
        Simplify usage of get_field()
      ef7ebed4
  32. 05 Mar, 2005 2 commits
    • unknown's avatar
      Fix for yet another memleak caused by SP-locking patch. · e3bc9d82
      unknown authored
      Improved handling of situations when we encounter error during
      CREATE PROCEDURE (FUNCTION/TRIGGER/...) and bail out of yyparse()
      without restoring proper THD::lex.
      
      
      sql/sp.cc:
        We do not need to call sp_head::restore_lex() explicitly to restore right
        value of THD::lex in case when we have encountered error during parsing.
        Now we do this in sp_head::~sp_head() instead.
      sql/sp_head.cc:
        sp_head::destroy():
         Fixed cleaning up of stack of auxilary LEXes. 
         We also restore right value of THD::lex during this process now.
      sql/sql_parse.cc:
        We do not need to call sp_head::restore_lex() explicitly to restore right
        value of THD::lex in case when we have encountered error during parsing.
        Now we do this in sp_head::~sp_head() instead.
      sql/sql_prepare.cc:
        We do not need to call sp_head::restore_lex() explicitly to restore right
        value of THD::lex in case when we have encountered error during parsing.
        Now we do this in sp_head::~sp_head() instead.
      sql/sql_trigger.cc:
        We do not need to call sp_head::restore_lex() explicitly to restore right
        value of THD::lex in case when we have encountered error during parsing.
        Now we do this in sp_head::~sp_head() instead.
      e3bc9d82
    • unknown's avatar
      0d7e68c9
  33. 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