← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/item.cc

Ensure that moving/renaming plugins works.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/item.cc
17
17
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
18
18
 */
19
19
 
20
 
#include "config.h"
 
20
#include "drizzled/server_includes.h"
21
21
#include "drizzled/sql_select.h"
22
22
#include "drizzled/error.h"
23
23
#include "drizzled/show.h"
30
30
#include "drizzled/sql_base.h"
31
31
#include "drizzled/util/convert.h"
32
32
#include "drizzled/plugin/client.h"
33
 
#include "drizzled/time_functions.h"
34
33
 
35
34
#include "drizzled/field/str.h"
36
35
#include "drizzled/field/num.h"
47
46
#include "drizzled/field/timestamp.h"
48
47
#include "drizzled/field/datetime.h"
49
48
#include "drizzled/field/varstring.h"
50
 
#include "drizzled/internal/m_string.h"
51
49
 
52
50
#include <math.h>
53
51
#include <algorithm>
54
 
#include <float.h>
55
52
 
56
53
using namespace std;
57
 
 
58
 
namespace drizzled
59
 
{
 
54
using namespace drizzled;
60
55
 
61
56
const String my_null_string("NULL", 4, default_charset_info);
62
57
 
321
316
  session->free_list= this;
322
317
}
323
318
 
324
 
uint32_t Item::float_length(uint32_t decimals_par) const
325
 
{
326
 
  return decimals != NOT_FIXED_DEC ? (DBL_DIG+2+decimals_par) : DBL_DIG+8;
327
 
}
328
 
 
329
319
uint32_t Item::decimal_precision() const
330
320
{
331
321
  Item_result restype= result_type();
429
419
                            str + length - orig_len);
430
420
    }
431
421
  }
432
 
  name= memory::sql_strmake(str, length);
 
422
  name= sql_strmake(str, length);
433
423
}
434
424
 
435
425
bool Item::eq(const Item *item, bool) const
469
459
    if (number_to_datetime(value, ltime, fuzzydate, &was_cut) == -1L)
470
460
    {
471
461
      char buff[22], *end;
472
 
      end= internal::int64_t10_to_str(value, buff, -10);
 
462
      end= int64_t10_to_str(value, buff, -10);
473
463
      make_truncated_value_warning(current_session, DRIZZLE_ERROR::WARN_LEVEL_WARN,
474
464
                                   buff, (int) (end-buff), DRIZZLE_TIMESTAMP_NONE,
475
465
                                   NULL);
614
604
  return false;
615
605
}
616
606
 
 
607
bool Item::reset_query_id_processor(unsigned char *)
 
608
{
 
609
  return false;
 
610
}
 
611
 
617
612
bool Item::register_field_in_read_map(unsigned char *)
618
613
{
619
614
  return false;
693
688
  return test(is_expensive_cache);
694
689
}
695
690
 
 
691
int Item::save_in_field_no_warnings(Field *field, bool no_conversions)
 
692
{
 
693
  int res;
 
694
  Table *table= field->table;
 
695
  Session *session= table->in_use;
 
696
  enum_check_fields tmp= session->count_cuted_fields;
 
697
  ulong sql_mode= session->variables.sql_mode;
 
698
  session->variables.sql_mode&= ~(MODE_NO_ZERO_DATE);
 
699
  session->count_cuted_fields= CHECK_FIELD_IGNORE;
 
700
  res= save_in_field(field, no_conversions);
 
701
  session->count_cuted_fields= tmp;
 
702
  session->variables.sql_mode= sql_mode;
 
703
  return res;
 
704
}
 
705
 
696
706
/*
697
707
 need a special class to adjust printing : references to aggregate functions
698
708
 must not be printed as refs because the aggregate functions that are added to
787
797
  if (session->lex->describe & DESCRIBE_EXTENDED)
788
798
  {
789
799
    char warn_buff[DRIZZLE_ERRMSG_SIZE];
790
 
    snprintf(warn_buff, sizeof(warn_buff), ER(ER_WARN_FIELD_RESOLVED),
 
800
    sprintf(warn_buff, ER(ER_WARN_FIELD_RESOLVED),
791
801
            db_name, (db_name[0] ? "." : ""),
792
802
            table_name, (table_name [0] ? "." : ""),
793
803
            resolved_item->field_name,
906
916
        if (cur_field->db_name && db_name)
907
917
        {
908
918
          /* If field_name is also qualified by a database name. */
909
 
          if (strcasecmp(cur_field->db_name, db_name))
 
919
          if (strcmp(cur_field->db_name, db_name))
