//reset params here
params->user_table = user_table;
params->bucket_table = bucket_table;
+ params->quota_table = quota_table;
params->lc_entry_table = lc_entry_table;
params->lc_head_table = lc_head_table;
if (!params)
return -1;
- params->object_table = obj_table;
- params->objectdata_table = obj_data_table;
params->op.bucket.info.bucket.name = bucket_name;
params->op.obj.state.obj.key.name = obj_name;
params->op.obj.state.obj.key.instance = obj_instance;
if (!params)
return -1;
- params->object_table = store->getObjectTable(bucket);
- params->objectdata_table = store->getObjectDataTable(bucket);
params->op.bucket.info.bucket.name = bucket;
params->op.obj.state.obj = obj;
params->op.obj.obj_id = obj_id;
*meta.mtime = meta.set_mtime;
}
- /* XXX: handle multipart */
params.op.query_str = "meta";
params.op.obj.obj_id = target->obj_id;
ret = store->ProcessOp(dpp, "PutObject", ¶ms);
return r;
}
-int DB::Object::Write::update_mp_parts(const DoutPrefixProvider *dpp, rgw_obj_key new_obj_key)
-{
- int ret = 0;
- DBOpParams params = {};
- DB *store = target->get_store();
-
- store->InitializeParams(dpp, "UpdateObjectData", ¶ms);
- target->InitializeParamsfromObject(dpp, ¶ms);
-
- params.op.obj.new_obj_key = new_obj_key;
-
- ret = store->ProcessOp(dpp, "UpdateObjectData", ¶ms);
-
- if (ret) {
- ldpp_dout(dpp, 0)<<"In UpdateObjectData failed err:(" <<ret<<")" << dendl;
- return ret;
- }
-
- return 0;
-}
-
int DB::Object::Delete::delete_obj(const DoutPrefixProvider *dpp) {
int ret = 0;
DB *store = target->get_store();
store->InitializeParams(dpp, "DeleteObject", &del_params);
target->InitializeParamsfromObject(dpp, &del_params);
- /* As it is cascade delete, it will delete the objectdata table entries also */
ret = store->ProcessOp(dpp, "DeleteObject", &del_params);
if (ret) {
ldpp_dout(dpp, 0) << "In DeleteObject failed err:(" <<ret<<")" << dendl;
- goto out;
+ return ret;
}
-out:
- return ret;
+ /* Now that tail objects are associated with objectID, they are not deleted
+ * as part of this DeleteObj operation. Such tail objects (with no head object
+ * in *.object.table are cleaned up later by GC thread.
+ *
+ * To avoid races between writes/reads & GC delete, mtime is maintained for each
+ * tail object. This mtime is updated when tail object is written and also when
+ * its corresponding head object is deleted (like here in this case).
+ */
+ DBOpParams update_params = del_params;
+ update_params.op.obj.obj_id = astate->shadow_obj; // objectID is copied here in get_state()
+ update_params.op.obj.state.mtime = real_clock::now();
+ ret = store->ProcessOp(dpp, "UpdateObjectData", &update_params);
+
+ if (ret) {
+ ldpp_dout(dpp, 0) << "Updating tail objects mtime failed err:(" <<ret<<")" << dendl;
+ return ret;
+ }
+
+ return 0;
}
int DB::get_entry(const std::string& oid, const std::string& marker,
ldpp_dout(dpp, 0) << "In GetBucket failed err:(" <<ret<<")" << dendl;
}
- ldpp_dout(dpp, 30) << " Deleting stale_objs of bucket( " << bucket <<")" << dendl;
+ ldpp_dout(dpp, 20) << " Deleting stale_objs of bucket( " << bucket <<")" << dendl;
/* XXX: handle reads racing with delete here. Simple approach is maybe
* to use locks or sqlite transactions.
*/
InitializeParams(dpp, "DeleteStaleObjectData", ¶ms);
- params.op.obj.state.mtime = (real_clock::now() + make_timespan(min_wait));
+ params.op.obj.state.mtime = (real_clock::now() - make_timespan(min_wait));
ret = ProcessOp(dpp, "DeleteStaleObjectData", ¶ms);
if (ret) {
ldpp_dout(dpp, 0) << "In DeleteStaleObjectData failed err:(" <<ret<<")" << dendl;
rgw_user user;
user.id = user_marker;
buckets.clear();
+ is_truncated = false;
int r = db->list_buckets(dpp, "all", user, marker, string(),
max, false, &buckets, &is_truncated);
user_marker = user.id;
/* XXX: If using locks, unlock here and reacquire in the next iteration */
- std::this_thread::sleep_for(std::chrono::milliseconds(10));
+ std::this_thread::sleep_for(std::chrono::milliseconds(100));
}
} while(is_truncated);
bucket_marker.clear();
- std::this_thread::sleep_for(std::chrono::milliseconds(gc_interval));
+ std::this_thread::sleep_for(std::chrono::milliseconds(gc_interval*10));
} while(1);
std::string min_marker;
std::string max_marker;
std::list<rgw_bucket_dir_entry> list_entries;
- /* Below used to update mp_parts obj name
- * from meta object to src object on completion */
- rgw_obj_key new_obj_key;
+ /* XXX: Maybe use std::vector instead of std::list */
};
struct DBOpObjectDataInfo {
/* Ops*/
DBOpInfo op;
- /* Below are subject to change */
std::string objectdata_table;
+ std::string object_view;
std::string quota_table;
std::string lc_head_table;
std::string lc_entry_table;
DBOpPrepareInfo op;
- /* below subject to change */
std::string objectdata_table;
+ std::string object_view;
std::string quota_table;
std::string lc_head_table;
std::string lc_entry_table;
ObjAttrs BLOB, \
HeadSize INTEGER, \
MaxHeadSize INTEGER, \
- ObjID TEXT, \
+ ObjID TEXT NOT NULL, \
TailInstance TEXT, \
HeadPlacementRuleName TEXT, \
HeadPlacementRuleStorageClass TEXT, \
ObjInstance TEXT, \
ObjNS TEXT, \
BucketName TEXT NOT NULL , \
- ObjID String, \
+ ObjID TEXT NOT NULL , \
MultipartPartStr TEXT, \
PartNum INTEGER NOT NULL, \
Offset INTEGER, \
FOREIGN KEY (BucketName) \
REFERENCES '{}' (BucketName) ON DELETE CASCADE ON UPDATE CASCADE \n);";
+ const std::string CreateObjectViewQ =
+ /* This query creats temporary view with entries from ObjectData table which have
+ * corresponding head object (i.e, with same ObjName, ObjInstance, ObjNS, ObjID)
+ * in the Object table.
+ *
+ * GC thread can use this view to delete stale entries from the ObjectData table which
+ * do not exist in this view.
+ *
+ * XXX: This view is throwing ForeignKey mismatch error, mostly may be because all the keys
+ * of objectdata table are not referenced here. So this view is not used atm.
+ */
+ "CREATE TEMP VIEW IF NOT EXISTS '{}' AS \
+ SELECT s.ObjName, s.ObjInstance, s.ObjID from '{}' as s INNER JOIN '{}' USING \
+ (ObjName, BucketName, ObjInstance, ObjID);";
+
+
const std::string CreateQuotaTableQ =
"CREATE TABLE IF NOT EXISTS '{}' ( \
QuotaID INTEGER PRIMARY KEY AUTOINCREMENT UNIQUE , \
return fmt::format(CreateObjectDataTableQ.c_str(),
params->objectdata_table.c_str(),
params->bucket_table.c_str());
+ if (!type.compare("ObjectView"))
+ return fmt::format(CreateObjectTableQ.c_str(),
+ params->object_view.c_str(),
+ params->objectdata_table.c_str(),
+ params->object_table.c_str());
if (!type.compare("Quota"))
return fmt::format(CreateQuotaTableQ.c_str(),
params->quota_table.c_str());
private:
const std::string Query =
"UPDATE '{}' \
- SET ObjName = {}, ObjInstance = {}, ObjNS = {} \
- WHERE ObjName = {} and ObjInstance = {} and ObjNS = {} and \
- BucketName = {}";
+ SET Mtime = {} WHERE ObjName = {} and ObjInstance = {} and \
+ BucketName = {} and ObjID = {}";
public:
virtual ~UpdateObjectDataOp() {}
std::string Schema(DBOpPrepareParams ¶ms) {
return fmt::format(Query.c_str(),
params.objectdata_table.c_str(),
- params.op.obj.new_obj_name, params.op.obj.new_obj_instance,
- params.op.obj.new_obj_ns,
+ params.op.obj.mtime,
params.op.obj.obj_name, params.op.obj.obj_instance,
- params.op.obj.obj_ns,
- params.op.bucket.bucket_name.c_str());
+ params.op.bucket.bucket_name.c_str(),
+ params.op.obj.obj_id);
}
};
class GetObjectDataOp: virtual public DBOp {
class DeleteStaleObjectDataOp: virtual public DBOp {
private:
const std::string Query =
- "DELETE from '{}' WHERE (ObjName, ObjInstance, ObjID) NOT IN (SELECT s.ObjName, s.ObjInstance, s.ObjID from '{}' as s INNER JOIN '{}' USING (ObjName, BucketName, ObjInstance, ObjID)) and Mtime > {}";
+ "DELETE from '{}' WHERE (ObjName, ObjInstance, ObjID) NOT IN (SELECT s.ObjName, s.ObjInstance, s.ObjID from '{}' as s INNER JOIN '{}' USING (ObjName, BucketName, ObjInstance, ObjID)) and Mtime < {}";
public:
virtual ~DeleteStaleObjectDataOp() {}
public:
DB(std::string db_name, CephContext *_cct) : db_name(db_name),
- user_table(db_name+".user.table"),
- bucket_table(db_name+".bucket.table"),
- quota_table(db_name+".quota.table"),
- lc_head_table(db_name+".lc_head.table"),
- lc_entry_table(db_name+".lc_entry.table"),
+ user_table(db_name+"_user_table"),
+ bucket_table(db_name+"_bucket_table"),
+ quota_table(db_name+"_quota_table"),
+ lc_head_table(db_name+"_lc_head_table"),
+ lc_entry_table(db_name+"_lc_entry_table"),
cct(_cct),
dp(_cct, ceph_subsys_rgw, "rgw DBStore backend: ")
{}
/* DB() {}*/
DB(CephContext *_cct) : db_name("default_db"),
- user_table(db_name+".user.table"),
- bucket_table(db_name+".bucket.table"),
- quota_table(db_name+".quota.table"),
- lc_head_table(db_name+".lc_head.table"),
- lc_entry_table(db_name+".lc_entry.table"),
+ user_table(db_name+"_user_table"),
+ bucket_table(db_name+"_bucket_table"),
+ quota_table(db_name+"_quota_table"),
+ lc_head_table(db_name+"_lc_head_table"),
+ lc_entry_table(db_name+"_lc_entry_table"),
cct(_cct),
dp(_cct, ceph_subsys_rgw, "rgw DBStore backend: ")
{}
const std::string getLCHeadTable() { return lc_head_table; }
const std::string getLCEntryTable() { return lc_entry_table; }
const std::string getObjectTable(std::string bucket) {
- return db_name+"."+bucket+".object.table"; }
+ return db_name+"_"+bucket+"_object_table"; }
const std::string getObjectDataTable(std::string bucket) {
- return db_name+"."+bucket+".objectdata.table"; }
+ return db_name+"_"+bucket+"_objectdata_table"; }
+ const std::string getObjectView(std::string bucket) {
+ return db_name+"_"+bucket+"_object_view"; }
std::map<std::string, class ObjectOp*> getObjectMap();
virtual int createTables(const DoutPrefixProvider *dpp) { return 0; }
virtual int InitializeDBOps(const DoutPrefixProvider *dpp) { return 0; }
virtual int FreeDBOps(const DoutPrefixProvider *dpp) { return 0; }
- virtual int InitPrepareParams(const DoutPrefixProvider *dpp, DBOpPrepareParams ¶ms) = 0;
+ virtual int InitPrepareParams(const DoutPrefixProvider *dpp,
+ DBOpPrepareParams &p_params,
+ DBOpParams* params) = 0;
virtual int createLCTables(const DoutPrefixProvider *dpp) = 0;
virtual int ListAllBuckets(const DoutPrefixProvider *dpp, DBOpParams *params) = 0;
* gc_obj_min_wait: Min. time to wait before deleting any data post its creation.
*
*/
- uint32_t gc_interval = 24*60*60*10; //msec ; default: 24*60*60*10
- uint32_t gc_obj_min_wait = 600; //600sec default
+ uint32_t gc_interval = 24*60*60; //sec ; default: 24*60*60
+ uint32_t gc_obj_min_wait = 60*60; //60*60sec default
std::string bucket_marker;
std::string user_marker;
bool assume_noent, bool modify_tail);
int write_meta(const DoutPrefixProvider *dpp, uint64_t size,
uint64_t accounted_size, std::map<std::string, bufferlist>& attrs);
- /* Below are used to update mp data rows object name
- * from meta to src object name on multipart upload
- * completion
- */
- int update_mp_parts(const DoutPrefixProvider *dpp, rgw_obj_key new_obj_key);
};
struct Delete {
rc = -1; \
goto out; \
} \
+ ldpp_dout(dpp, 20)<<"Bind parameter text for index(" \
+ <<index<<") in stmt("<<stmt<<") is " \
+ <<str<< dendl; \
}while(0);
#define SQL_BIND_INT(dpp, stmt, index, num, sdb) \
rc = -1; \
goto out; \
} \
+ ldpp_dout(dpp, 20)<<"Bind parameter int for index(" \
+ <<index<<") in stmt("<<stmt<<") is " \
+ <<num<< dendl; \
}while(0);
#define SQL_BIND_BLOB(dpp, stmt, index, blob, size, sdb) \
} \
}while(0);
+int SQLiteDB::InitPrepareParams(const DoutPrefixProvider *dpp,
+ DBOpPrepareParams &p_params,
+ DBOpParams* params)
+{
+ std::string bucket;
+
+ if (!params)
+ return -1;
+
+ if (params->user_table.empty()) {
+ params->user_table = getUserTable();
+ }
+ if (params->user_table.empty()) {
+ params->user_table = getUserTable();
+ }
+ if (params->bucket_table.empty()) {
+ params->bucket_table = getBucketTable();
+ }
+ if (params->quota_table.empty()) {
+ params->quota_table = getQuotaTable();
+ }
+ if (params->lc_entry_table.empty()) {
+ params->lc_entry_table = getLCEntryTable();
+ }
+ if (params->lc_head_table.empty()) {
+ params->lc_head_table = getLCHeadTable();
+ }
+
+ p_params.user_table = params->user_table;
+ p_params.bucket_table = params->bucket_table;
+ p_params.quota_table = params->quota_table;
+ p_params.lc_entry_table = params->lc_entry_table;
+ p_params.lc_head_table = params->lc_head_table;
+
+ p_params.op.query_str = params->op.query_str;
+
+ bucket = params->op.bucket.info.bucket.name;
+
+ if (!bucket.empty()) {
+ if (params->object_table.empty()) {
+ params->object_table = getObjectTable(bucket);
+ }
+ if (params->objectdata_table.empty()) {
+ params->objectdata_table = getObjectDataTable(bucket);
+ }
+ if (params->object_view.empty()) {
+ params->object_view = getObjectView(bucket);
+ }
+ p_params.object_table = params->object_table;
+ p_params.objectdata_table = params->objectdata_table;
+ p_params.object_view = params->object_view;
+ }
+
+ return 0;
+}
+
static int list_callback(void *None, int argc, char **argv, char **aname)
{
int i;
- for(i=0; i<argc; i++) {
+ for(i=0; i < argc; i++) {
string arg = argv[i] ? argv[i] : "NULL";
cout<<aname[i]<<" = "<<arg<<"\n";
}
ObjAttrs,
HeadSize,
MaxHeadSize,
- Prefix,
+ ObjID,
TailInstance,
HeadPlacementRuleName,
HeadPlacementRuleStorageClass,
SQL_DECODE_BLOB_PARAM(dpp, stmt, ObjAttrs, op.obj.state.attrset, sdb);
op.obj.head_size = sqlite3_column_int(stmt, HeadSize);
op.obj.max_head_size = sqlite3_column_int(stmt, MaxHeadSize);
- op.obj.obj_id = (const char*)sqlite3_column_text(stmt, Prefix);
+ op.obj.obj_id = (const char*)sqlite3_column_text(stmt, ObjID);
op.obj.tail_instance = (const char*)sqlite3_column_text(stmt, TailInstance);
op.obj.head_placement_rule.name = (const char*)sqlite3_column_text(stmt, HeadPlacementRuleName);
op.obj.head_placement_rule.storage_class = (const char*)sqlite3_column_text(stmt, HeadPlacementRuleStorageClass);
return ret;
}
+int SQLiteDB::createObjectView(const DoutPrefixProvider *dpp, DBOpParams *params)
+{
+ int ret = -1;
+ string schema;
+
+ schema = CreateTableSchema("ObjectView", params);
+
+ ret = exec(dpp, schema.c_str(), NULL);
+ if (ret)
+ ldpp_dout(dpp, 0)<<"CreateObjectView failed " << dendl;
+
+ ldpp_dout(dpp, 20)<<"CreateObjectView suceeded " << dendl;
+
+ return ret;
+}
+
int SQLiteDB::createQuotaTable(const DoutPrefixProvider *dpp, DBOpParams *params)
{
int ret = -1;
goto out;
}
- p_params.user_table = params->user_table;
+ InitPrepareParams(dpp, p_params, params);
SQL_PREPARE(dpp, p_params, sdb, stmt, ret, "PrepareInsertUser");
out:
goto out;
}
- p_params.user_table = params->user_table;
+ InitPrepareParams(dpp, p_params, params);
SQL_PREPARE(dpp, p_params, sdb, stmt, ret, "PrepareRemoveUser");
out:
goto out;
}
- p_params.user_table = params->user_table;
- p_params.op.query_str = params->op.query_str;
+ InitPrepareParams(dpp, p_params, params);
if (params->op.query_str == "email") {
SQL_PREPARE(dpp, p_params, sdb, email_stmt, ret, "PrepareGetUser");
goto out;
}
- p_params.bucket_table = params->bucket_table;
+ InitPrepareParams(dpp, p_params, params);
SQL_PREPARE(dpp, p_params, sdb, stmt, ret, "PrepareInsertBucket");
int ret = -1;
class SQLObjectOp *ObPtr = NULL;
string bucket_name = params->op.bucket.info.bucket.name;
+ struct DBOpPrepareParams p_params = PrepareParams;
ObPtr = new SQLObjectOp(sdb, ctx());
objectmapInsert(dpp, bucket_name, ObPtr);
SQL_EXECUTE(dpp, params, stmt, NULL);
+
+ /* Once Bucket is inserted created corresponding object(&data) tables
+ */
+ InitPrepareParams(dpp, p_params, params);
+
+ (void)createObjectTable(dpp, params);
+ (void)createObjectDataTable(dpp, params);
out:
return ret;
}
goto out;
}
- p_params.op.query_str = params->op.query_str;
- p_params.bucket_table = params->bucket_table;
+ InitPrepareParams(dpp, p_params, params);
if (params->op.query_str == "attrs") {
SQL_PREPARE(dpp, p_params, sdb, attrs_stmt, ret, "PrepareUpdateBucket");
goto out;
}
- p_params.bucket_table = params->bucket_table;
+ InitPrepareParams(dpp, p_params, params);
SQL_PREPARE(dpp, p_params, sdb, stmt, ret, "PrepareRemoveBucket");
goto out;
}
- p_params.bucket_table = params->bucket_table;
- p_params.user_table = params->user_table;
+ InitPrepareParams(dpp, p_params, params);
SQL_PREPARE(dpp, p_params, sdb, stmt, ret, "PrepareGetBucket");
goto out;
}
- p_params.bucket_table = params->bucket_table;
+ InitPrepareParams(dpp, p_params, params);
- p_params.op.query_str = params->op.query_str;
if (params->op.query_str == "all") {
SQL_PREPARE(dpp, p_params, sdb, all_stmt, ret, "PrepareListUserBuckets");
}else {
{
int ret = -1;
struct DBOpPrepareParams p_params = PrepareParams;
- struct DBOpParams copy = *params;
- string bucket_name = params->op.bucket.info.bucket.name;
if (!*sdb) {
ldpp_dout(dpp, 0)<<"In SQLPutObject - no db" << dendl;
goto out;
}
- if (p_params.object_table.empty()) {
- p_params.object_table = getObjectTable(bucket_name);
- }
- params->object_table = p_params.object_table;
- (void)createObjectTable(dpp, params);
-
+ InitPrepareParams(dpp, p_params, params);
SQL_PREPARE(dpp, p_params, sdb, stmt, ret, "PreparePutObject");
out:
{
int ret = -1;
struct DBOpPrepareParams p_params = PrepareParams;
- struct DBOpParams copy = *params;
- string bucket_name = params->op.bucket.info.bucket.name;
if (!*sdb) {
ldpp_dout(dpp, 0)<<"In SQLDeleteObject - no db" << dendl;
goto out;
}
- if (p_params.object_table.empty()) {
- p_params.object_table = getObjectTable(bucket_name);
- }
- params->object_table = p_params.object_table;
- (void)createObjectTable(dpp, params);
-
+ InitPrepareParams(dpp, p_params, params);
SQL_PREPARE(dpp, p_params, sdb, stmt, ret, "PrepareDeleteObject");
out:
{
int ret = -1;
struct DBOpPrepareParams p_params = PrepareParams;
- struct DBOpParams copy = *params;
- string bucket_name = params->op.bucket.info.bucket.name;
if (!*sdb) {
ldpp_dout(dpp, 0)<<"In SQLGetObject - no db" << dendl;
goto out;
}
- if (p_params.object_table.empty()) {
- p_params.object_table = getObjectTable(bucket_name);
- }
- params->object_table = p_params.object_table;
- (void)createObjectTable(dpp, params);
-
+ InitPrepareParams(dpp, p_params, params);
SQL_PREPARE(dpp, p_params, sdb, stmt, ret, "PrepareGetObject");
out:
goto out;
}
- if (p_params.object_table.empty()) {
- bucket_name = params->op.bucket.info.bucket.name;
- p_params.object_table = getObjectTable(bucket_name);
- }
-
- p_params.op.query_str = params->op.query_str;
+ InitPrepareParams(dpp, p_params, params);
if (params->op.query_str == "omap") {
SQL_PREPARE(dpp, p_params, sdb, omap_stmt, ret, "PrepareUpdateObject");
{
int ret = -1;
struct DBOpPrepareParams p_params = PrepareParams;
- struct DBOpParams copy = *params;
- string bucket_name;
if (!*sdb) {
ldpp_dout(dpp, 0)<<"In SQLListBucketObjects - no db" << dendl;
goto out;
}
- if (p_params.object_table.empty()) {
- bucket_name = params->op.bucket.info.bucket.name;
- p_params.object_table = getObjectTable(bucket_name);
- }
-
- /* XXX: instead of creating..maybe keep object count in bucket info
- * and return if there is no object table created.
- */
- params->object_table = p_params.object_table;
- (void)createObjectTable(dpp, params);
-
- p_params.op.query_str = params->op.query_str;
+ InitPrepareParams(dpp, p_params, params);
SQL_PREPARE(dpp, p_params, sdb, stmt, ret, "PrepareListBucketObjects");
{
int ret = -1;
struct DBOpPrepareParams p_params = PrepareParams;
- struct DBOpParams copy = *params;
- string bucket_name = params->op.bucket.info.bucket.name;
if (!*sdb) {
ldpp_dout(dpp, 0)<<"In SQLPutObjectData - no db" << dendl;
goto out;
}
- if (p_params.object_table.empty()) {
- p_params.object_table = getObjectTable(bucket_name);
- }
- if (p_params.objectdata_table.empty()) {
- p_params.objectdata_table = getObjectDataTable(bucket_name);
- }
- params->object_table = p_params.object_table;
- params->objectdata_table = p_params.objectdata_table;
- (void)createObjectDataTable(dpp, params);
+ InitPrepareParams(dpp, p_params, params);
SQL_PREPARE(dpp, p_params, sdb, stmt, ret, "PreparePutObjectData");
{
int ret = -1;
struct DBOpPrepareParams p_params = PrepareParams;
- struct DBOpParams copy = *params;
- string bucket_name = params->op.bucket.info.bucket.name;
if (!*sdb) {
ldpp_dout(dpp, 0)<<"In SQLUpdateObjectData - no db" << dendl;
goto out;
}
- if (p_params.object_table.empty()) {
- p_params.object_table = getObjectTable(bucket_name);
- }
- if (p_params.objectdata_table.empty()) {
- p_params.objectdata_table = getObjectDataTable(bucket_name);
- }
- params->bucket_table = p_params.bucket_table;
- params->object_table = p_params.object_table;
- params->objectdata_table = p_params.objectdata_table;
- (void)createObjectDataTable(dpp, params);
-
+ InitPrepareParams(dpp, p_params, params);
SQL_PREPARE(dpp, p_params, sdb, stmt, ret, "PrepareUpdateObjectData");
out:
struct DBOpPrepareParams p_params = PrepareParams;
SQL_BIND_INDEX(dpp, stmt, index, p_params.op.obj.obj_name.c_str(), sdb);
-
SQL_BIND_TEXT(dpp, stmt, index, params->op.obj.state.obj.key.name.c_str(), sdb);
SQL_BIND_INDEX(dpp, stmt, index, p_params.op.obj.obj_instance.c_str(), sdb);
-
SQL_BIND_TEXT(dpp, stmt, index, params->op.obj.state.obj.key.instance.c_str(), sdb);
- SQL_BIND_INDEX(dpp, stmt, index, p_params.op.obj.obj_ns.c_str(), sdb);
-
- SQL_BIND_TEXT(dpp, stmt, index, params->op.obj.state.obj.key.ns.c_str(), sdb);
-
SQL_BIND_INDEX(dpp, stmt, index, p_params.op.bucket.bucket_name.c_str(), sdb);
-
SQL_BIND_TEXT(dpp, stmt, index, params->op.bucket.info.bucket.name.c_str(), sdb);
- SQL_BIND_INDEX(dpp, stmt, index, p_params.op.obj.new_obj_name.c_str(), sdb);
-
- SQL_BIND_TEXT(dpp, stmt, index, params->op.obj.new_obj_key.name.c_str(), sdb);
-
- SQL_BIND_INDEX(dpp, stmt, index, p_params.op.obj.new_obj_instance.c_str(), sdb);
-
- SQL_BIND_TEXT(dpp, stmt, index, params->op.obj.new_obj_key.instance.c_str(), sdb);
-
- SQL_BIND_INDEX(dpp, stmt, index, p_params.op.obj.new_obj_ns.c_str(), sdb);
+ SQL_BIND_INDEX(dpp, stmt, index, p_params.op.obj.obj_id.c_str(), sdb);
+ SQL_BIND_TEXT(dpp, stmt, index, params->op.obj.obj_id.c_str(), sdb);
- SQL_BIND_TEXT(dpp, stmt, index, params->op.obj.new_obj_key.ns.c_str(), sdb);
+ SQL_BIND_INDEX(dpp, stmt, index, p_params.op.obj.mtime.c_str(), sdb);
+ SQL_ENCODE_BLOB_PARAM(dpp, stmt, index, params->op.obj.state.mtime, sdb);
out:
return rc;
{
int ret = -1;
struct DBOpPrepareParams p_params = PrepareParams;
- struct DBOpParams copy = *params;
- string bucket_name = params->op.bucket.info.bucket.name;
if (!*sdb) {
ldpp_dout(dpp, 0)<<"In SQLGetObjectData - no db" << dendl;
goto out;
}
- if (p_params.object_table.empty()) {
- p_params.object_table = getObjectTable(bucket_name);
- }
- if (p_params.objectdata_table.empty()) {
- p_params.objectdata_table = getObjectDataTable(bucket_name);
- }
- params->object_table = p_params.object_table;
- params->objectdata_table = p_params.objectdata_table;
- (void)createObjectDataTable(dpp, params);
-
+ InitPrepareParams(dpp, p_params, params);
SQL_PREPARE(dpp, p_params, sdb, stmt, ret, "PrepareGetObjectData");
out:
{
int ret = -1;
struct DBOpPrepareParams p_params = PrepareParams;
- struct DBOpParams copy = *params;
- string bucket_name = params->op.bucket.info.bucket.name;
if (!*sdb) {
ldpp_dout(dpp, 0)<<"In SQLDeleteObjectData - no db" << dendl;
goto out;
}
- if (p_params.object_table.empty()) {
- p_params.object_table = getObjectTable(bucket_name);
- }
- if (p_params.objectdata_table.empty()) {
- p_params.objectdata_table = getObjectDataTable(bucket_name);
- }
- params->object_table = p_params.object_table;
- params->objectdata_table = p_params.objectdata_table;
- (void)createObjectDataTable(dpp, params);
-
+ InitPrepareParams(dpp, p_params, params);
SQL_PREPARE(dpp, p_params, sdb, stmt, ret, "PrepareDeleteObjectData");
out:
{
int ret = -1;
struct DBOpPrepareParams p_params = PrepareParams;
- struct DBOpParams copy = *params;
- string bucket_name = params->op.bucket.info.bucket.name;
if (!*sdb) {
ldpp_dout(dpp, 0)<<"In SQLDeleteStaleObjectData - no db" << dendl;
goto out;
}
- if (p_params.object_table.empty()) {
- p_params.object_table = getObjectTable(bucket_name);
- }
- if (p_params.objectdata_table.empty()) {
- p_params.objectdata_table = getObjectDataTable(bucket_name);
- }
- params->object_table = p_params.object_table;
- params->objectdata_table = p_params.objectdata_table;
- (void)createObjectDataTable(dpp, params);
-
+ InitPrepareParams(dpp, p_params, params);
SQL_PREPARE(dpp, p_params, sdb, stmt, ret, "PrepareDeleteStaleObjectData");
out:
goto out;
}
- p_params.lc_entry_table = params->lc_entry_table;
+ InitPrepareParams(dpp, p_params, params);
SQL_PREPARE(dpp, p_params, sdb, stmt, ret, "PrepareInsertLCEntry");
goto out;
}
- p_params.lc_entry_table = params->lc_entry_table;
+ InitPrepareParams(dpp, p_params, params);
SQL_PREPARE(dpp, p_params, sdb, stmt, ret, "PrepareRemoveLCEntry");
goto out;
}
- p_params.lc_entry_table = params->lc_entry_table;
- p_params.op.query_str = params->op.query_str;
+ InitPrepareParams(dpp, p_params, params);
if (params->op.query_str == "get_next_entry") {
pstmt = &next_stmt;
goto out;
}
- p_params.lc_entry_table = params->lc_entry_table;
+ InitPrepareParams(dpp, p_params, params);
SQL_PREPARE(dpp, p_params, sdb, stmt, ret, "PrepareListLCEntries");
goto out;
}
- p_params.lc_head_table = params->lc_head_table;
+ InitPrepareParams(dpp, p_params, params);
SQL_PREPARE(dpp, p_params, sdb, stmt, ret, "PrepareInsertLCHead");
goto out;
}
- p_params.lc_head_table = params->lc_head_table;
+ InitPrepareParams(dpp, p_params, params);
SQL_PREPARE(dpp, p_params, sdb, stmt, ret, "PrepareRemoveLCHead");
goto out;
}
- p_params.lc_head_table = params->lc_head_table;
+ InitPrepareParams(dpp, p_params, params);
SQL_PREPARE(dpp, p_params, sdb, stmt, ret, "PrepareGetLCHead");
projects / ceph.git / commitdiff