-
Notifications
You must be signed in to change notification settings - Fork 1
/
Copy pathha_tsdb_engine.cc
1062 lines (896 loc) · 28.6 KB
/
ha_tsdb_engine.cc
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
/*
@Author: Ayoub Serti
@file ha_tsdb_engine.cc
@brief ha_tsdb_engine implementation
*/
//include precompiled headers
#include "PCHfile.h"
#include "sql_class.h" // MYSQL_HANDLERTON_INTERFACE_VERSION
#include "ha_tsdb_engine.h"
#include "probes_mysql.h"
#include "sql_plugin.h"
//internal use
#include <sys/stat.h>
//gobal variables:
const char* ha_tsdb_engine_system_database= NULL;
//file extensions
static const char *ha_tsdb_engine_exts[] = {
".tsdb"
};
static uint64 _getTimeepoch()
{
struct timeval tms;
if (gettimeofday(&tms,NULL))
{
return -1;
}
uint64 micros = tms.tv_sec * 1000000;
/* Add full microseconds */
micros += tms.tv_usec;
return micros;
}
static handler *tsdb_engine_create_handler(handlerton *hton,
TABLE_SHARE *table,
MEM_ROOT *mem_root);
handlerton *tsdb_engine_hton;
/* Interface to mysqld, to check system tables supported by SE */
static const char* tsdb_engine_system_database();
static bool tsdb_engine_is_supported_system_table(const char *db,
const char *table_name,
bool is_sql_layer_system_table);
//tsdb_engine_share impl
//ctor
tsdb_engine_share::tsdb_engine_share()
{
thr_lock_init(&lock);
use_count=0;
}
//init func
static int tsdb_engine_init_func(void *p)
{
DBUG_ENTER("tsdb_engine_init_func");
tsdb_engine_hton= (handlerton *)p;
tsdb_engine_hton->state= SHOW_OPTION_YES;
tsdb_engine_hton->create= tsdb_engine_create_handler;
tsdb_engine_hton->flags= HTON_CAN_RECREATE;
tsdb_engine_hton->system_database= tsdb_engine_system_database;
tsdb_engine_hton->is_supported_system_table= tsdb_engine_is_supported_system_table;
DBUG_RETURN(0);
}
//ha_tsdb_engine impl
tsdb_engine_share *ha_tsdb_engine::get_share()
{
tsdb_engine_share *tmp_share;
DBUG_ENTER("ha_tsdb_engine::get_share()");
lock_shared_ha_data();
if (!(tmp_share= static_cast<tsdb_engine_share*>(get_ha_share_ptr())))
{
tmp_share= new tsdb_engine_share;
if (!tmp_share)
goto err;
set_ha_share_ptr(static_cast<Handler_share*>(tmp_share));
}
err:
unlock_shared_ha_data();
DBUG_RETURN(tmp_share);
}
//static function tsdb_engine_create_handler
/*
@brief this function creates a handler of ha_tsdb_engine handler
TODO: ?? explain more this machin
*/
static handler* tsdb_engine_create_handler(handlerton *hton,
TABLE_SHARE *table,
MEM_ROOT *mem_root)
{
return new (mem_root) ha_tsdb_engine(hton, table);
}
//ctor
//call super ctor
ha_tsdb_engine::ha_tsdb_engine(handlerton *hton, TABLE_SHARE *table_arg)
:handler(hton, table_arg)
{
fTMSeries = NULL;
}
//ha_tsdb_engine::bas_ext() return our extension
const char **ha_tsdb_engine::bas_ext() const
{
return ha_tsdb_engine_exts;
}
const char* tsdb_engine_system_database()
{
return ha_tsdb_engine_system_database;
}
//list of all systems tables specific to our engine
//we do not need to implemnt this because it's generic
//until we do not have system table we just put NULL
//TODO: remove this stuff
static st_system_tablename ha_tsdb_engine_system_tables[]= {
{(const char*)NULL, (const char*)NULL}
};
/**
@brief Check if the given db.tablename is a system table for this SE.
@param db Database name to check.
@param table_name table name to check.
@param is_sql_layer_system_table if the supplied db.table_name is a SQL
layer system table.
@return
@retval TRUE Given db.table_name is supported system table.
@retval FALSE Given db.table_name is not a supported system table.
*/
static bool tsdb_engine_is_supported_system_table(const char *db,
const char *table_name,
bool is_sql_layer_system_table)
{
st_system_tablename *systab;
// Does this SE support "ALL" SQL layer system tables ?
if (is_sql_layer_system_table)
return false;
// Check if this is SE layer system tables
systab= ha_tsdb_engine_system_tables;
while (systab && systab->db)
{
if (systab->db == db &&
strcmp(systab->tablename, table_name) == 0)
return true;
systab++;
}
return false;
}
/*
@function ha_tsdb_engine:open()
@brief open a table
@params
name table file name
mode O_RDONLY or O_RDWR
test_if_locked self-segnificant :)
@return mysql error code
*/
int ha_tsdb_engine::open(const char *name, int mode, uint test_if_locked)
{
//need to be changed to open our table
DBUG_ENTER("ha_tsdb_engine::open");
if (!(share = get_share()))
DBUG_RETURN(1);
thr_lock_data_init(&share->lock,&lock,NULL);
std::string filename(name);
filename+=bas_ext()[0]; //add ".tsdb"
hid_t ofh = H5Fopen(filename.c_str(), H5F_ACC_RDWR, H5P_DEFAULT);
if(ofh < 0)
{
std::cerr << "Error opening TSDB file: '" << filename << "'." << std::endl;
return 0;
}
try{
fTMSeries = new tsdb::Timeseries(ofh,"tsdb");
}catch(...)
{
return -1;
}
H5Fclose(ofh);
DBUG_RETURN(0);
}
/*
@function ha_tsdb_engine::close
@brief close table
@params void
@return mysql error code
*/
int ha_tsdb_engine::close(void)
{
DBUG_ENTER("ha_tsdb_engine::close");
H5close();
if (NULL != fTMSeries )
delete fTMSeries;
DBUG_RETURN(0);
}
/*
@function ha_tsdb_engine::write_row
@brief insert row
@params buf is an uchar* that we could cast to any struct
@return mysql error code
*/
int ha_tsdb_engine::write_row(uchar *buf)
{
DBUG_ENTER("ha_tsdb_engine::write_row");
size_t recordsize = fTMSeries->structure()->getSizeOf();
uchar* recordPtr = (uchar*)thd_alloc(ha_thd(),recordsize + 8 + 1); //8bytes for time stamps, 1 dummy byte
struct timeval tms;
if (gettimeofday(&tms,NULL))
{
return -1;
}
int64_t micros = tms.tv_sec * 1000ull;
/* Add full microseconds */
micros += tms.tv_usec/1000;
//std::cerr << "[NOTE]: micros = " << micros << std::endl;
memcpy(recordPtr,µs,8);
uchar* urecord = recordPtr;
recordPtr+=8;
memcpy(recordPtr, buf, table->s->null_bytes);
recordPtr += table->s->null_bytes;
for (Field **field = table->field ; *field ; field++)
{
if ( !((*field)->is_null()) )
{
//(*field)>pack()
//uchar* to = (uchar*)sql_alloc((*field)->data_length());
if ( !((*field)->is_null()))
recordPtr= (*field)->pack(recordPtr,buf+(*field)->offset(table->record[0]));
// std::cerr << "[NOTE] data length "<< (*field)->data_length() <<std::endl;
//std::cerr << "[NOTE] field offset:" << (*field)->offset(table->record[0]) << " " << buf + (*field)->offset(table->record[0])<< std::endl;
}
}
//must remove exception to enhance performance for win32 bit
try{
fTMSeries->appendRecords(1,urecord,true);
}
catch (tsdb::TimeseriesException& e)
{
std::cerr << "COULD NOT SAVE ROW " << e.what() << std::endl;
}
DBUG_RETURN(0);
}
/*
@function ha_tsdb_engine::update_row
@brief update row
@params old_data and new_data are unsigned char ptrs
@return mysql error code
*/
int ha_tsdb_engine::update_row(const uchar *old_data, uchar *new_data)
{
DBUG_ENTER("ha_tsdb_engine::update_row");
//prealably must not update time series
DBUG_RETURN(1);
}
/*
@function ha_tsdb_engine::delete_row
@brief update row
@params buf is const uchar ptr
@return mysql error code
*/
int ha_tsdb_engine::delete_row(const uchar *buf)
{
DBUG_ENTER("ha_tsdb_engine::delete_row");
DBUG_RETURN(HA_ERR_WRONG_COMMAND);
}
/*
@function ha_tsdb_engine::index_read_map
*/
int ha_tsdb_engine::index_read_map(uchar *buf, const uchar *key,
key_part_map keypart_map __attribute__((unused)),
enum ha_rkey_function find_flag
__attribute__((unused)))
{
int rc;
DBUG_ENTER("ha_tsdb_engine::index_read");
MYSQL_INDEX_READ_ROW_START(table_share->db.str, table_share->table_name.str);
rc= HA_ERR_WRONG_COMMAND;
MYSQL_INDEX_READ_ROW_DONE(rc);
DBUG_RETURN(rc);
}
/**
* @function ha_tsdb_engine::index_next
@brief
Used to read forward through the index.
*/
int ha_tsdb_engine::index_next(uchar *buf)
{
int rc;
DBUG_ENTER("ha_tsdb_engine::index_next");
MYSQL_INDEX_READ_ROW_START(table_share->db.str, table_share->table_name.str);
rc= HA_ERR_WRONG_COMMAND;
MYSQL_INDEX_READ_ROW_DONE(rc);
DBUG_RETURN(rc);
}
/**
@brief
Used to read backwards through the index.
*/
int ha_tsdb_engine::index_prev(uchar *buf)
{
int rc;
DBUG_ENTER("ha_tsdb_engine::index_prev");
MYSQL_INDEX_READ_ROW_START(table_share->db.str, table_share->table_name.str);
rc= HA_ERR_WRONG_COMMAND;
MYSQL_INDEX_READ_ROW_DONE(rc);
DBUG_RETURN(rc);
}
/*
@function ha_tsdb_engine::index_first
*/
int ha_tsdb_engine::index_first(uchar *buf)
{
int rc;
DBUG_ENTER("ha_tsdb_engine::index_first");
MYSQL_INDEX_READ_ROW_START(table_share->db.str, table_share->table_name.str);
rc= HA_ERR_WRONG_COMMAND;
MYSQL_INDEX_READ_ROW_DONE(rc);
DBUG_RETURN(rc);
}
/**
@brief
index_last() asks for the last key in the index.
@details
Called from opt_range.cc, opt_sum.cc, sql_handler.cc, and sql_select.cc.
@see
opt_range.cc, opt_sum.cc, sql_handler.cc and sql_select.cc
*/
int ha_tsdb_engine::index_last(uchar *buf)
{
int rc;
DBUG_ENTER("ha_tsdb_engine::index_last");
MYSQL_INDEX_READ_ROW_START(table_share->db.str, table_share->table_name.str);
rc= HA_ERR_WRONG_COMMAND;
MYSQL_INDEX_READ_ROW_DONE(rc);
DBUG_RETURN(rc);
}
/**
@brief
rnd_init() is called when the system wants the storage engine to do a table
scan. See the tsdb_engine in the introduction at the top of this file to see when
rnd_init() is called.
@details
Called from filesort.cc, records.cc, sql_handler.cc, sql_select.cc, sql_table.cc,
and sql_update.cc.
@see
filesort.cc, records.cc, sql_handler.cc, sql_select.cc, sql_table.cc and sql_update.cc
*/
int ha_tsdb_engine::rnd_init(bool scan)
{
DBUG_ENTER("ha_tsdb_engine::rnd_init");
//initialize random access
fRecordIndx=0;
fRecordNbr = fTMSeries->getNRecords();
fCacheRecInd = 0;
fCacheLen = 0;
fFirstEteration = true;
fTimeEcl =0;
fRownbr =0;
std::cerr << "[NOTE]: scan value " << scan << std::endl;
std::cerr << "[NOTE]: record Nbr " << fRecordNbr << std::endl;
DBUG_RETURN(0);
}
int ha_tsdb_engine::rnd_end()
{
DBUG_ENTER("ha_tsdb_engine::rnd_end");
std::cerr << "[NOTE] : random access end " << std::endl;
std::cerr << "[PROFILING]: fetching row took " << fTimeEcl << " for " << fRownbr << " : " << std::endl;
if ( fRownbr )
std::cerr << "Time/row " << fTimeEcl/fRownbr << std::endl;
DBUG_RETURN(0);
}
/**
@brief
This is called for each row of the table scan. When you run out of records
you should return HA_ERR_END_OF_FILE. Fill buff up with the row information.
The Field structure for the table is the key to getting data into buf
in a manner that will allow the server to understand it.
@details
Called from filesort.cc, records.cc, sql_handler.cc, sql_select.cc, sql_table.cc,
and sql_update.cc.
@see
filesort.cc, records.cc, sql_handler.cc, sql_select.cc, sql_table.cc and sql_update.cc
*/
int ha_tsdb_engine::rnd_next(uchar *buf)
{
int rc=0;
DBUG_ENTER("ha_tsdb_engine::rnd_next");
MYSQL_READ_ROW_START(table_share->db.str, table_share->table_name.str,TRUE);
if( fRecordIndx < fRecordNbr )
{
if ( fRecordIndx > fCacheRecInd + fCacheLen || (fFirstEteration == true))
{
try
{
uint64 start = _getTimeepoch();
fCacheRecords = fTMSeries->recordSet(fRecordIndx,fRecordIndx+10000);
fTimeEcl+= _getTimeepoch() - start;
fRownbr++;
}
catch(...)
{
std::cerr << "[NOTE] could not get recordSet" << std::endl;
}
fCacheRecInd = fRecordIndx;
fCacheLen= fCacheRecords.size();
fFirstEteration = false;
}
if (fCacheLen > 0)
{
//my_bitmap_map *old_map = dbug_tmp_use_all_columns(table,table->write_set );
tsdb::MemoryBlockPtr memptr = fCacheRecords[fRecordIndx - fCacheRecInd].memoryBlockPtr();
size_t mmlen = memptr.size();
const uchar* val = (const uchar*)memptr.raw();
val+=8; //skip timestamp
memcpy(buf,val,table->s->null_bytes);
val+= table->s->null_bytes;
for ( Field** field = table->field; *field; ++field)
{
if (!((*field)->is_null()))
{
val =(*field)->unpack(buf +(*field)->offset(table->record[0]),val);
}
}
}
else
{
std::cerr << "[NOTE]: empty record" << std::endl;
}
rc = 0;
fRecordIndx++;
table->status = 0;
}
else
{
rc = HA_ERR_END_OF_FILE;
}
MYSQL_READ_ROW_DONE(rc);
DBUG_RETURN(rc);
}
/**
@brief
position() is called after each call to rnd_next() if the data needs
to be ordered. You can do something like the following to store
the position:
@code
my_store_ptr(ref, ref_length, current_position);
@endcode
@details
The server uses ref to store data. ref_length in the above case is
the size needed to store current_position. ref is just a byte array
that the server will maintain. If you are using offsets to mark rows, then
current_position should be the offset. If it is a primary key like in
BDB, then it needs to be a primary key.
Called from filesort.cc, sql_select.cc, sql_delete.cc, and sql_update.cc.
@see
filesort.cc, sql_select.cc, sql_delete.cc and sql_update.cc
*/
void ha_tsdb_engine::position(const uchar *record)
{
DBUG_ENTER("ha_tsdb_engine::position");
std::cerr << "[NOTE] : position" << std::endl;
DBUG_VOID_RETURN;
}
/**
@brief
This is like rnd_next, but you are given a position to use
to determine the row. The position will be of the type that you stored in
ref. You can use ha_get_ptr(pos,ref_length) to retrieve whatever key
or position you saved when position() was called.
@details
Called from filesort.cc, records.cc, sql_insert.cc, sql_select.cc, and sql_update.cc.
@see
filesort.cc, records.cc, sql_insert.cc, sql_select.cc and sql_update.cc
*/
int ha_tsdb_engine::rnd_pos(uchar *buf, uchar *pos)
{
int rc=0;
DBUG_ENTER("ha_tsdb_engine::rnd_pos");
MYSQL_READ_ROW_START(table_share->db.str, table_share->table_name.str,
TRUE);
std::cerr << "[NOTE]: ha_tsdb_engine::rnd_pos" << std::endl;
rc= HA_ERR_WRONG_COMMAND;
MYSQL_READ_ROW_DONE(rc);
DBUG_RETURN(rc);
}
/**
@brief
::info() is used to return information to the optimizer. See my_base.h for
the complete description.
@details
Currently this table handler doesn't implement most of the fields really needed.
SHOW also makes use of this data.
You will probably want to have the following in your code:
@code
if (records < 2)
records = 2;
@endcode
The reason is that the server will optimize for cases of only a single
record. If, in a table scan, you don't know the number of records, it
will probably be better to set records to two so you can return as many
records as you need. Along with records, a few more variables you may wish
to set are:
records
deleted
data_file_length
index_file_length
delete_length
check_time
Take a look at the public variables in handler.h for more information.
Called in filesort.cc, ha_heap.cc, item_sum.cc, opt_sum.cc, sql_delete.cc,
sql_delete.cc, sql_derived.cc, sql_select.cc, sql_select.cc, sql_select.cc,
sql_select.cc, sql_select.cc, sql_show.cc, sql_show.cc, sql_show.cc, sql_show.cc,
sql_table.cc, sql_union.cc, and sql_update.cc.
@see
filesort.cc, ha_heap.cc, item_sum.cc, opt_sum.cc, sql_delete.cc, sql_delete.cc,
sql_derived.cc, sql_select.cc, sql_select.cc, sql_select.cc, sql_select.cc,
sql_select.cc, sql_show.cc, sql_show.cc, sql_show.cc, sql_show.cc, sql_table.cc,
sql_union.cc and sql_update.cc
*/
int ha_tsdb_engine::info(uint flag)
{
DBUG_ENTER("ha_tsdb_engine::info");
DBUG_RETURN(0);
}
/**
@brief
extra() is called whenever the server wishes to send a hint to
the storage engine. The myisam engine implements the most hints.
ha_innodb.cc has the most exhaustive list of these hints.
@see
ha_innodb.cc
*/
int ha_tsdb_engine::extra(enum ha_extra_function operation)
{
DBUG_ENTER("ha_tsdb_engine::extra");
DBUG_RETURN(0);
}
/**
@brief
Used to delete all rows in a table, including cases of truncate and cases where
the optimizer realizes that all rows will be removed as a result of an SQL statement.
@details
Called from item_sum.cc by Item_func_group_concat::clear(),
Item_sum_count_distinct::clear(), and Item_func_group_concat::clear().
Called from sql_delete.cc by mysql_delete().
Called from sql_select.cc by JOIN::reinit().
Called from sql_union.cc by st_select_lex_unit::exec().
@see
Item_func_group_concat::clear(), Item_sum_count_distinct::clear() and
Item_func_group_concat::clear() in item_sum.cc;
mysql_delete() in sql_delete.cc;
JOIN::reinit() in sql_select.cc and
st_select_lex_unit::exec() in sql_union.cc.
*/
int ha_tsdb_engine::delete_all_rows()
{
DBUG_ENTER("ha_tsdb_engine::delete_all_rows");
DBUG_RETURN(HA_ERR_WRONG_COMMAND);
}
/**
@brief
Used for handler specific truncate table. The table is locked in
exclusive mode and handler is responsible for reseting the auto-
increment counter.
@details
Called from Truncate_statement::handler_truncate.
Not used if the handlerton supports HTON_CAN_RECREATE, unless this
engine can be used as a partition. In this case, it is invoked when
a particular partition is to be truncated.
@see
Truncate_statement in sql_truncate.cc
Remarks in handler::truncate.
*/
int ha_tsdb_engine::truncate()
{
DBUG_ENTER("ha_tsdb_engine::truncate");
DBUG_RETURN(HA_ERR_WRONG_COMMAND);
}
/**
@brief
This create a lock on the table. If you are implementing a storage engine
that can handle transacations look at ha_berkely.cc to see how you will
want to go about doing this. Otherwise you should consider calling flock()
here. Hint: Read the section "locking functions for mysql" in lock.cc to understand
this.
@details
Called from lock.cc by lock_external() and unlock_external(). Also called
from sql_table.cc by copy_data_between_tables().
@see
lock.cc by lock_external() and unlock_external() in lock.cc;
the section "locking functions for mysql" in lock.cc;
copy_data_between_tables() in sql_table.cc.
*/
int ha_tsdb_engine::external_lock(THD *thd, int lock_type)
{
DBUG_ENTER("ha_tsdb_engine::external_lock");
DBUG_RETURN(0);
}
/**
@brief
The idea with handler::store_lock() is: The statement decides which locks
should be needed for the table. For updates/deletes/inserts we get WRITE
locks, for SELECT... we get read locks.
@details
Before adding the lock into the table lock handler (see thr_lock.c),
mysqld calls store lock with the requested locks. Store lock can now
modify a write lock to a read lock (or some other lock), ignore the
lock (if we don't want to use MySQL table locks at all), or add locks
for many tables (like we do when we are using a MERGE handler).
Berkeley DB, for example, changes all WRITE locks to TL_WRITE_ALLOW_WRITE
(which signals that we are doing WRITES, but are still allowing other
readers and writers).
When releasing locks, store_lock() is also called. In this case one
usually doesn't have to do anything.
In some exceptional cases MySQL may send a request for a TL_IGNORE;
This means that we are requesting the same lock as last time and this
should also be ignored. (This may happen when someone does a flush
table when we have opened a part of the tables, in which case mysqld
closes and reopens the tables and tries to get the same locks at last
time). In the future we will probably try to remove this.
Called from lock.cc by get_lock_data().
@note
In this method one should NEVER rely on table->in_use, it may, in fact,
refer to a different thread! (this happens if get_lock_data() is called
from mysql_lock_abort_for_thread() function)
@see
get_lock_data() in lock.cc
*/
THR_LOCK_DATA **ha_tsdb_engine::store_lock(THD *thd,
THR_LOCK_DATA **to,
enum thr_lock_type lock_type)
{
if (lock_type != TL_IGNORE && lock.type == TL_UNLOCK)
lock.type=lock_type;
*to++= &lock;
return to;
}
/**
@brief
Used to delete a table. By the time delete_table() has been called all
opened references to this table will have been closed (and your globally
shared references released). The variable name will just be the name of
the table. You will need to remove any files you have created at this point.
@details
If you do not implement this, the default delete_table() is called from
handler.cc and it will delete all files with the file extensions returned
by bas_ext().
Called from handler.cc by delete_table and ha_create_table(). Only used
during create if the table_flag HA_DROP_BEFORE_CREATE was specified for
the storage engine.
@see
delete_table and ha_create_table() in handler.cc
*/
int ha_tsdb_engine::delete_table(const char *name)
{
DBUG_ENTER("ha_tsdb_engine::delete_table");
/* This is not implemented but we want someone to be able that it works. */
DBUG_RETURN(0);
}
/**
@brief
Renames a table from one name to another via an alter table call.
@details
If you do not implement this, the default rename_table() is called from
handler.cc and it will delete all files with the file extensions returned
by bas_ext().
Called from sql_table.cc by mysql_rename_table().
@see
mysql_rename_table() in sql_table.cc
*/
int ha_tsdb_engine::rename_table(const char * from, const char * to)
{
DBUG_ENTER("ha_tsdb_engine::rename_table ");
DBUG_RETURN(HA_ERR_WRONG_COMMAND);
}
/**
@brief
Given a starting key and an ending key, estimate the number of rows that
will exist between the two keys.
@details
end_key may be empty, in which case determine if start_key matches any rows.
Called from opt_range.cc by check_quick_keys().
@see
check_quick_keys() in opt_range.cc
*/
ha_rows ha_tsdb_engine::records_in_range(uint inx, key_range *min_key,
key_range *max_key)
{
DBUG_ENTER("ha_tsdb_engine::records_in_range");
DBUG_RETURN(10); // low number to force index usage
}
/**
@brief
create() is called to create a database. The variable name will have the name
of the table.
@details
When create() is called you do not need to worry about
opening the table. Also, the .frm file will have already been
created so adjusting create_info is not necessary. You can overwrite
the .frm file at this point if you wish to change the table
definition, but there are no methods currently provided for doing
so.
Called from handle.cc by ha_create_table().
@see
ha_create_table() in handle.cc
*/
int ha_tsdb_engine::create(const char *name, TABLE *table_arg,
HA_CREATE_INFO *create_info)
{
DBUG_ENTER("ha_tsdb_engine::create");
mysql_mutex_lock(&fMutex);
if ( share == NULL )share = get_share();
/* if (share->count == 0 )
{
thr_lock_init(&share->lock)
}*/
// thr_lock_data_init(&share->lock,&lock,NULL);
/*
retrieve table name
*/
LEX_STRING filePath = table_arg->s->path;
if ( filePath.length == 0 )
{
DBUG_RETURN(1);
}
std::string strTableName(name) , strFilePath;
strFilePath.copy(filePath.str,filePath.length);
//append file extension
strTableName+=".tsdb";
//check file exists
struct stat finfo;
int intstat;
intstat = stat(strFilePath.c_str(),&finfo);
hid_t ofh;
if(intstat != 0)
{
// Try to create the file
ofh = H5Fcreate(strTableName.c_str(),H5F_ACC_EXCL,H5P_DEFAULT,H5P_DEFAULT);
if(ofh < 0) {
std::cerr << "[INFO]: name:" << name << std::endl;
std::cerr << "Error creating TSDB file: '" << strFilePath << "'." << std::endl;
DBUG_RETURN(-1);
}
}
else
{
//exception
std::cerr << "Error reading file" << strFilePath << std::endl;
DBUG_RETURN(-5);
}
tsdb::Structure* intStructure=NULL;
int err = CreateTSDBStructure(table_arg->field,&intStructure);
if ( err != 0)
{
std::cerr << "Error when creating internal structure " << err << std::endl; ;
return -6;
}
try{
tsdb::Timeseries ts = tsdb::Timeseries(ofh,"tsdb","",boost::make_shared<tsdb::Structure>(*intStructure));
}catch(...)
{
std::cerr << "[ERROR]: exception" << std::endl;
return -7;
}
//close hdf5 handle
H5Fclose(ofh);
fflush(stderr);
mysql_mutex_unlock(&fMutex);
DBUG_RETURN(0);
}
void ha_tsdb_engine::start_bulk_insert(ha_rows rows)
{
std::cerr << "ENTER ha_tsdb_engine::start_bulk_insert" << std::endl;
}
int ha_tsdb_engine::end_bulk_insert()
{
int err = 0;
//fTMSeries->flushAppendBuffer();
std::cerr << "ENTER ha_tsdb_engine::end_bulk_insert" << std::endl;
DBUG_RETURN(err);
}
struct st_mysql_storage_engine tsdb_engine_storage_engine=
{ MYSQL_HANDLERTON_INTERFACE_VERSION };
static ulong srv_enum_var= 0;
static ulong srv_ulong_var= 0;
static double srv_double_var= 0;
const char *enum_var_names[]=
{
"e1", "e2", NullS
};
TYPELIB enum_var_typelib=
{
array_elements(enum_var_names) - 1,
"enum_var_typelib",
enum_var_names,
NULL
};
static MYSQL_SYSVAR_ENUM(
enum_var, // name
srv_enum_var, // varname
PLUGIN_VAR_RQCMDARG, // opt
"Sample ENUM system variable.", // comment
NULL, // check
NULL, // update
0, // def
&enum_var_typelib); // typelib
static MYSQL_SYSVAR_ULONG(
ulong_var,
srv_ulong_var,
PLUGIN_VAR_RQCMDARG,
"0..1000",
NULL,
NULL,
8,
0,
1000,
0);
static MYSQL_SYSVAR_DOUBLE(
double_var,
srv_double_var,
PLUGIN_VAR_RQCMDARG,
"0.500000..1000.500000",
NULL,
NULL,
8.5,
0.5,
1000.5,
0); // reserved always 0
static MYSQL_THDVAR_DOUBLE(
double_thdvar,
PLUGIN_VAR_RQCMDARG,
"0.500000..1000.500000",
NULL,
NULL,
8.5,
0.5,
1000.5,
0);
static struct st_mysql_sys_var* tsdb_engine_system_variables[]= {
MYSQL_SYSVAR(enum_var),
MYSQL_SYSVAR(ulong_var),
MYSQL_SYSVAR(double_var),
MYSQL_SYSVAR(double_thdvar),
NULL
};
// this is an tsdb_engine of SHOW_FUNC and of my_snprintf() service
static int show_func_tsdb_engine(MYSQL_THD thd, struct st_mysql_show_var *var,
char *buf)
{