You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
545 lines
26 KiB
545 lines
26 KiB
/*
|
|
* This Source Code Form is subject to the terms of the Mozilla Public
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
|
|
*
|
|
* Copyright 1997 - July 2008 CWI, August 2008 - 2022 MonetDB B.V.
|
|
*/
|
|
|
|
#ifndef SQL_STORAGE_H
|
|
#define SQL_STORAGE_H
|
|
|
|
#include "sql_catalog.h"
|
|
#include "store_sequence.h"
|
|
|
|
#define COLSIZE 1024
|
|
|
|
#define LOG_OK 0
|
|
#define LOG_ERR (-1)
|
|
#define LOG_CONFLICT (-2)
|
|
|
|
#define isTempTable(x) ((x)->persistence!=SQL_PERSIST)
|
|
#define isGlobal(x) ((x)->persistence!=SQL_LOCAL_TEMP && (x)->persistence!=SQL_DECLARED_TABLE)
|
|
#define isGlobalTemp(x) ((x)->persistence==SQL_GLOBAL_TEMP)
|
|
#define isLocalTemp(x) ((x)->persistence==SQL_LOCAL_TEMP)
|
|
#define isTempSchema(x) (strcmp((x)->base.name, "tmp") == 0)
|
|
#define isDeclaredTable(x) ((x)->persistence==SQL_DECLARED_TABLE)
|
|
|
|
typedef enum store_type {
|
|
store_bat, /* delta bats, ie multi user read/write */
|
|
store_tst,
|
|
store_mem
|
|
} store_type;
|
|
|
|
|
|
struct sqlstore;
|
|
|
|
/* builtin functions have ids less than this */
|
|
#define FUNC_OIDS 2000
|
|
|
|
/* relational interface */
|
|
typedef oid (*column_find_row_fptr)(sql_trans *tr, sql_column *c, const void *value, ...);
|
|
typedef void *(*column_find_value_fptr)(sql_trans *tr, sql_column *c, oid rid);
|
|
typedef sqlid (*column_find_sqlid_fptr)(sql_trans *tr, sql_column *c, oid rid);
|
|
typedef bte (*column_find_bte_fptr)(sql_trans *tr, sql_column *c, oid rid);
|
|
typedef sht (*column_find_sht_fptr)(sql_trans *tr, sql_column *c, oid rid);
|
|
typedef int (*column_find_int_fptr)(sql_trans *tr, sql_column *c, oid rid);
|
|
typedef lng (*column_find_lng_fptr)(sql_trans *tr, sql_column *c, oid rid);
|
|
typedef const char * (*column_find_string_start_fptr)(sql_trans *tr, sql_column *c, oid rid, ptr *cbat);
|
|
typedef void (*column_find_string_end_fptr)(ptr cbat);
|
|
typedef int (*column_update_value_fptr)(sql_trans *tr, sql_column *c, oid rid, void *value);
|
|
typedef int (*table_insert_fptr)(sql_trans *tr, sql_table *t, ...);
|
|
typedef int (*table_delete_fptr)(sql_trans *tr, sql_table *t, oid rid);
|
|
|
|
typedef res_table *(*table_orderby_fptr)(sql_trans *tr, sql_table *t,
|
|
sql_column *jl, sql_column *jr,
|
|
sql_column *jl2, sql_column *jr2 /* optional join(jl,jr,(jl2,jr2)) */, sql_column *o, ...);
|
|
typedef void *(*table_fetch_value_fptr)(res_table *rt, sql_column *c);
|
|
typedef void (*table_result_destroy_fptr)(res_table *rt);
|
|
|
|
typedef struct rids {
|
|
BUN cur;
|
|
void *data;
|
|
} rids;
|
|
|
|
typedef struct subrids {
|
|
BUN pos;
|
|
sqlid id;
|
|
void *ids;
|
|
void *rids;
|
|
} subrids;
|
|
|
|
/* returns table rids, for the given select ranges */
|
|
typedef rids *(*rids_select_fptr)( sql_trans *tr, sql_column *key, const void *key_value_low, const void *key_value_high, ...);
|
|
|
|
/* order rids by orderby_column values */
|
|
typedef rids *(*rids_orderby_fptr)( sql_trans *tr, rids *r, sql_column *orderby_col);
|
|
|
|
typedef rids *(*rids_join_fptr)( sql_trans *tr, rids *l, sql_column *lc, rids *r, sql_column *rc);
|
|
typedef rids *(*rids_semijoin_fptr)( sql_trans *tr, rids *l, sql_column *lc, rids *r, sql_column *rc);
|
|
typedef rids *(*rids_diff_fptr)( sql_trans *tr, rids *l, sql_column *lc, subrids *r, sql_column *rc);
|
|
|
|
/* return table rids from result of table_select, return (-1) when done */
|
|
typedef oid (*rids_next_fptr)(rids *r);
|
|
|
|
/* clean up the resources taken by the result of table_select */
|
|
typedef void (*rids_destroy_fptr)(rids *r);
|
|
typedef int (*rids_empty_fptr)(rids *r);
|
|
|
|
typedef subrids *(*subrids_create_fptr)( sql_trans *tr, rids *l, sql_column *jc1, sql_column *jc2, sql_column *obc);
|
|
|
|
/* return table rids from result of table_select, return (-1) when done */
|
|
typedef oid (*subrids_next_fptr)(subrids *r);
|
|
typedef sqlid (*subrids_nextid_fptr)(subrids *r);
|
|
|
|
/* clean up the resources taken by the result of table_select */
|
|
typedef void (*subrids_destroy_fptr)(subrids *r);
|
|
|
|
typedef struct table_functions {
|
|
column_find_row_fptr column_find_row;
|
|
column_find_value_fptr column_find_value;
|
|
column_find_sqlid_fptr column_find_sqlid;
|
|
column_find_bte_fptr column_find_bte;
|
|
column_find_int_fptr column_find_int;
|
|
column_find_lng_fptr column_find_lng;
|
|
column_find_string_start_fptr column_find_string_start; /* this function returns a pointer to the heap, use it with care! */
|
|
column_find_string_end_fptr column_find_string_end; /* don't forget to call this function to unfix the bat descriptor! */
|
|
|
|
column_update_value_fptr column_update_value;
|
|
table_insert_fptr table_insert;
|
|
table_delete_fptr table_delete;
|
|
table_orderby_fptr table_orderby;
|
|
table_fetch_value_fptr table_fetch_value;
|
|
table_result_destroy_fptr table_result_destroy;
|
|
|
|
rids_select_fptr rids_select;
|
|
rids_orderby_fptr rids_orderby;
|
|
rids_join_fptr rids_join;
|
|
rids_semijoin_fptr rids_semijoin;
|
|
rids_next_fptr rids_next;
|
|
rids_destroy_fptr rids_destroy;
|
|
rids_empty_fptr rids_empty;
|
|
|
|
subrids_create_fptr subrids_create;
|
|
subrids_next_fptr subrids_next;
|
|
subrids_nextid_fptr subrids_nextid;
|
|
subrids_destroy_fptr subrids_destroy;
|
|
rids_diff_fptr rids_diff;
|
|
} table_functions;
|
|
|
|
/* delta table setup (ie readonly col + ins + upd + del)
|
|
-- binds for column,idx (rdonly, inserts, updates) and delets
|
|
*/
|
|
typedef void *(*bind_col_fptr) (sql_trans *tr, sql_column *c, int access);
|
|
typedef void *(*bind_idx_fptr) (sql_trans *tr, sql_idx *i, int access);
|
|
typedef void *(*bind_cands_fptr) (sql_trans *tr, sql_table *t, int nr_of_parts, int part_nr);
|
|
|
|
typedef int (*append_col_fptr) (sql_trans *tr, sql_column *c, BUN offset, BAT *offsets, void *d, BUN cnt, int t);
|
|
typedef int (*append_idx_fptr) (sql_trans *tr, sql_idx *i, BUN offset, BAT *offsets, void *d, BUN cnt, int t);
|
|
|
|
typedef int (*update_col_fptr) (sql_trans *tr, sql_column *c, void *tids, void *d, int t);
|
|
typedef int (*update_idx_fptr) (sql_trans *tr, sql_idx *i, void *tids, void *d, int t);
|
|
|
|
typedef int (*delete_tab_fptr) (sql_trans *tr, sql_table *t, void *d, int tpe);
|
|
typedef int (*claim_tab_fptr) (sql_trans *tr, sql_table *t, size_t cnt, BUN *offset, BAT **offsets);
|
|
typedef int (*tab_validate_fptr) (sql_trans *tr, sql_table *t, int uncommitted);
|
|
|
|
/*
|
|
-- count number of rows in column (excluding the deletes)
|
|
-- check for sortedness
|
|
*/
|
|
typedef size_t (*count_del_fptr) (sql_trans *tr, sql_table *t, int access);
|
|
typedef size_t (*count_col_fptr) (sql_trans *tr, sql_column *c, int access);
|
|
typedef size_t (*count_idx_fptr) (sql_trans *tr, sql_idx *i, int access);
|
|
typedef size_t (*dcount_col_fptr) (sql_trans *tr, sql_column *c);
|
|
typedef int (*min_max_col_fptr) (sql_trans *tr, sql_column *c);
|
|
typedef int (*prop_col_fptr) (sql_trans *tr, sql_column *c);
|
|
|
|
/*
|
|
-- create the necessary storage resources for columns, indices and tables
|
|
-- returns LOG_OK, LOG_ERR
|
|
*/
|
|
typedef int (*create_col_fptr) (sql_trans *tr, sql_column *c);
|
|
typedef int (*create_idx_fptr) (sql_trans *tr, sql_idx *i);
|
|
typedef int (*create_del_fptr) (sql_trans *tr, sql_table *t);
|
|
|
|
typedef void *(*col_dup_fptr) (sql_column *c);
|
|
typedef void *(*idx_dup_fptr) (sql_idx *i);
|
|
typedef void *(*del_dup_fptr) (sql_table *t);
|
|
|
|
/*
|
|
-- upgrade the necessary storage resources for columns, indices and tables
|
|
-- needed for the upgrade of the logger structure (ie user tables are
|
|
-- now stored using the object ids, no longer the names). This allows
|
|
-- renames.
|
|
-- returns LOG_OK, LOG_ERR
|
|
*/
|
|
typedef int (*upgrade_col_fptr) (sql_trans *tr, sql_column *c);
|
|
typedef int (*upgrade_idx_fptr) (sql_trans *tr, sql_idx *i);
|
|
typedef int (*upgrade_del_fptr) (sql_trans *tr, sql_table *t);
|
|
typedef int (*swap_bats_fptr) (sql_trans *tr, sql_column *c, BAT *b);
|
|
|
|
/*
|
|
-- free the storage resources for columns, indices and tables
|
|
-- returns LOG_OK, LOG_ERR
|
|
*/
|
|
typedef int (*destroy_col_fptr) (struct sqlstore *store, sql_column *c);
|
|
typedef int (*destroy_idx_fptr) (struct sqlstore *store, sql_idx *i);
|
|
typedef int (*destroy_del_fptr) (struct sqlstore *store, sql_table *t);
|
|
|
|
/*
|
|
-- drop a persistent table, ie add to the list of changes
|
|
-- returns LOG_OK, LOG_ERR
|
|
*/
|
|
typedef int (*drop_col_fptr) (sql_trans *tr, sql_column *c);
|
|
typedef int (*drop_idx_fptr) (sql_trans *tr, sql_idx *i);
|
|
typedef int (*drop_del_fptr) (sql_trans *tr, sql_table *t);
|
|
|
|
typedef BUN (*clear_table_fptr) (sql_trans *tr, sql_table *t);
|
|
|
|
typedef enum storage_type {
|
|
ST_DEFAULT = 0,
|
|
ST_DICT,
|
|
ST_FOR,
|
|
} storage_type;
|
|
|
|
typedef int (*col_compress_fptr) (sql_trans *tr, sql_column *c, storage_type st, BAT *offsets, BAT *vals);
|
|
|
|
/*
|
|
-- update_table rollforward the changes made from table ft to table tt
|
|
-- returns LOG_OK, LOG_ERR
|
|
*/
|
|
typedef int (*update_table_fptr) (sql_trans *tr, sql_table *ft, sql_table *tt);
|
|
|
|
/* backing struct for this interface */
|
|
typedef struct store_functions {
|
|
|
|
bind_col_fptr bind_col;
|
|
bind_idx_fptr bind_idx;
|
|
bind_cands_fptr bind_cands;
|
|
|
|
append_col_fptr append_col;
|
|
append_idx_fptr append_idx;
|
|
|
|
update_col_fptr update_col;
|
|
update_idx_fptr update_idx;
|
|
|
|
delete_tab_fptr delete_tab;
|
|
claim_tab_fptr claim_tab;
|
|
claim_tab_fptr key_claim_tab;
|
|
tab_validate_fptr tab_validate;
|
|
|
|
count_del_fptr count_del;
|
|
count_col_fptr count_col;
|
|
count_idx_fptr count_idx;
|
|
dcount_col_fptr dcount_col;
|
|
min_max_col_fptr min_max_col;
|
|
prop_col_fptr sorted_col;
|
|
prop_col_fptr unique_col;
|
|
prop_col_fptr double_elim_col; /* varsize col with double elimination */
|
|
|
|
col_dup_fptr col_dup;
|
|
idx_dup_fptr idx_dup;
|
|
del_dup_fptr del_dup;
|
|
|
|
create_col_fptr create_col;
|
|
create_idx_fptr create_idx;
|
|
create_del_fptr create_del;
|
|
|
|
destroy_col_fptr destroy_col;
|
|
destroy_idx_fptr destroy_idx;
|
|
destroy_del_fptr destroy_del;
|
|
|
|
drop_col_fptr drop_col;
|
|
drop_idx_fptr drop_idx;
|
|
drop_del_fptr drop_del;
|
|
|
|
clear_table_fptr clear_table;
|
|
col_compress_fptr col_compress;
|
|
|
|
upgrade_col_fptr upgrade_col;
|
|
upgrade_idx_fptr upgrade_idx;
|
|
upgrade_del_fptr upgrade_del;
|
|
swap_bats_fptr swap_bats;
|
|
} store_functions;
|
|
|
|
typedef int (*logger_create_fptr) (struct sqlstore *store, int debug, const char *logdir, int catalog_version);
|
|
|
|
typedef void (*logger_destroy_fptr) (struct sqlstore *store);
|
|
typedef int (*logger_flush_fptr) (struct sqlstore *store, lng save_id);
|
|
typedef int (*logger_activate_fptr) (struct sqlstore *store);
|
|
typedef int (*logger_cleanup_fptr) (struct sqlstore *store);
|
|
|
|
typedef int (*logger_changes_fptr)(struct sqlstore *store);
|
|
typedef int (*logger_get_sequence_fptr) (struct sqlstore *store, int seq, lng *id);
|
|
|
|
typedef int (*log_isnew_fptr)(struct sqlstore *store);
|
|
typedef int (*log_tstart_fptr) (struct sqlstore *store, bool flush);
|
|
typedef int (*log_tend_fptr) (struct sqlstore *store);
|
|
typedef int (*log_tdone_fptr) (struct sqlstore *store, ulng commit_ts);
|
|
typedef lng (*log_save_id_fptr) (struct sqlstore *store);
|
|
typedef int (*log_sequence_fptr) (struct sqlstore *store, int seq, lng id);
|
|
|
|
/*
|
|
-- List which parts of which files must be included in a hot snapshot.
|
|
-- This is written to the given stream in the following format:
|
|
-- - The first line is the absolute path of the db dir. All other paths
|
|
-- are relative to this.
|
|
-- - Every other line is either "c %ld %s\n" or "w %ld %s\n". The long
|
|
-- is always the number of bytes to write. The %s is the relative path of the
|
|
-- destination. For "c" lines (copy), it is also the relative path of the
|
|
-- source file. For "w" lines (write), the %ld bytes to write follow directly
|
|
-- after the newline.
|
|
-- Using a stream (buffer) instead of a list data structure simplifies debugging
|
|
-- and avoids a lot of tiny allocations and pointer manipulations.
|
|
*/
|
|
typedef gdk_return (*logger_get_snapshot_files_fptr)(struct sqlstore *store, stream *plan);
|
|
|
|
typedef struct logger_functions {
|
|
logger_create_fptr create;
|
|
logger_destroy_fptr destroy;
|
|
logger_flush_fptr flush;
|
|
logger_activate_fptr activate;
|
|
|
|
logger_changes_fptr changes;
|
|
logger_get_sequence_fptr get_sequence;
|
|
|
|
logger_get_snapshot_files_fptr get_snapshot_files;
|
|
|
|
log_isnew_fptr log_isnew;
|
|
log_tstart_fptr log_tstart;
|
|
log_tend_fptr log_tend;
|
|
log_tdone_fptr log_tdone;
|
|
log_save_id_fptr log_save_id;
|
|
log_sequence_fptr log_sequence;
|
|
} logger_functions;
|
|
|
|
/* we need to add an interface for result_tables later */
|
|
|
|
extern res_table *res_table_create(sql_trans *tr, int res_id, oid query_id, int nr_cols, mapi_query_t querytype, res_table *next, void *order);
|
|
extern res_col *res_col_create(sql_trans *tr, res_table *t, const char *tn, const char *name, const char *typename, int digits, int scale, char mtype, void *v, bool cache);
|
|
|
|
extern void res_table_destroy(res_table *t);
|
|
|
|
extern res_table *res_tables_remove(res_table *results, res_table *t);
|
|
sql_export void res_tables_destroy(res_table *results);
|
|
extern res_table *res_tables_find(res_table *results, int res_id);
|
|
|
|
extern struct sqlstore *store_init(int debug, store_type store, int readonly, int singleuser);
|
|
extern void store_exit(struct sqlstore *store);
|
|
|
|
extern void store_suspend_log(struct sqlstore *store);
|
|
extern void store_resume_log(struct sqlstore *store);
|
|
extern lng store_hot_snapshot(struct sqlstore *store, str tarfile);
|
|
extern lng store_hot_snapshot_to_stream(struct sqlstore *store, stream *s);
|
|
|
|
extern ulng store_function_counter(struct sqlstore *store);
|
|
|
|
extern ulng store_oldest(struct sqlstore *store);
|
|
extern ulng store_get_timestamp(struct sqlstore *store);
|
|
extern void store_manager(struct sqlstore *store);
|
|
|
|
extern void store_lock(struct sqlstore *store);
|
|
extern void store_unlock(struct sqlstore *store);
|
|
extern sqlid store_next_oid(struct sqlstore *store);
|
|
|
|
extern int store_readonly(struct sqlstore *store);
|
|
|
|
extern sql_trans *sql_trans_create(struct sqlstore *store, sql_trans *parent, const char *name);
|
|
extern sql_trans *sql_trans_destroy(sql_trans *tr);
|
|
//extern bool sql_trans_validate(sql_trans *tr);
|
|
extern int sql_trans_commit(sql_trans *tr);
|
|
|
|
extern int sql_trans_create_type(sql_trans *tr, sql_schema *s, const char *sqlname, unsigned int digits, unsigned int scale, int radix, const char *impl);
|
|
extern int sql_trans_drop_type(sql_trans *tr, sql_schema * s, sqlid id, int drop_action);
|
|
|
|
extern int sql_trans_create_func(sql_func **fres, sql_trans *tr, sql_schema *s, const char *func, list *args, list *res, sql_ftype type, sql_flang lang,
|
|
const char *mod, const char *impl, const char *query, bit varres, bit vararg, bit system, bit side_effect);
|
|
|
|
extern int sql_trans_drop_func(sql_trans *tr, sql_schema *s, sqlid id, int drop_action);
|
|
extern int sql_trans_drop_all_func(sql_trans *tr, sql_schema *s, list *list_func, int drop_action);
|
|
|
|
extern void sql_trans_update_tables(sql_trans *tr, sql_schema *s);
|
|
extern void sql_trans_update_schemas(sql_trans *tr);
|
|
|
|
extern int sql_trans_create_schema(sql_trans *tr, const char *name, sqlid auth_id, sqlid owner);
|
|
extern int sql_trans_rename_schema(sql_trans *tr, sqlid id, const char *new_name);
|
|
extern int sql_trans_drop_schema(sql_trans *tr, sqlid id, int drop_action);
|
|
|
|
sql_export int sql_trans_create_table(sql_table **tres, sql_trans *tr, sql_schema *s, const char *name, const char *sql, int tt, bit system, int persistence, int commit_action, int sz, bte properties);
|
|
|
|
extern int sql_trans_set_partition_table(sql_trans *tr, sql_table *t);
|
|
extern int sql_trans_add_table(sql_trans *tr, sql_table *mt, sql_table *pt);
|
|
extern int sql_trans_add_range_partition(sql_trans *tr, sql_table *mt, sql_table *pt, sql_subtype tpe, ptr min, ptr max, bit with_nills, int update, sql_part** err);
|
|
extern int sql_trans_add_value_partition(sql_trans *tr, sql_table *mt, sql_table *pt, sql_subtype tpe, list* vals, bit with_nills, int update, sql_part **err);
|
|
|
|
extern int sql_trans_rename_table(sql_trans *tr, sql_schema *s, sqlid id, const char *new_name);
|
|
extern int sql_trans_set_table_schema(sql_trans *tr, sqlid id, sql_schema *os, sql_schema *ns);
|
|
extern int sql_trans_del_table(sql_trans *tr, sql_table *mt, sql_table *pt, int drop_action);
|
|
|
|
extern int sql_trans_drop_table(sql_trans *tr, sql_schema *s, const char *name, int drop_action);
|
|
extern int sql_trans_drop_table_id(sql_trans *tr, sql_schema *s, sqlid id, int drop_action);
|
|
extern BUN sql_trans_clear_table(sql_trans *tr, sql_table *t);
|
|
extern int sql_trans_alter_access(sql_trans *tr, sql_table *t, sht access);
|
|
|
|
extern int sql_trans_create_column(sql_column **rcol, sql_trans *tr, sql_table *t, const char *name, sql_subtype *tpe);
|
|
extern int sql_trans_rename_column(sql_trans *tr, sql_table *t, sqlid id, const char *old_name, const char *new_name);
|
|
extern int sql_trans_drop_column(sql_trans *tr, sql_table *t, sqlid id, int drop_action);
|
|
extern int sql_trans_alter_null(sql_trans *tr, sql_column *col, int isnull);
|
|
extern int sql_trans_alter_default(sql_trans *tr, sql_column *col, char *val);
|
|
extern int sql_trans_alter_storage(sql_trans *tr, sql_column *col, char *storage);
|
|
extern int sql_trans_is_sorted(sql_trans *tr, sql_column *col);
|
|
extern int sql_trans_is_unique(sql_trans *tr, sql_column *col);
|
|
extern int sql_trans_is_duplicate_eliminated(sql_trans *tr, sql_column *col);
|
|
extern size_t sql_trans_dist_count(sql_trans *tr, sql_column *col);
|
|
extern int sql_trans_ranges(sql_trans *tr, sql_column *col, void **min, void **max);
|
|
|
|
extern void column_destroy(struct sqlstore *store, sql_column *c);
|
|
extern void idx_destroy(struct sqlstore *store, sql_idx * i);
|
|
extern void table_destroy(struct sqlstore *store, sql_table *t);
|
|
|
|
extern int sql_trans_create_ukey(sql_key **res, sql_trans *tr, sql_table *t, const char *name, key_type kt);
|
|
extern int sql_trans_key_done(sql_trans *tr, sql_key *k);
|
|
|
|
extern int sql_trans_create_fkey(sql_fkey **res, sql_trans *tr, sql_table *t, const char *name, key_type kt, sql_key *rkey, int on_delete, int on_update);
|
|
extern int sql_trans_create_kc(sql_trans *tr, sql_key *k, sql_column *c);
|
|
extern int sql_trans_create_fkc(sql_trans *tr, sql_fkey *fk, sql_column *c);
|
|
extern int sql_trans_drop_key(sql_trans *tr, sql_schema *s, sqlid id, int drop_action);
|
|
|
|
extern int sql_trans_create_idx(sql_idx **i, sql_trans *tr, sql_table *t, const char *name, idx_type it);
|
|
extern int sql_trans_create_ic(sql_trans *tr, sql_idx *i, sql_column *c);
|
|
extern int sql_trans_drop_idx(sql_trans *tr, sql_schema *s, sqlid id, int drop_action);
|
|
|
|
extern int sql_trans_create_trigger(sql_trigger **tres, sql_trans *tr, sql_table *t, const char *name,sht time, sht orientation, sht event, const char *old_name, const char *new_name,const char *condition, const char *statement);
|
|
extern int sql_trans_drop_trigger(sql_trans *tr, sql_schema *s, sqlid id, int drop_action);
|
|
|
|
extern sql_sequence *create_sql_sequence(struct sqlstore *store, sql_allocator *sa, sql_schema *s, const char *name, lng start, lng min, lng max, lng inc, lng cacheinc, bit cycle);
|
|
extern int sql_trans_create_sequence(sql_trans *tr, sql_schema *s, const char *name, lng start, lng min, lng max, lng inc, lng cacheinc, bit cycle, bit bedropped);
|
|
extern int sql_trans_drop_sequence(sql_trans *tr, sql_schema *s, sql_sequence *seq, int drop_action);
|
|
extern int sql_trans_alter_sequence(sql_trans *tr, sql_sequence *seq, lng min, lng max, lng inc, lng cache, bit cycle);
|
|
extern int sql_trans_sequence_restart(sql_trans *tr, sql_sequence *seq, lng start);
|
|
|
|
extern sql_session * sql_session_create(struct sqlstore *store, sql_allocator *sa, int autocommit);
|
|
extern void sql_session_destroy(sql_session *s);
|
|
extern int sql_session_reset(sql_session *s, int autocommit);
|
|
extern int sql_trans_begin(sql_session *s);
|
|
extern int sql_trans_end(sql_session *s, int commit /* rollback=0, or commit=1 temporaries */);
|
|
|
|
extern list* sql_trans_schema_user_dependencies(sql_trans *tr, sqlid schema_id);
|
|
extern int sql_trans_create_dependency(sql_trans *tr, sqlid id, sqlid depend_id, sql_dependency depend_type);
|
|
extern int sql_trans_drop_dependencies(sql_trans *tr, sqlid depend_id);
|
|
extern int sql_trans_drop_dependency(sql_trans *tr, sqlid id, sqlid depend_id, sql_dependency depend_type);
|
|
extern list* sql_trans_get_dependencies(sql_trans *tr, sqlid id, sql_dependency depend_type, list *ignore_ids);
|
|
extern int sql_trans_get_dependency_type(sql_trans *tr, sqlid depend_id, sql_dependency depend_type);
|
|
extern int sql_trans_check_dependency(sql_trans *tr, sqlid id, sqlid depend_id, sql_dependency depend_type);
|
|
extern list* sql_trans_owner_schema_dependencies(sql_trans *tr, sqlid id);
|
|
|
|
extern sql_table *create_sql_table(struct sqlstore *store, sql_allocator *sa, const char *name, sht type, bit system, int persistence, int commit_action, bit properties);
|
|
extern sql_column *create_sql_column(struct sqlstore *store, sql_allocator *sa, sql_table *t, const char *name, sql_subtype *tpe);
|
|
extern sql_key *create_sql_ukey(struct sqlstore *store, sql_allocator *sa, sql_table *t, const char *nme, key_type kt);
|
|
extern sql_fkey *create_sql_fkey(struct sqlstore *store, sql_allocator *sa, sql_table *t, const char *nme, key_type kt, sql_key *rkey, int on_delete, int on_update );
|
|
extern sql_key *create_sql_kc(struct sqlstore *store, sql_allocator *sa, sql_key *k, sql_column *c);
|
|
extern sql_key * key_create_done(sql_trans *tr, sql_allocator *sa, sql_key *k);
|
|
|
|
extern sql_idx *create_sql_idx(struct sqlstore *store, sql_allocator *sa, sql_table *t, const char *nme, idx_type it);
|
|
extern sql_idx *create_sql_ic(struct sqlstore *store, sql_allocator *sa, sql_idx *i, sql_column *c);
|
|
extern sql_idx *create_sql_idx_done(sql_trans *tr, sql_idx *i);
|
|
extern sql_func *create_sql_func(struct sqlstore *store, sql_allocator *sa, const char *func, list *args, list *res, sql_ftype type, sql_flang lang, const char *mod,
|
|
const char *impl, const char *query, bit varres, bit vararg, bit system, bit side_effect);
|
|
|
|
/* for alter we need to duplicate a table */
|
|
extern sql_table *dup_sql_table(sql_allocator *sa, sql_table *t);
|
|
extern void drop_sql_column(sql_table *t, sqlid id, int drop_action);
|
|
extern void drop_sql_idx(sql_table *t, sqlid id);
|
|
extern void drop_sql_key(sql_table *t, sqlid id, int drop_action);
|
|
|
|
extern int sql_trans_copy_column(sql_trans *tr, sql_table *t, sql_column *c, sql_column **cres);
|
|
extern int sql_trans_copy_key(sql_trans *tr, sql_table *t, sql_key *k, sql_key **kres);
|
|
extern int sql_trans_copy_idx(sql_trans *tr, sql_table *t, sql_idx *i, sql_idx **ires);
|
|
extern int sql_trans_copy_trigger(sql_trans *tr, sql_table *t, sql_trigger *tri, sql_trigger **tres);
|
|
extern sql_table *globaltmp_instantiate(sql_trans *tr, sql_table *t);
|
|
|
|
#define NR_TABLE_LOCKS 64
|
|
#define NR_COLUMN_LOCKS 512
|
|
#define TRANSACTION_ID_BASE (1ULL<<63)
|
|
|
|
typedef struct sqlstore {
|
|
int catalog_version; /* software version of the catalog */
|
|
sql_catalog *cat; /* the catalog of persistent tables (what to do with tmp tables ?) */
|
|
sql_schema *tmp; /* keep pointer to default (empty) tmp schema */
|
|
MT_Lock lock; /* lock protecting concurrent writes (not reads, ie use rcu) */
|
|
MT_Lock commit; /* protect transactions, only single commit (one wal writer) */
|
|
MT_Lock flush; /* flush lock protecting concurrent writes (not reads, ie use rcu) */
|
|
MT_Lock table_locks[NR_TABLE_LOCKS]; /* protecting concurrent writes to tables (storage) */
|
|
MT_Lock column_locks[NR_COLUMN_LOCKS]; /* protecting concurrent writes to columns (storage) */
|
|
list *active; /* list of running transactions */
|
|
|
|
ATOMIC_TYPE nr_active; /* count number of transactions */
|
|
ATOMIC_TYPE lastactive; /* timestamp of last active client */
|
|
ATOMIC_TYPE timestamp; /* timestamp counter */
|
|
ATOMIC_TYPE transaction;/* transaction id counter */
|
|
ATOMIC_TYPE function_counter;/* function counter used during function instantiation */
|
|
ulng oldest;
|
|
ulng oldest_pending;
|
|
int readonly; /* store is readonly */
|
|
int singleuser; /* store is for a single user only (==1 enable, ==2 single user session running) */
|
|
int first; /* just created the db */
|
|
int initialized; /* used during bootstrap only */
|
|
int debug; /* debug mask */
|
|
store_type active_type;
|
|
list *changes; /* pending changes to cleanup */
|
|
sql_hash *dependencies; /* pending dependencies created to cleanup */
|
|
sql_hash *depchanges; /* pending dependencies changes to cleanup */
|
|
list *seqchanges; /* pending sequence number changes to be add to the first commiting transaction */
|
|
sql_hash *sequences; /* loaded store sequence numbers */
|
|
|
|
sql_allocator *sa; /* for now a store allocator, needs a special version with free operations (with reuse) */
|
|
sqlid obj_id, prev_oid;
|
|
|
|
store_functions storage_api;
|
|
table_functions table_api;
|
|
logger_functions logger_api;
|
|
void *logger; /* space to keep logging structure of storage backend */
|
|
} sqlstore;
|
|
|
|
typedef enum sql_dependency_change_type {
|
|
ddl = 1,
|
|
dml = 2
|
|
} sql_dependency_change_type;
|
|
|
|
typedef struct sql_dependency_change {
|
|
sqlid objid; /* id of the object where the dependency was created */
|
|
sql_dependency_change_type type; /* type of dependency */
|
|
ulng ts; /* transaction timestamp of the dependency */
|
|
} sql_dependency_change;
|
|
|
|
typedef struct sql_change {
|
|
sql_base *obj;
|
|
ulng ts; /* commit/rollback timestamp */
|
|
void *data; /* data changes */
|
|
bool committed; /* commit or rollback */
|
|
bool handled; /* handled in commit */
|
|
tc_log_fptr log; /* callback to log changes */
|
|
tc_commit_fptr commit; /* callback to commit or rollback the changes */
|
|
tc_cleanup_fptr cleanup;/* callback to cleanup changes */
|
|
} sql_change;
|
|
|
|
extern void trans_add(sql_trans *tr, sql_base *b, void *data, tc_cleanup_fptr cleanup, tc_commit_fptr commit, tc_log_fptr log);
|
|
extern int tr_version_of_parent(sql_trans *tr, ulng ts);
|
|
|
|
extern int sql_trans_add_predicate(sql_trans* tr, sql_column *c, unsigned int cmp, atom *r, atom *f, bool anti, bool semantics);
|
|
extern int sql_trans_add_dependency(sql_trans* tr, sqlid id, sql_dependency_change_type tp);
|
|
sql_export int sql_trans_add_dependency_change(sql_trans *tr, sqlid id, sql_dependency_change_type tp);
|
|
|
|
/* later move intop dict.h on this level */
|
|
extern BAT *DICTenlarge(BAT *offsets, BUN cnt, BUN sz, role_t role);
|
|
extern BAT *DICTdecompress_(BAT *o, BAT *u, role_t role);
|
|
extern int DICTprepare4append(BAT **noffsets, BAT *vals, BAT *dict);
|
|
extern int DICTprepare4append_vals(void **noffsets, void *vals, BUN cnt, BAT *dict);
|
|
|
|
extern BAT *FORdecompress_(BAT *o, lng minval, int tt, role_t role);
|
|
extern int FORprepare4append(BAT **noffsets, BAT *vals, lng minval, int tt);
|
|
extern int FORprepare4append_vals(void **noffsets, void *vals, BUN cnt, lng minval, int vtype, int ft);
|
|
|
|
#endif /*SQL_STORAGE_H */
|