910
920
            /* Same field names, different databases. */
911
921
            return NULL;
912
922
          ++cur_match_degree;
1261
1271
  return error;
1262
1272
}
1263
1273
 
1264
 
/**
1265
 
  Check if an item is a constant one and can be cached.
1266
 
 
1267
 
  @param arg [out] TRUE <=> Cache this item.
1268
 
 
1269
 
  @return TRUE  Go deeper in item tree.
1270
 
  @return FALSE Don't go deeper in item tree.
1271
 
*/
1272
 
 
1273
 
bool Item::cache_const_expr_analyzer(unsigned char **arg)
1274
 
{
1275
 
  bool *cache_flag= (bool*)*arg;
1276
 
  if (!*cache_flag)
1277
 
  {
1278
 
    Item *item= real_item();
1279
 
    /*
1280
 
      Cache constant items unless it's a basic constant, constant field or
1281
 
      a subselect (they use their own cache).
1282
 
    */
1283
 
    if (const_item() &&
1284
 
        !(item->basic_const_item() || item->type() == Item::FIELD_ITEM ||
1285
 
          item->type() == SUBSELECT_ITEM ||
1286
 
           /*
1287
 
             Do not cache GET_USER_VAR() function as its const_item() may
1288
 
             return TRUE for the current thread but it still may change
1289
 
             during the execution.
1290
 
           */
1291
 
          (item->type() == Item::FUNC_ITEM &&
1292
 
           ((Item_func*)item)->functype() == Item_func::GUSERVAR_FUNC)))
1293
 
      *cache_flag= true;
1294
 
    return true;
1295
 
  }
1296
 
  return false;
1297
 
}
1298
 
 
1299
 
/**
1300
 
  Cache item if needed.
1301
 
 
1302
 
  @param arg   TRUE <=> Cache this item.
1303
 
 
1304
 
  @return cache if cache needed.
1305
 
  @return this otherwise.
1306
 
*/
1307
 
 
1308
 
Item* Item::cache_const_expr_transformer(unsigned char *arg)
1309
 
{
1310
 
  if (*(bool*)arg)
1311
 
  {
1312
 
    *((bool*)arg)= false;
1313
 
    Item_cache *cache= Item_cache::get_cache(this);
1314
 
    if (!cache)
1315
 
      return NULL;
1316
 
    cache->setup(this);
1317
 
    cache->store(this);
1318
 
    return cache;
1319
 
  }
1320
 
  return this;
1321
 
}
1322
 
 
1323
1274
bool Item::send(plugin::Client *client, String *buffer)
1324
1275
{
1325
1276
  bool result= false;
1403
1354
    return; /* Can't be better */
1404
1355
  Item_result res_type=item_cmp_type(comp_item->result_type(),
1405
1356
                                     item->result_type());
1406
 
  char *name=item->name; /* Alloced by memory::sql_alloc */
 
1357
  char *name=item->name; /* Alloced by sql_alloc */
1407
1358
 
1408
1359
  switch (res_type) {
1409
1360
  case STRING_RESULT:
1416
1367
    else
1417
1368
    {
1418
1369
      uint32_t length= result->length();
1419
 
      char *tmp_str= memory::sql_strmake(result->ptr(), length);
 
1370
      char *tmp_str= sql_strmake(result->ptr(), length);
1420
1371
      new_item= new Item_string(name, tmp_str, length, result->charset());
1421
1372
    }
1422
1373
    break;
1664
1615
Field *create_tmp_field(Session *session,
1665
1616
                        Table *table,
1666
1617
                        Item *item,
1667
 
                        Item::Type type,
1668
 
                        Item ***copy_func,
 
1618
                        Item::Type type, 
 
1619
                        Item ***copy_func, 
1669
1620
                        Field **from_field,
1670
 
                        Field **default_field,
1671
 
                        bool group,
 
1621
                        Field **default_field, 
 
1622
                        bool group, 
1672
1623
                        bool modify_item,
 
1624
                        bool, 
1673
1625
                        bool make_copy_field,
1674
1626
                        uint32_t convert_blob_length)
1675
1627
{
1760
1712
  }
1761
1713
}
1762
1714
 
1763
 
} /* namespace drizzled */
 
1715
#ifdef HAVE_EXPLICIT_TEMPLATE_INSTANTIATION
 
1716
template class List<Item>;
 
1717
template class List_iterator<Item>;
 
1718
template class List_iterator_fast<Item>;
 
1719
template class List_iterator_fast<Item_field>;
 
1720
template class List<List_item>;
 
1721
#endif